DEV Community: Damian Esteban

Building a Serverless GraphQL Yoga Server with TypeScript on Cloudflare Workers with Cloudflare KV

Damian Esteban — Tue, 22 Aug 2023 22:06:11 +0000

Hello, friends! I'm thrilled to launch a series of blog posts focused on Cloudflare Workers, an innovative platform that's revolutionizing the web development landscape.

Cloudflare Workers is a trailblazer in edge computing, executing code near the user for enhanced speed and security. It's like having a superhuman guardian for your web application, ensuring rapid and secure delivery. The next time I have the opportunity to build a platform from scratch, I plan to make heavy use of Cloudflare Workers. If you are interested in knowing more, please reach out to me 😉.

As a huge supporter of this platform, I'm eager to showcase its capabilities. In this series, we'll explore Cloudflare Workers, experiment with its features like KV, Durable Objects, Cloudflare Queues, and D1.

In this inaugural post, I'll guide you through building a simple GraphQL Yoga server with TypeScript on Cloudflare Workers. Why? Because my passion for GraphQL is as strong as my admiration for Cloudflare Workers, and these two technologies harmonize perfectly.

Yoga, along with numerous other GraphQL Projects, is maintained by The Guild. Their approach to software design is outstanding and I am a big fan. In a subsequent post, I will integrate GraphQL over SSE into our project.

In this tutorial, we've chosen to use 'animal rescues' as our API's data. This choice is not arbitrary; I am currently developing an open-source Animal Rescue & Shelter Management application. This project is a testament to my commitment to leveraging technology for social good, and it provides a practical context for this tutorial. By sharing this with you, I hope to inspire more engineers to contribute to open-source projects and use their skills to make a positive impact.

Let's do this.

Step 1: Setting Up Your Project

Firstly, let's initiate our project with c3. Make sure to select "Hello World" for a blank slate and choose TypeScript.

npm create cloudflare

Next, install the necessary libraries:

npm install graphql graphql-yoga

Finally, let's create two KV namespaces:

wrangler kv:namespace create Animal_Rescues_KV

wrangler kv:namespace create Animal_Rescues_KV --preview

You will see the following output in your terminal:

 ⛅️ wrangler 3.0.0 (update available 3.4.0)
-----------------------------------------------------
🌀 Creating namespace with title "damp-block-4742-Animal_Rescues_KV"
✨ Success!
Add the following to your configuration file in your kv_namespaces array:
{ binding = "Animal_Rescues_KV", id = "6e07585309964f36a11e058aadcc8968" }

 ⛅️ wrangler 3.0.0 (update available 3.4.0)
-----------------------------------------------------
🌀 Creating namespace with title "damp-block-4742-Animal_Rescues_KV_preview"
✨ Success!
Add the following to your configuration file in your kv_namespaces array:
{ binding = "Animal_Rescues_KV", preview_id = "d3c1f3203ee24db4849194701e6ee741" }

Go ahead and edit your wrangler.toml file, and add the KV namespaces:

name = "damp-block-4742"
main = "src/worker.ts"
compatibility_date = "2023-07-24"

[[kv_namespaces]]
binding = "Animal_Rescues_KV"
id = "6e07585309964f36a11e058aadcc8968"
preview_id = "d3c1f3203ee24db4849194701e6ee741"

Step 2: Creating Your GraphQL Server

Edit the src/worker.ts file and add the following code:

import { createSchema, createYoga } from 'graphql-yoga';
import gql from 'graphql-tag';
import { nanoid } from 'nanoid';

// Workers Env
export interface Env {
  Animal_Rescues_KV: KVNamespace;
}

