[Xata](https://xata.io/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog) is a serverless data platform for building modern and robust applications. Built on top of PostgreSQL, Xata provides a unified REST API for efficient data management. Setting itself apart from other data platforms, Xata introduces unique functionalities that significantly streamline the developer workflow. Here are some key benefits of integrating Xata into any application:

-   **Robust file management**: Xata provides APIs and SDKs to manage and securely upload images, documents, and more, directly to a database record.
-   **Multiple environments support and workflow**: With Xata, creating isolated production environments for testing, staging, or feature releases is seamless.
-   **Fast search support**: Xata automatically indexes uploaded data, facilitating fast and efficient data searches across tables and branches.
-   **AI support**: Xata offers vector embedding and AI solutions that empower the development of intelligent applications.

To experience the capabilities of Xata, we will build a project management API in Rust. This API will offer features for creating, reading, updating, and deleting (CRUD) projects. The project repository can be found [here](https://github.com/Mr-Malomz/rust-xata).

## Prerequisites

To follow along with this tutorial, the following are needed:

-   Basic understanding of Rust
-   Xata account. Signup is [free](https://app.xata.io/signin?mode=signup?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [Postman](https://www.postman.com/downloads/) or any API testing application of your choice

## Getting started

To get started, we need to navigate to the desired directory and run the command below:

    cargo new rust-xata && cd rust-xata

This command creates a Rust project called `rust-xata` and navigates into the project directory.

Next, we install the required dependencies by modifying the `[dependencies]` section of the `Cargo.toml` file as shown below:

```toml
[dependencies]
actix-web = "4.4.1"
serde = { version = "1.0.195", features = ["derive"] }
serde_json = "1.0.111"
dotenv = "0.15.0"
reqwest = { version = "0.11.23", features = ["json"] }
```

`actix-web = "4.4.1"` is a Rust-based framework for building web applications.

`serde = { version = "1.0.145", features = ["derive"] }` for serializing and deserializing Rust data structures.

`serde_json = "1.0"` for manipulating JSON and vice versa.

`reqwest = { version = "0.11", features = ["json"] }` for making HTTP requests.

We need to run the command below to install the dependencies:

```bash
cargo build
```

**Structuring the application**

It is essential to have a good project structure as it makes the codebase maintainable and seamless for anyone to read or manage.

To do this, we need to navigate to the `src` directory and, in this folder, create an `api` folder. In the `api` folder, we also need to create a `mod.rs`, `models.rs`, `services.rs`, and `handlers.rs` files.

`mod.rs` is a file for managing application visibility.

`models.rs` is for structuring our application data.

`xata_services.rs` is for abstracting our application logic.

`handlers.rs` is for structuring our APIs.

Next, we need to declare these files as a module by importing them into the `mod.rs` file

```rust
pub mod handlers;
pub mod models;
pub mod services;
```

Finally, we need to register `api` folder as a parent module by importing it into the `main.rs` file as shown below:

```rust
mod api; //add

fn main() {
    println!("Hello world")
}
```

## Setup the database on Xata

To get started, log into the [Xata workspace](https://app.xata.io/workspaces) and create a `project` database. Inside the `project` database, create a `Project` table and add columns as shown below:

| **Column type** | **Column name** |
| --------------- | --------------- |
| String          | name            |
| Text            | description     |
| String          | status          |

![Create database](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706440285877_Screenshot+2024-01-28+at+12.11.03.png)
![Add table](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706442245485_Screenshot+2024-01-20+at+22.09.07.png)
![Add field](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706442310277_Screenshot+2024-01-20+at+22.35.14.png)

Inside a table, Xata automatically adds an `id`, `xata.createdAt`, `xata.updatedAt`, and `xata.version` columns that we can also leverage to perform advanced data operations.

![Created column](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706441400678_Screenshot+2024-01-28+at+12.19.01.png)

**Get the Database URL and set up the API Key**

To securely connect to the database, Xata provides a unique and secure URL for accessing it. To get the database URL, click the **Get code snippet** button and copy the URL. Then click the **API Key** link, add a new key, save and copy the API key.

![click the Get code snippet button](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706442511712_Screenshot+2024-01-20+at+22.40.52.png)
![copy URL](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706442537662_Screenshot+2024-01-20+at+22.42.04.png)
![create API key](https://paper-attachments.dropboxusercontent.com/s_724B5DB0ED02FBEDE105C37DC2102A0D29EC66EAFDCC27146EA9AEF451272040_1703596030165_Screenshot+2023-12-21+at+23.42.03.png)

**Setup environment variable**

Next, we must add our database URL and API key as an environment variable. To do this, create `.env` file in the root directory and add the copied URL and API key.

```bash
XATA_DATABASE_URL= <REPLACE WITH THE COPIED DATABASE URL>
XATA_API_KEY=<REPLACE WITH THE COPIED API KEY>
```

## Building the project management API with Rust and Xata

We can start building our API with our database fully set up on Xata and a secure URL created to access it.

**Create the API models**

To represent the application data, we need to update the `models.rs` file as shown below:

```rust
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct Project {
    pub id: String,
    pub name: String,
    pub description: String,
    pub status: String,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct ProjectRequest {
    pub name: String,
    pub description: String,
    pub status: String,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct ProjectResponse {
    pub id: String,
}

#[derive(Serialize, Debug, Clone)]
pub struct APIResponse<T> {
    pub status: u16,
    pub message: String,
    pub data: Option<T>,
}

#[derive(Serialize, Debug, Clone)]
pub struct APIErrorResponse {
    pub status: u16,
    pub message: String,
    pub data: Option<String>,
}
```

The snippet above does the following:

-   Imports the required dependency
-   Creates a `Project`, `ProjectRequest`, and `ProjectResponse` structs with required properties to describe request and response body accordingly
-   Creates an `APIResponse`, and `APIErrorResponse` structs with the required properties needed for the API response

**Create the API services**

With our application models fully set up, we can now use them to create our application logic. To do this, we need to update the `xata_service.rs` file by doing the following:

First, we need to import the required dependencies and create helper functions:

```rust
use std::env;
use dotenv::dotenv;
use reqwest::{header, Client, Error, RequestBuilder};
use super::model::{Project, ProjectRequest, ProjectResponse};

pub struct XataService;

impl XataService {
    fn env_loader(key: &str) -> String {
        dotenv().ok();
        match env::var(key) {
            Ok(v) => v.to_string(),
            Err(_) => format!("Error loading env variable"),
        }
    }

    fn init() -> Client {
        Client::new()
    }

    fn create_headers() -> header::HeaderMap {
        let mut headers = header::HeaderMap::new();
        headers.insert("Content-Type", "application/json".parse().unwrap());
        headers.insert(
            header::AUTHORIZATION,
            format!("Bearer {}", XataService::env_loader("XATA_API_KEY"))
                .parse()
                .unwrap(),
        );
        headers
    }

    async fn send_request(builder: RequestBuilder) -> Result<reqwest::Response, reqwest::Error> {
        builder.send().await
    }

    async fn handle_response<T>(response: reqwest::Response) -> Result<T, reqwest::Error>
    where
        T: serde::de::DeserializeOwned,
    {
        let json = response.text().await?;
        Ok(serde_json::from_str(json.as_str()).unwrap())
    }
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Creates an `XataService` struct
-   Creates an implementation block that adds `env_loader`, `init`, `create_headers`, `send_request`, and `handle_response` helper methods. These methods are designed to load environment variables, create a connection pool for making asynchronous requests, generate request headers, handle the sending of requests, and manage the deserialization of JSON responses.

Lastly, we need to add methods that use the helper methods to perform CRUD operations.

```rust
//imports goes here

pub struct XataService;

impl XataService {
    //helper methodes goes here

    pub async fn create_project(new_project: ProjectRequest) -> Result<ProjectResponse, Error> {
        let url = format!(
            "{}:main/tables/Project/data",
            XataService::env_loader("XATA_DATABASE_URL")
        );

        let client = XataService::init()
            .post(url)
            .headers(XataService::create_headers())
            .json(&new_project);

        let response = XataService::send_request(client).await?;
        XataService::handle_response(response).await
    }

    pub async fn get_project(project_id: String) -> Result<Project, Error> {
        let url = format!(
            "{}:main/tables/Project/data/{}",
            XataService::env_loader("XATA_DATABASE_URL"),
            project_id
        );

        let client = XataService::init()
            .get(url)
            .headers(XataService::create_headers());

        let response = XataService::send_request(client).await?;
        XataService::handle_response(response).await
    }

    pub async fn update_project(
        updated_project: ProjectRequest,
        project_id: String,
    ) -> Result<ProjectResponse, Error> {
        let url = format!(
            "{}:main/tables/Project/data/{}",
            XataService::env_loader("XATA_DATABASE_URL"),
            project_id
        );

        let client = XataService::init()
            .put(url)
            .headers(XataService::create_headers())
            .json(&updated_project);

        let response = XataService::send_request(client).await?;
        XataService::handle_response(response).await
    }

    pub async fn delete_project(project_id: String) -> Result<String, Error> {
        let url = format!(
            "{}:main/tables/Project/data/{}",
            XataService::env_loader("XATA_DATABASE_URL"),
            project_id
        );

        let client = XataService::init()
            .delete(url)
            .headers(XataService::create_headers());

        let _response = XataService::send_request(client).await?;
        Ok(format!(
            "Project with ID: {} deleted successfully!!",
            project_id
        ))
    }
}
```

The snippet above creates a `create_project`, `get_project`, `update_project`, and `delete_project` methods for performing CRUD operations.

**Create the API handlers**

With that done, we can use the services to create our API handlers. To do this, first, we need to add the snippet below to the `handlers.rs` file:

```rust
use actix_web::{
    delete, get, post, put,
    web::{Json, Path},
    HttpResponse,
};
use reqwest::StatusCode;
use super::{
    model::{APIErrorResponse, APIResponse, Project, ProjectRequest, ProjectResponse},
    xata_service::XataService,
};

#[post("/project")]
pub async fn create_project_handler(new_project: Json<ProjectRequest>) -> HttpResponse {
    let project_details = XataService::create_project(new_project.to_owned()).await;

    match project_details {
        Ok(data) => HttpResponse::Accepted().json(APIResponse::<ProjectResponse> {
            status: StatusCode::CREATED.as_u16(),
            message: "success".to_string(),
            data: Some(data),
        }),
        Err(error) => HttpResponse::InternalServerError().json(APIErrorResponse {
            status: StatusCode::INTERNAL_SERVER_ERROR.as_u16(),
            message: "failure".to_string(),
            data: Some(error.to_string()),
        }),
    }
}

#[get("/project/{id}")]
pub async fn get_project_handler(path: Path<String>) -> HttpResponse {
    let id = path.into_inner();
    if id.is_empty() {
        return HttpResponse::BadRequest().json(APIErrorResponse {
            status: StatusCode::BAD_REQUEST.as_u16(),
            message: "failure".to_string(),
            data: Some("invalid ID".to_string()),
        });
    };

    let project_details = XataService::get_project(id).await;

    match project_details {
        Ok(data) => HttpResponse::Accepted().json(APIResponse::<Project> {
            status: StatusCode::OK.as_u16(),
            message: "success".to_string(),
            data: Some(data),
        }),
        Err(error) => HttpResponse::InternalServerError().json(APIErrorResponse {
            status: StatusCode::INTERNAL_SERVER_ERROR.as_u16(),
            message: "failure".to_string(),
            data: Some(error.to_string()),
        }),
    }
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Creates a `create_project_handler` and `get_project_handler` handler with corresponding API routes that use the services to perform the corresponding actions and return the appropriate response using the `APIResponse` and `APIErrorResponse`

Lastly, we need to add `update_project_handler` and `delete_project_handler` handlers that use logic similar to the handlers above to update and delete a project.

```rust
//imports goes here

#[post("/project")]
pub async fn create_project_handler(new_project: Json<ProjectRequest>) -> HttpResponse {
    //create_project_handler code goes here
}

#[get("/project/{id}")]
pub async fn get_project_handler(path: Path<String>) -> HttpResponse {
    //get_project_handler code goes here
}

#[put("/project/{id}")]
pub async fn update_project_handler(
    updated_project: Json<ProjectRequest>,
    path: Path<String>,
) -> HttpResponse {
    let id = path.into_inner();
    if id.is_empty() {
        return HttpResponse::BadRequest().json(APIErrorResponse {
            status: StatusCode::BAD_REQUEST.as_u16(),
            message: "failure".to_string(),
            data: Some("invalid ID".to_string()),
        });
    };

    let project_details = XataService::update_project(updated_project.to_owned(), id).await;

    match project_details {
        Ok(data) => HttpResponse::Accepted().json(APIResponse::<ProjectResponse> {
            status: StatusCode::OK.as_u16(),
            message: "success".to_string(),
            data: Some(data),
        }),
        Err(error) => HttpResponse::InternalServerError().json(APIErrorResponse {
            status: StatusCode::INTERNAL_SERVER_ERROR.as_u16(),
            message: "failure".to_string(),
            data: Some(error.to_string()),
        }),
    }
}

#[delete("/project/{id}")]
pub async fn delete_project_handler(path: Path<String>) -> HttpResponse {
    let id = path.into_inner();
    if id.is_empty() {
        return HttpResponse::BadRequest().json(APIErrorResponse {
            status: StatusCode::BAD_REQUEST.as_u16(),
            message: "failure".to_string(),
            data: Some("invalid ID".to_string()),
        });
    };

    let project_details = XataService::delete_project(id).await;

    match project_details {
        Ok(data) => HttpResponse::Accepted().json(APIResponse::<String> {
            status: StatusCode::ACCEPTED.as_u16(),
            message: "success".to_string(),
            data: Some(data),
        }),
        Err(error) => HttpResponse::InternalServerError().json(APIErrorResponse {
            status: StatusCode::INTERNAL_SERVER_ERROR.as_u16(),
            message: "failure".to_string(),
            data: Some(error.to_string()),
        }),
    }
}
```

**Putting it all together**

With that done, we must update the `main.rs` file to include our application entry point and use the handlers.

```rust
use actix_web::{App, HttpServer};
use api::handler::{
    create_project_handler, delete_project_handler, get_project_handler, update_project_handler,
};
mod api;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(move || {
        App::new()
            .service(create_project_handler)
            .service(get_project_handler)
            .service(update_project_handler)
            .service(delete_project_handler)
    })
    .bind(("localhost", 8080))?
    .run()
    .await
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Creates a new server that adds the handlers and runs on `localhost:8080`

With that done, we can start a development server using the command below:

```rust
cargo run main
```

![Create project](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706483516010_Screenshot+2024-01-29+at+00.09.09.png)
![Get a project](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706483516012_Screenshot+2024-01-29+at+00.09.28.png)
![Update a project](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706483516046_Screenshot+2024-01-29+at+00.10.05.png)

![Delete a project](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706483516086_Screenshot+2024-01-29+at+00.11.02.png)

We can also confirm the project management data by checking the table on Xata.

![Data on Xata](https://paper-attachments.dropboxusercontent.com/s_E1CBF4A45089EFC3D9C461B80BB9F97D882823FECDCA010DD86FEAC6EC26A79C_1706483568817_Screenshot+2024-01-29+at+00.11.32.png)

# Conclusion

This post discussed what Xata is and provided a detailed step-by-step guide to use it to build a project management API in Rust. In addition to the functionalities explored earlier, Xata also includes well-tailored features that developers can harness to build applications ranging from small to large.

These resources may also be helpful:

-   [Xata documentation](https://xata.io/docs?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [Actix web framework](https://actix.rs/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)


This post discussed what Xata is and provided a detailed step-by-step guide to use it to build a project management API in Rust.

Xata + Rust: A getting started guide.

Learn how to abstract technical overhead by leveraging Appwrite to build a project management API in Rust

Appwrite + Rust: Build APIs without technical overhead

Learn how to build a product delivery page using Cloudinary for media optimization, Uniform for composing experience, and Yew; a Rust-based frontend framework for rendering the product markup.

Build a product delivery page with Rust and Uniform

A common paradigm in most programming languages is the use of files, modules, folders, and packages to break down codebases into separate and organized segments. Well, Rust isn’t an exception to this. You can structure your code in files and modules to achieve the desired result.

While files and modules work, they come with it’s limitations, as you can only use the separated code in a single codebase. An approach Rust uses to make your code reusable across multiple projects is the use of **workspaces**.

In this guide, you will learn what Rust workspaces are, their benefits, and a practical guide on how to build a REST API using Rust workspaces.

## What are Rust Workspaces?

Rust workspace is a feature that lets you manage multiple related packages in one place. They let you structure your code for code reuse, simplify development workflow, and improve the overall developer experience.

**Benefits of Rust Workspaces:**

1. **Code reusability**: Workspaces allow you to share your code among multiple projects, which makes it easier to maintain and update.

2. **Simplified dependency management**: With workspaces, you can manage dependencies centrally for all member crates, avoid duplication, and ensure consistency.

3. **Improved organization**: Keep related projects together so that you can easily navigate and understand the codebase.

4. **Streamlined builds**: It lets you build all crates in the workspace simultaneously, which reduces build times and simplifies CI/CD processes.

In our case, you will use Rust Workspaces to build a REST API with Xata, a serverless data platform built on top of PostgreSQL for creating modern and robust applications.

![Workspace showcase](https://paper-attachments.dropboxusercontent.com/s_875B09528CC05D69F077F2DBD6CA914D522197226C156E5582878AC3B7DF4FF8_1722932707997_workspace+2.png)

The first step in creating workspaces is to architect your application by categorizing components into those that can be reused in multiple projects and those that are specific to a particular project. In this case, the data model and database service can be structured using workspaces, while the API handlers can leverage these workspaces.

## Prerequisites

To follow along with this tutorial, you’ll need to have:

-   Basic understanding of Rust
-   Xata account. Signup is [free](https://app.xata.io/signin?mode=signup?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [Postman](https://www.postman.com/downloads/) or any API testing application of your choice

## Scaffold the project

To get started, navigate to the desired directory and run the command below:

```bash
cargo new rust-worskpace && cd rust-worskpace
```

This command creates a Rust project called `rust-workspace` and navigates into the project directory.

Next, install the required dependency by modifying the `[dependencies]` section of the `Cargo.toml` file as shown below:

```toml
[dependencies]
actix-web = "4.4.1"
```

`actix-web = "4.4.1"` is a Rust-based framework for building web applications.

**Setup the database**

Log into your Xata workspace and create a `project` database with the following columns:

| **Column type** | **Column name** |
| --------------- | --------------- |
| String          | name            |
| Text            | description     |
| String          | status          |

![database](https://paper-attachments.dropboxusercontent.com/s_875B09528CC05D69F077F2DBD6CA914D522197226C156E5582878AC3B7DF4FF8_1722187264529_Screenshot+2024-07-28+at+18.18.00.png)

Next, click the **Get code snippet** button to get the database URL and navigate to your [workspace settings](https://app.xata.io/settings) to generate an API key.

![Get URL](https://paper-attachments.dropboxusercontent.com/s_875B09528CC05D69F077F2DBD6CA914D522197226C156E5582878AC3B7DF4FF8_1722187278674_image.png)

![Generate API Key](https://paper-attachments.dropboxusercontent.com/s_875B09528CC05D69F077F2DBD6CA914D522197226C156E5582878AC3B7DF4FF8_1722187482613_Screenshot+2024-07-28+at+18.23.47.png)

Finally, create `.env` file in the root directory and add the copied URL and API key.

```bash
XATA_DATABASE_URL= <REPLACE WITH THE COPIED DATABASE URL>
XATA_API_KEY=<REPLACE WITH THE COPIED API KEY>
```

With this done, you can now create the required workspaces that the application will use.

**Data model workspace**

To get started, run the command below:

```bash
cargo new --lib shared_models
```

The command above will create a **library** called `shared_models`.

Next, install the required dependency by modifying the `[dependencies]` section of the `shared_models/Cargo.toml` file as shown below:

```toml
#shared_models/Cargo.toml

[dependencies]
serde = { version = "1.0.195", features = ["derive"] }
```

Finally, update the `shared_models/src/lib.rs` file as shown below:

```rust
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct Project {
    pub id: String,
    pub name: String,
    pub description: String,
    pub status: String,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct ResponseData {
    pub records: Vec<Project>,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct ProjectRequest {
    pub name: String,
    pub description: String,
    pub status: String,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct ProjectResponse {
    pub id: String,
}

#[derive(Serialize, Debug, Clone)]
pub struct APIResponse<T> {
    pub status: u16,
    pub message: String,
    pub data: Option<T>,
}

#[derive(Serialize, Debug, Clone)]
pub struct APIErrorResponse {
    pub status: u16,
    pub message: String,
    pub data: Option<String>,
}
```

The snippet above does the following:

-   Imports the required dependency.
-   Creates a `Project`, `ResponseData`, `ProjectRequest`, and `ProjectResponse` structs with required properties to describe the request and response body accordingly.
-   Creates an `APIResponse`, and `APIErrorResponse` structs with the required properties needed for the API response

**Database service workspace**

To get started, run the command below:

```bash
cargo new --lib xata_client
```

The command above will create a **library** called `xata_client`.

Next, install the required dependency by modifying the `[dependencies]` section of the `xata_client/Cargo.toml` file as shown below:

```toml
#xata_client/Cargo.toml

[dependencies]
dotenv = "0.15.0"
reqwest = { version = "0.11.23", features = ["json"] }
serde_json = "1.0.111"
shared_models = { path = "../shared_models" }
```

`dotenv = "0.15.0"` is a library for loading environment variables.

`reqwest = { version = "0.11", features = ["json"] }` for making HTTP requests.

`serde_json = "1.0"` for manipulating JSON data.

`shared_models = { path = "../shared_models" }` adds the model workspace you created earlier to `xata_client` library. By doing this, you’ll be able to use the `shared_models` workspace in this newly created workspace.

Finally, update the `xata_client/src/lib.rs` file as shown below:

```rust
use std::env;

use dotenv::dotenv;
use reqwest::{header, Client, Error};
use shared_models::{Project, ProjectRequest, ProjectResponse, ResponseData};

pub struct XataClient;

impl XataClient {
    fn env_loader(key: &str) -> String {
        dotenv().ok();
        match env::var(key) {
            Ok(v) => v.to_string(),
            Err(_) => format!("Error loading environment variable"),
        }
    }

    fn init() -> Client {
        Client::new()
    }

    fn create_header() -> header::HeaderMap {
        let mut headers = header::HeaderMap::new();
        headers.insert("Content-Type", "application/json".parse().unwrap());
        headers.insert(
            header::AUTHORIZATION,
            format!("Bearer {}", XataClient::env_loader("XATA_API_KEY"))
                .parse()
                .unwrap(),
        );
        headers
    }

    pub async fn create_project(new_project: ProjectRequest) -> Result<ProjectResponse, Error> {
        let database_url = XataClient::env_loader("XATA_DATABASE_URL");
        let url = format!("{}:main/tables/Project/data", database_url);
        let client = XataClient::init()
            .post(url)
            .headers(XataClient::create_header())
            .json(&new_project)
            .send()
            .await;
        match client {
            Ok(response) => {
                let json = response.text().await?;
                let created_project: ProjectResponse = serde_json::from_str(json.as_str()).unwrap();
                Ok(created_project)
            }
            Err(error) => Err(error),
        }
    }

    pub async fn get_projects() -> Result<Vec<Project>, Error> {
        let database_url = XataClient::env_loader("XATA_DATABASE_URL");
        let url = format!("{}:main/tables/Project/query", database_url);
        let client = XataClient::init()
            .post(url)
            .headers(XataClient::create_header())
            .send()
            .await;
        match client {
            Ok(response) => {
                let json = response.text().await?;
                let response_data: ResponseData = serde_json::from_str(json.as_str()).unwrap();
                Ok(response_data.records)
            }
            Err(error) => Err(error),
        }
    }
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Creates an `XataClient` struct
-   Creates an implementation block that adds `env_loader`, `init`, `create_header`, `create_project`, and `get_projects` methods. These methods are designed to load environment variables, create a connection pool for making asynchronous requests, generate request headers, create a project, and get the list of products.

## Building the APIs with the workspaces

With the workspaces fully set up, you might think you can now start using the libraries in the main project. Well, not so fast—you need to specify them as dependencies in the main project first.

While Cargo automatically recognizes the libraries as part of the workspace, you still have to explicitly add them as dependencies. If you check the `Cargo.toml` file in the root directory, you’ll see the workspaces added as shows below:

```toml
workspace = { members = ["shared_models", "xata_client"] }
```

To add the libraries as depencies, update the `[dependencies]` section by specifying the library and the associated path.

```toml
#rust-workspace/Cargo.toml

[dependencies]
actix-web = "4.4.1"
#add workspaces below
shared_models = { path = "./shared_models" }
xata_client = { path = "./xata_client" }
```

With that done, you can now use the library to build the APIs.

To do this, create a `handler.rs` file inside the `src` folder of the project and add the snippet below:

```rust
use actix_web::{http::StatusCode, post, web::Json, HttpResponse};
use shared_models::{APIErrorResponse, APIResponse, Project, ProjectRequest, ProjectResponse};
use xata_client::XataClient;

#[post("/project")]
pub async fn create_project_handler(new_project: Json<ProjectRequest>) -> HttpResponse {
    let create_project = XataClient::create_project(new_project.to_owned()).await;

    match create_project {
        Ok(data) => HttpResponse::Created().json(APIResponse::<ProjectResponse> {
            status: StatusCode::CREATED.as_u16(),
            message: "success".to_string(),
            data: Some(data),
        }),
        Err(error) => HttpResponse::InternalServerError().json(APIErrorResponse {
            status: StatusCode::INTERNAL_SERVER_ERROR.as_u16(),
            message: "failure".to_string(),
            data: Some(error.to_string()),
        }),
    }
}

#[post("/projects")]
pub async fn get_projects_handler() -> HttpResponse {
    let get_projects = XataClient::get_projects().await;

    match get_projects {
        Ok(data) => HttpResponse::Ok().json(APIResponse::<Vec<Project>> {
            status: StatusCode::OK.as_u16(),
            message: "success".to_string(),
            data: Some(data),
        }),
        Err(error) => HttpResponse::InternalServerError().json(APIErrorResponse {
            status: StatusCode::INTERNAL_SERVER_ERROR.as_u16(),
            message: "failure".to_string(),
            data: Some(error.to_string()),
        }),
    }
}
```

The snippet above does the following:

-   Imports the required dependencies (including the workspaces)
-   Creates a `create_project_handler` and `get_projects_handler` handler with corresponding API routes that use the `libraries` to perform the corresponding actions and return the appropriate response using the `APIResponse` and `APIErrorResponse`

**Putting it all together**

With that done, update the `main.rs` file to include the application entry point and use the handlers.

```rust
use actix_web::{App, HttpServer};
use handlers::{create_project_handler, get_projects_handler};
mod handlers;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(move || {
        App::new()
            .service(create_project_handler)
            .service(get_projects_handler)
    })
    .bind(("localhost", 8080))?
    .run()
    .await
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Creates a new server that adds the handlers and runs on `localhost:8080`

With that done, we can start a development server using the command below:

```bash
cargo run
```

![API test](https://paper-attachments.dropboxusercontent.com/s_875B09528CC05D69F077F2DBD6CA914D522197226C156E5582878AC3B7DF4FF8_1722207963810_Screenshot+2024-07-29+at+00.05.54.png)

This post discussed what Rust workspaces are, their benefits, and a walkthrough guide on how to use them to build a REST API with Xata. Beyond what was explored above, you can extend the workspaces and the API to support deleting, editing, and getting a single project.

These resources may be helpful:

-   [Xata + Rust: A getting started guide](https://fullstackwriter.dev/post/xata-rust-a-getting-started-guide?category=rust)
-   [Xata documentation](https://xata.io/docs?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [Actix web framework](https://actix.rs/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)


In this guide, you will learn what Rust workspaces are, their benefits, and a practical guide on how to build a REST API using Rust workspaces.

Rust Workspaces: A guide to managing your code better

gRPC is a modern communication framework that can run in any environment and helps connect services efficiently. This post explores what gRPC is and how to get started by building a user management service using gRPC, MongoDB and Rust.

rust

Xata + Rust: A getting started guide.

Appwrite + Rust: Build APIs without technical overhead

Build a product delivery page with Rust and Uniform

Rust Workspaces: A guide to managing your code better

Getting started with gRPC in Rust

blog

Contact