// Create Yoga server with schema and resolvers
const yoga = createYoga<Env>({
  schema: createSchema({
    typeDefs: gql`

      enum AnimalRescueSpecies {
        DOG
        CAT
      }
      type AnimalRescue {
        id: ID!
        name: String!
        species: AnimalRescueSpecies!
      }

      type Query {
        animalRescue(id: ID!): AnimalRescue
        animalRescues: [AnimalRescue]
      }

      type Mutation {
        addAnimalRescue(name: String!, species: AnimalRescueSpecies): AnimalRescue
      }
    `,
    resolvers: {
      Query: {
        animalRescue: async (_, { id }, { Animal_Rescues_KV }) => {
          const value = await Animal_Rescues_KV.get(id);
          console.log('value', value);
          return JSON.parse(value!);
        },
        animalRescues: async (_, {}, { Animal_Rescues_KV }) => {
          const records = await Animal_Rescues_KV.list();

          const allRecords = await Promise.all(records.keys.map((k) => Animal_Rescues_KV.get(k.name)));
          const parsed = allRecords.map((r) => JSON.parse(r!));
          return parsed;
        },
      },
      Mutation: {
        addAnimalRescue: async (_, { name, species }, { Animal_Rescues_KV }) => {
          const newAnimalRescue = {
            name,
            species,
            id: nanoid(),
          };
          await Animal_Rescues_KV.put(newAnimalRescue.id, JSON.stringify(newAnimalRescue));
          return newAnimalRescue;
        },
      },
    },
  }),
});

// Fetch handler
export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    return yoga.fetch(request, env);
  },
};

Here's what we did:

Added the Animal_Rescues_KV to the Env interface.
Created our schema and resolvers. Notice how Animal_Rescues_KV is available for us by default in the context.
In our resolvers, we use Animal_Rescues_KV as out datasource. We will go into more detail about KV in another blog post.
Finally, we created our GraphQL Yoga server and added it to our fetch handler. It's amazing how easy it is to get up and running with GraphQL Yoga.

Step 4: Deployment

Provided you're logged in with wrangler, you only need to run the following:

wrangler publish

Our GraphQL Yoga server is now running on Cloudflare Workers. Visit https://your-worker-name.<your-account>.workers.dev/graphql and you'll see the GraphiQL interface with your schema. Go ahead and add some data with a mutation and then perform a query. It works!

Conclusion

In this tutorial, we've explored how to build a GraphQL Yoga server with TypeScript + KV, and deploy it on Cloudflare Workers. This setup leverages the power of GraphQL and the scalability of serverless computing. I hope you find this tutorial helpful, and I encourage you to delve deeper into these technologies. If you have any questions, feel free to reach out to me on Twitter. In our next post, we will explore Durable Objects. I'm excited!

You can find the source code for this blog post here.

Originally published on my blog.

A Simple CRUD API in Rust with Cloudflare Workers, Cloudflare KV, and the Rust Router

Damian Esteban — Tue, 22 Aug 2023 17:13:00 +0000

Introduction

Greetings readers! I had originally planned to cover Cloudflare Durable Objects in this post. However, I've decided to hold off on that topic until we dig into some more Rust basics for Cloudflare Workers.

I'm really enjoying my journey with Rust so far. My Swift experience makes picking up Rust fairly intuitive, though naturally there are differences like Rust's unique memory management model. We may do a Swift vs Rust comparison another time - that would be cool.

For now, I want to focus on building simple CRUD APIs with Rust and Workers. We will use the Cloudflare worker crate to build our API. The worker crate is a framework for building Cloudflare Workers in Rust. It provides a high-level API for interacting with the Cloudflare Workers API. Please note that this library is still in development, so some things may change in the future. See the GitHub repo for more information.

For routing and request handling, we'll utilize the handy Router from the worker crate. It provides a flexible API for defining routes and handlers to get up and running quickly.

To serialize and deserialize data, we'll employ the popular serde crate along with serde_json. This will allow us to easily convert between Rust types and JSON when working with API requests and responses. For async operations we'll use the Rust futures crate.

Finally, for peristence we'll use Cloudflare KV.

By leveraging the Router for concise routing and serde for data serialization, we get powerful libraries purpose-built for API development in Workers. This combination sets us up for productive and idiomatic API development in Rust.

By the end, you'll see how straightforward it is to create fast, resilient APIs in Rust on the Workers platform.

Let's get started.

Why Rust?

Rust is a modern systems programming language that emphasizes safety, speed, and concurrency. With its excellent performance and low resource usage, Rust is a great fit for building highly scalable serverless functions on platforms like Cloudflare Workers.

One key advantage of using Rust for Cloudflare Workers is its excellent WebAssembly (WASM) support. Rust code can be efficiently compiled to WASM bytecode and executed with near-native performance in the browser. This makes it a fantastic fit for the serverless computing model of Cloudflare Workers. The generated WASM module is uploaded to Cloudflare's edge network during deployment, where it can quickly scale to handle requests across global data centers. By leveraging Rust and WASM, we get safe, fast code with tiny bundles that load quickly. For our API, this means low-latency and resilient performance for end users, while keeping costs low on the serverless backend. Rust's lightweight threading model also shines in the concurrent environment of Workers.

In this tutorial, we'll use Rust and Workers to build a simple CRUD (Create, Read, Update, Delete) API that allows us to manage data for an animal rescue organization.

Overview

Our API will support the following endpoints:

POST /rescues - Create a new animal rescue record
PUT /rescues/:id - Update an existing rescue record
DELETE /rescues/:id - Delete a rescue record
GET /rescues - Get all rescue records
GET /rescue/:id - Get a rescue record by ID
GET /shared-data - Get some shared data accessible across requests

Get Started

To get started, create a new Cloudflare Workers project with Rust support:

npm init cloudflare project_name worker-rust
cd project_name

Take a look in src/lib.rs. You'll see a simple "Hello World" example. This is the entry point for our Worker. We'll replace this with our API code. Be sure to add serde and serde_json to your project:

cargo add serde
cargo add serde_json
cargo add futures

Implementing the API

NOTE: Please see this article if you need help setting up Workers KV for your project. The final code at the end of the article contains comments explaining each section. You can find the full code here.

Let's walk through the code step-by-step.

First we import the required crates:

use worker::*;
use serde::{Deserialize, Serialize};
use serde_json::to_string;
use futures::future::join_all; // For async iteration

Next we define a few structs to represent the data:

// This is a shared data struct that we will pass to the router
struct SharedData {
    name: String,
}

// This is the struct that we will use to store and retrieve data from KV. It implements Serialize and Deserialize
#[derive(Clone, Debug, Deserialize, Serialize)]
struct AnimalRescue {
    id: u8,
    name: String,
    age: u8,
    species: String,
}

// This is the struct that we will use to update data in KV. It implements Serialize and Deserialize
#[derive(Clone, Debug, Deserialize, Serialize)]
struct AnimalRescueUpdate {
    name: String,
    age: u8,
    species: String,
}

SharedData holds some data we want to share across requests. I've added this here as an example of the Rust Router's support for storing state. We'll use this later to demonstrate how to access shared data from a request handler.

AnimalRescue will be used to represent individual rescue records, andAnimalRescueUpdate will be used to upload a record. We derive Serialize and Deserialize so it can easily be converted to/from JSON.

In the main worker module, we first grab the shared data and create a router:

#[event(fetch)]
pub async fn main(req: Request, env: Env, _ctx: Context) -> Result<Response> {

  let shared_data = SharedData {
    name: "Rusty".to_string(),
  };

  let router = Router::with_data(shared_data);
  router.run(req, env).await
}

Then we configure the CRUD routes on the router:

router
  .get("/shared-data", |_, ctx| {
      let shared_data = ctx.data.name;
      Response::ok(shared_data)
  })
  .post_async("/rescues", |mut req, ctx| async move {
    // Create rescue logic
  })
  .get_async("/rescues/:id", |req, ctx| async move {
    // Read rescue logic
  })
  .get_async("/rescues", |req, ctx| async move {
    // Read all rescues logic
  })
  .delete_async("/rescues/:id", |req, ctx| async move {
    // Delete rescue logic
  })
  .put_async("/rescues/:id", |mut req, ctx| async move {
    // Update rescue logic
  })

To handle POST requests, we deserialize the JSON body, write to KV, and return the created record:

  .post_async("/rescues", |mut req, ctx| async move {
      let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;
      let body = req.json::<AnimalRescue>().await?;
      let value = to_string(&body)?;
      kv.put(&body.id.to_string(), value)?.execute().await?;
      Response::from_json(&body)
  })

For GET, we fetch the record or records from KV and handle if missing:

  .get_async("/rescues/:id", |_req, ctx | async move {
        if let Some(id) = ctx.param("id") {
            let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;
            return match kv.get(id).json::<AnimalRescue>().await? {
                Some(animal) => Response::from_json(&animal),
                None => Response::error("Animal not found", 404)
            };
        }
        Response::error("Animal not found", 404)
    })
    .get_async("/rescues", |_req, ctx | async move {
        let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;

        let keys = kv
            .list()
            .execute()
            .await?
            .keys;

        console_debug!("{:?}", keys);

        let key_names = keys
            .into_iter()
            .map(|key| key.name)
            .collect::<Vec<String>>();

        console_debug!("{:?}", key_names);

        let futures = key_names
            .iter()
            .map(|key| kv.get(key).json::<AnimalRescue>());

        let animals = join_all(futures)
            .await
            .into_iter()
            .filter_map(|animal| animal.ok())
            .collect::<Vec<_>>().into_iter()
            .map(|animal| animal)
            .collect::<Vec<_>>();

        let final_result = Response::from_json(&animals);
        console_debug!("Final Result: \n {:?}", &final_result);

        final_result
    })

For PUT we fetch and update the record:

 .put_async("/rescues/:id", |mut req, ctx| async move {
          if let Some(id) = ctx.param("id") {
              let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;
              let body = req.json::<AnimalRescueUpdate>().await?;
              if kv.get(id).json::<AnimalRescue>().await?.is_none() {
                  return Response::error("Animal not found", 404);
              }

              let new_animal = AnimalRescue {
                  id: id.parse::<u8>().unwrap(),
                  name: body.name,
                  age: body.age,
                  species: body.species,
              };

              let value = to_string(&new_animal)?;
              kv.put(&id, value)?.execute().await?;
              return Response::from_json(&new_animal);
          }
          Response::error("Animal not found", 404)
      })

Finally, for DELETE we fetch and delete the record:

.delete_async("/rescues/:id", |_req, ctx| async move {
    if let Some(id) = ctx.param("id") {
        let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;
        return match kv.delete(id).await {
            Ok(_) => Response::ok("").map(|resp| resp.with_status(204)),
            Err(e) => Response::error(e.to_string(), 404)
        };
    }
    Response::error("Animal not found", 404)
})

Here it is all together with comments explaining each section:

use worker::*;
use serde::{Deserialize, Serialize};
use serde_json::to_string;
use futures::future::join_all;

// This is a shared data struct that we will pass to the router
struct SharedData {
    name: String,
}

// This is the struct that we will use to store and retrieve data from KV. It implements Serialize and Deserialize
#[derive(Clone, Debug, Deserialize, Serialize)]
struct AnimalRescue {
    id: u8,
    name: String,
    age: u8,
    species: String,
}

// This is the struct that we will use to update data in KV. It implements Serialize and Deserialize
#[derive(Clone, Debug, Deserialize, Serialize)]
struct AnimalRescueUpdate {
    name: String,
    age: u8,
    species: String,
}

#[event(fetch)]
async fn main(req: Request, env: Env, _ctx: Context) -> Result<Response> {
    // Shared data is accessible across requests
    let shared_data = SharedData {
        name: "Rustacean".to_string(),
    };

    // Create a new router with the shared data
    let router = Router::with_data(shared_data);

    // Router definition
    router
        .get("/shared-data", |_, ctx| {
             // Get the shared data from the context. This is available because we used with_data above.
            let shared_data = ctx.data.name;
            // Return the response
            Response::ok(shared_data)
        })
        .post_async("/rescues", |mut req, ctx| async move {
             // Get the KV namespace
            let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;
            // Get the body of the request - Note that AnimalRescue implements Deserialize
            let body = req.json::<AnimalRescue>().await?;
            // Serialize the body to a string
            let value = to_string(&body)?;
            // Store the value in KV
            kv.put(&body.id.to_string(), value)?.execute().await?;
            // Return the response
            Response::from_json(&body)
        })
        .delete_async("/rescues/:id", |_req, ctx| async move {
            // Get the id from the request, we use if let to check if the id exists
            if let Some(id) = ctx.param("id") {
                // Get the KV namespace
                let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;
                // Delete the value from KV. In this case,
                // we use the id as the key and return a match statement in case of an error.
                return match kv.delete(id).await {
                    // ! NOTE: I could not find a way to return a 204 No Content response, so this has an empty body.
                    Ok(_) => Response::ok("").map(|resp| resp.with_status(204)),
                    Err(e) => Response::error(e.to_string(), 404)
                };
            }
            Response::error("Animal not found", 404)
        })
        .put_async("/rescues/:id", |mut req, ctx| async move {
            // Get the id from the request, we use if let to check if the id exists
            if let Some(id) = ctx.param("id") {
                // Get the KV namespace
                let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;
                // Get the body of the request - Note that AnimalRescueUpdate implements Deserialize
                let body = req.json::<AnimalRescueUpdate>().await?;
                // Check to see if the id exists in KV
                if kv.get(id).json::<AnimalRescue>().await?.is_none() {
                    // If the id does not exist, return an error
                    return Response::error("Animal not found", 404);
                }

                // Create a new AnimalRescue struct from the body and id
                let new_animal = AnimalRescue {
                    id: id.parse::<u8>().unwrap(),
                    name: body.name,
                    age: body.age,
                    species: body.species,
                };

                // Serialize new_animal to a string
                let value = to_string(&new_animal)?;
                // Store the value in KV
                kv.put(&id, value)?.execute().await?;
                // Return the response
                return Response::from_json(&new_animal);
            }
            Response::error("Animal not found", 404)
        })
        .get_async("/rescues/:id", |_req, ctx | async move {
            // Get the id from the request, we use if let to check if the id exists
            if let Some(id) = ctx.param("id") {
                // Get the KV namespace
                let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;
                // Get the value from KV. In this case,
                // we use the id as the key and return a match statement because the value may not exist.
                return match kv.get(id).json::<AnimalRescue>().await? {
                    Some(animal) => Response::from_json(&animal),
                    None => Response::error("Animal not found", 404)
                };
            }
            Response::error("Animal not found", 404)
        })
        .get_async("/rescues", |_req, ctx | async move {
            // Get the KV namespace
            let kv = ctx.kv("Animal_Rescues_Rusty_KV")?;

            // Get all the keys from KV
            let keys = kv
                .list()
                .execute()
                .await?
                .keys;

            console_debug!("{:?}", keys);

            // Create a Vec of only the key names
            let key_names = keys
                .into_iter()
                .map(|key| key.name)
                .collect::<Vec<String>>();

            console_debug!("{:?}", key_names);

            // Create a Vec of the futures, each future will return an AnimalRescue from KV.

            // The JavaScript code most comprarable to this is:
            // -----------------------------------------------
            // const values = keys.map(key => key.name);
            // const futures = values.map(key => kv.get(key).json());
            // const animals = await Promise.all(futures);
            // const final_result = new Response(JSON.stringify(animals));
            // return final_result;
            // -----------------------------------------------

            let futures = key_names
                .iter()
                .map(|key| kv.get(key).json::<AnimalRescue>());

            // Wait for all the futures to complete. This is similar to Promise.all in JavaScript.
            let animals = join_all(futures)
                .await
                .into_iter()
                .filter_map(|animal| animal.ok())
                .collect::<Vec<_>>().into_iter()
                .map(|animal| animal)
                .collect::<Vec<_>>();

            // Create a response from the animals Vec, wrapped in a Result type.
            let final_result = Response::from_json(&animals);
            console_debug!("Final Result: \n {:?}", &final_result);

            final_result
        })
        .run(req, env).await
}

Conclusion

In this post, we saw how Rust and Cloudflare Workers enable you to build fast, resilient APIs with minimal effort. By leveraging Rust's performance and safety guarantees combined with Workers serverless architecture, you can create APIs that scale automatically while keeping costs low.

The worker framework and crate allow rapid API development in idiomatic Rust style. Serde provides ergonomic serialization to convert between Rust types and JSON for API requests/responses. And Workers KV offers a fast, low-latency database for the edge.

I hope you enjoyed this post. If you have any questions or comments, please reach out on Twitter @estebanrules. Next up is Cloudflare D1. I can't wait!

Originally published here

How to Integrate with an EMR as a Digital Healthcare Startup

Damian Esteban — Mon, 25 Oct 2021 20:26:39 +0000

Introduction

The biggest technical challenge facing the American Healthcare System is the lack of interoperability between EMRs,largely due to the lack of a strong standard protocol. While HL7v2 is the most widely used messaging standard among Healthcare systems, it has loose and optional definitions which lead to discrepancies, and many application vendors do not support the latest and best-defined versions of HL7.

FHIR is a modern and robust standard that could solve this problem, but adoption is slow. Unless you are working with the major players like Epic, Cerner, AllScripts, or a handful of others it is unlikely that FHIR is an option.

At BetterHealthcare we create solutions for healthcare interoperability. Being integrated with BetterHealthcare means that patients can request accurate appointments that are updated in near real-time, and patient information can be sent back to the EMR. This increases efficiency for our customers, allowing them to effortlessly manage their schedules and intake new patients using our robust set of online tools.

What is necessary to integrate with an EMR?

Patience. As a startup, your team is able to move fast and efficiently. Once your project is specced and you have decided on your architecture your team is ready to roll. However, the path to integration with most EMRs is a long one that often involves dealing with many layers of bureaucracy. You’re on their time.
Flexibility. This applies to both the technology and the project timeline. The majority of EMRs do not have RESTful APIs, nor do they send data over HTTP. In my experience, the most common solution is the transmission of CSV files over SFTP. HL7v2 transmitted via MLLP is often an option, but if you don't have a Healthcare Integration Engineer on your team this can be challenging. In order to get an integration project started there is usually a security assessment which takes time, and larger companies may want penetration test results performed within the last year.
A willingness to learn. Even if you do not deal directly with HL7 you must become familiar with the different message types and their content. An excellent resource is Datica Academy's HL7 Primer.

How do I send and receive data from an EMR?

Stay tuned, more detailed blog posts will follow about different approaches. At BetterHealthcare we built a custom integration engine that leverages AWS Lambda, Dynamo, and Kinesis as a proxy layer that transforms incoming data into the desired format. There are many potential solutions. Here are a few services I recommend exploring:

The Google Cloud Healthcare API is a powerful service that allows you to consume and convert HL7v2, FHIR, and DICOM.
Azure FHIR Service is a fully managed FHIR server that you can get running in a few minutes.
FHIR Works on AWS is an official AWS Solutions Implementation that leverages AWS Lambda.
Redox Engine offers EMR integrations with a well-designed standard API. Their services are costly but can be worth the investment. This is your quickest option.
Mirth Connect is a powerful integration engine that allows you to send and receive any type of healthcare data.

The End

As you may have realized, this article barely scratches the surface of healthcare integration strategies. Expect more content on this topic soon and feel free to reach out to me if you have any questions.

How to Integrate with an EMR as a Digital Healthcare Startup

Damian Esteban — Sat, 16 Oct 2021 15:17:23 +0000

Introduction

What is necessary to integrate with an EMR?

Patience. As a startup, your team is able to move fast and efficiently. Once your project is specced and you have decided on your architecture your team is ready to roll. However, the path to integration with most EMRs is a long one that often involves dealing with many layers of bureaucracy. You’re on their time.
Flexibility. This applies to both the technology and the project timeline. The majority of EMRs do not have RESTful APIs, nor do they send data over HTTP. In my experience, the most common solution is the transmission of CSV files over SFTP. HL7v2 transmitted via MLLP is often an option, but if you don't have a Healthcare Integration Engineer on your team this can be challenging. In order to get an integration project started there is usually a security assessment which takes time, and larger companies may want penetration test results performed within the last year.
A willingness to learn. Even if you do not deal directly with HL7 you must become familiar with the different message types and their content. An excellent resource is Datica Academy's HL7 Primer.

How do I send and receive data from an EMR?

The Google Cloud Healthcare API is a powerful service that allows you to consume and convert HL7v2, FHIR, and DICOM.
Azure FHIR Service is a fully managed FHIR server that you can get running in a few minutes.
FHIR Works on AWS is an official AWS Solutions Implementation that leverages AWS Lambda.
Redox Engine offers EMR integrations with a well-designed standard API. Their services are costly but can be worth the investment. This is your quickest option.
Mirth Connect is a powerful integration engine that allows you to send and receive any type of healthcare data.