[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.

This post discusses what Xata is and provides a detailed step-by-step guide to using it to build a basic project management application with Flutter

Xata + Flutter: A getting started guide.

Explore what Internal Tool is and how to leverage Uniform as an Internal tool to build a News timeline application in Flutter.

Beyond Composability: Using Uniform as an Internal Tool

This post discusses what Xata is and provides a detailed step-by-step guide to using it to build a project management API in Go.

Xata + Go: A getting started guide.

[Appwrite Init](https://appwrite.io/init): a week-long program dedicated to showcasing and celebrating everything new with Appwrite. The 2024 edition saw the launch of **Appwrite 1.5**, introducing exciting features such as:

-   Local development support for serverless functions.
-   A new and better Appwrite command line interface (CLI).
-   Improved Appwrite serverless function.
-   Go runtime support and SDK
-   Mock numbers to test phone authentication.

The addition of [Go runtime support and SDK](https://appwrite.io/blog/post/announcing-go-support) stood out to me in particular. Developers can now build both APIs and serverless functions in Go, eliminating the need to switch contexts between Go and previously supported languages. This is a game changer, as it enables type consistency across APIs and functions, streamlines your deployment process, and significantly enhances the developer experience.

The project repository can be found [here](https://github.com/Mr-Malomz/go-appwriteSDK).

## Before the Go SDK

Prior to the Go SDK, if you want to build API with Go and Appwrite, you’ll first create a service that talks to Appwrite API:

```go
// get details from environment variable
var projectId = GetEnvVariable("PROJECT_ID")
var databaseId = GetEnvVariable("DATABASE_ID")
var collectionId = GetEnvVariable("COLLECTION_ID")
var apiKey = GetEnvVariable("PROJECT_ID")

func (app *Config) createProject(newProject *data.ProjectRequest) (*data.ProjectResponse, error) {
    url := fmt.Sprintf("https://cloud.appwrite.io/v1/databases/%s/collections/%s/documents", databaseId, collectionId)

    createdProject := data.ProjectResponse{}

    jsonData := data.JsonAPIBody{
        DocumentId: "unique()",
        Data:       newProject,
    }
    postBody, _ := json.Marshal(jsonData)
    bodyData := bytes.NewBuffer(postBody)

    // making the request
    client := &http.Client{}
    req, _ := http.NewRequest("POST", url, bodyData)
    req.Header.Add("Content-Type", "application/json")
    req.Header.Add("X-Appwrite-Key", apiKey)
    req.Header.Add("X-Appwrite-Project", projectId)

    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    err = json.Unmarshal([]byte(body), &createdProject)
    if err != nil {
        return nil, err
    }
    return &createdProject, nil
}
```

Then use the service to create a handler that exposes the API.

```go
// import dependencies

const appTimeout = time.Second * 10

func (app *Config) createdProjectHandler() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        _, cancel := context.WithTimeout(context.Background(), appTimeout)
        var payload data.ProjectRequest
        defer cancel()

        app.validateJsonBody(ctx, &payload)

        newProject := data.ProjectRequest{
            Name:        payload.Name,
            Description: payload.Description,
        }

        data, err := app.createProject(&newProject) // using the service
        if err != nil {
            app.errorJSON(ctx, err)
            return
        }

        app.writeJSON(ctx, http.StatusCreated, data)
    }
}
```

As seen above, you have to manually call the APIs using an HTTP client, configure headers to include the API key and project ID, switch URLs (when building other endpoints), handle requests, convert responses to JSON, and manage many other overhead tasks.

Now, imagine doing this for multiple requests across different endpoints. It quickly becomes a tedious process, with repetitive code and constant refactoring whenever you need to update the project.

But with Appwrite’s new Go SDK, you can build APIs seamlessly with minimal effort. Let’s take a closer look.

## Getting started

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

```bash
mkdir go-appwriteSDK && cd go-appwriteSDK
```

Next, initialize a Go module to manage project dependencies by running the command below:

```bash
go mod init go-appwriteSDK
```

Finally, proceed to install the required dependencies with:

```bash
go get github.com/appwrite/sdk-for-go github.com/gin-gonic/gin github.com/go-playground/validator/v10 github.com/joho/godotenv
```

`github.com/appwrite/sdk-for-go` is Appwrite Go SDK.

`github.com/gin-gonic/gin` is a framework for building web applications.

`github.com/go-playground/validator/v10` is a library for validating structs and fields.

`github.com/joho/godotenv` is a library for loading environment variables.

**Structuring the application**
To do this, create an `api`, `cmd`, and `data` folder in your project directory.

`api` is for structuring our API-related files.

`cmd` is for structuring our application entry point.

`data` is for structuring our application data.

## Setting up Appwrite

Log into our Appwrite [console](https://cloud.appwrite.io/console), click the **Create project** button, input `go_appwrite` as the name, and then **Create**.

![Create project](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_C9210607DAFF6D80615947ED6BE237716E98BADEF0416B60FACF081B1CAEFB80_1687518026974_Screenshot%2B2023-06-23%2Bat%2B11.38.55.png)

**Create a Database, Collection, and Add Attributes**

To do this, first, navigate to the **Database** tab, click the **Create database** button, input `project` as the name, and **Create**.

![Create database](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691705236741_Screenshot%2B2023-08-10%2Bat%2B23.06.00.png)

Secondly, create a collection for storing the projects by clicking the **Create collection** button, input `project_collection` as the name, and then click **Create**.

![Create collection](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691705351204_Screenshot%2B2023-08-04%2Bat%2B01.14.37.png)

Lastly, you need to create attributes to represent the database fields. To do this, navigate to the **Attributes** tab and create attributes for each of the values shown below:

| Attribute key | Attribute type | Size | Required |
| ------------- | -------------- | ---- | -------- |
| name          | String         | 250  | YES      |
| description   | String         | 5000 | YES      |

![Create attribute](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691705420699_Screenshot%2B2023-08-04%2Bat%2B01.15.49.png)

After creating the attributes, you should see them as shown below:

![List of attributes](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691705645782_Screenshot%2B2023-08-04%2Bat%2B01.21.03.png)

**Create an API key**

To securely connect to Appwrite, you need to create an API key. To do this, navigate to the **Overview** tab, scroll to the **Integrate With Your Server section**, and click the **API Key** button.

![Create API key](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691709339925_Screenshot%2B2023-08-04%2Bat%2B01.37.13.png)

Next, input `api_go` as the name, click the **Next** button, select **Database** as the required scope, and **Create**.

![input  name create](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691709339959_Screenshot%2B2023-08-04%2Bat%2B01.39.23.png)

![Set permission](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691709613147_Screenshot%2B2023-08-04%2Bat%2B01.40.32.png)

## Building the APIs fast with the Appwrite Go SDK

With the project fully set up on Appwrite, you can now use the database with the SDK to build the APIs without any other technical overhead.

**Set up Environment Variable**

To set up the required environment variables, you need to create a `.env` file in the root directory and add the snippet below:

```bash
API_KEY=<REPLACE WITH API KEY>
PROJECT_ID=<REPLACE WITH PROJECT ID>
DATABASE_ID=<REPLACE WITH DATABASE ID>
COLLECTION_ID=<REPLACE WITH COLLECTION ID>
API_URL=https://cloud.appwrite.io/v1
```

You can get the required key and IDs from your Appwrite console.

**Create the API models and helper function**

To represent the application data, create a `model.go` file inside the `data` folder and add the snippet below:

```go
package data

type Project struct {
    Id          string `json:"$id,omitempty"`
    Name        string `json:"name,omitempty"`
    Description string `json:"description,omitempty"`
}

type ProjectRequest struct {
    Name        string `json:"name,omitempty"`
    Description string `json:"description,omitempty"`
}

type ProjectResponse struct {
    Id           string `json:"$id,omitempty"`
    CollectionId string `json:"$collectionId,omitempty"`
}

type JsonAPIBody struct {
    Data       *ProjectRequest `json:"data,omitempty"`
}
```

The snippet above creates a `Project`, `ProjectRequest`, `ProjectResponse`, and `JsonAPIBody` struct with the required properties to describe requests and response types.

Finally, create a `helpers.go` file with a reusable function to load environment variables and return JSON responses inside the `api` folder.

```go
package api

import (
    "log"
    "net/http"
    "os"
    "github.com/gin-gonic/gin"
    "github.com/go-playground/validator/v10"
    "github.com/joho/godotenv"
)

type jsonResponse struct {
    Status  int    `json:"status"`
    Message string `json:"message"`
    Data    any    `json:"data"`
}

func GetEnvVariable(key string) string {
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }
    return os.Getenv(key)
}

func (app *Config) validateJsonBody(c *gin.Context, data any) error {
    var validate = validator.New()

    //validate the request body
    if err := c.BindJSON(&data); err != nil {
        return err
    }

    //validate with the validator library
    if err := validate.Struct(&data); err != nil {
        return err
    }
    return nil
}

func (app *Config) writeJSON(c *gin.Context, status int, data any) {
    c.JSON(status, jsonResponse{Status: status, Message: "success", Data: data})
}

func (app *Config) errorJSON(c *gin.Context, err error, status ...int) {
    statusCode := http.StatusBadRequest
    if len(status) > 0 {
        statusCode = status[0]
    }
    c.JSON(statusCode, jsonResponse{Status: statusCode, Message: err.Error()})
}
```

**Create the API route entry**

Create a `route.go` file for configuring the API routes inside the `api` folder and add the snippet below:

```go
package api

import "github.com/gin-gonic/gin"

type Config struct {
    Router *gin.Engine
}

func (app *Config) Routes() {
    //routes will come here
}
```

The snippet above does the following:

-   Imports the required dependency.
-   Creates a `Config` struct with a `Router` property to configure the application methods.
-   Creates a `Routes` function that takes in the `Config` struct as a pointer.

**Create the API handlers**

To create the handlers, first, create a `handler.go` file inside the `api` folder and add the snippet below:

```go
package api

import (
    "context"
    "go-appwriteSDK/data"
    "net/http"
    "time"
    "github.com/appwrite/sdk-for-go/appwrite"
    "github.com/appwrite/sdk-for-go/id"
    "github.com/gin-gonic/gin"
)

var projectId = GetEnvVariable("PROJECT_ID")
var databaseId = GetEnvVariable("DATABASE_ID")
var collectionId = GetEnvVariable("COLLECTION_ID")
var apiKey = GetEnvVariable("API_KEY")
var endpoint = GetEnvVariable("API_URL")

var client = appwrite.NewClient(
    appwrite.WithEndpoint(endpoint),
    appwrite.WithProject(projectId),
    appwrite.WithKey(apiKey),
)

const appTimeout = time.Second * 10
```

The snippet above imports the required dependencies, uses the `GetEnvVariable` to load the required enrionment variables, configures Appwrite with the required credentials, and creates a 10 seconds timeout for requests.

Finally, use the Appwrite instance and the timeout to create the handlers.

```go
func (app *Config) createProjectHandler() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        _, cancel := context.WithTimeout(context.Background(), appTimeout)
        databases := appwrite.NewDatabases(client)
        var payload data.ProjectRequest
        defer cancel()

        app.validateJsonBody(ctx, &payload)

        doc, err := databases.CreateDocument(databaseId, collectionId, id.Unique(), payload)
        if err != nil {
            app.errorJSON(ctx, err)
            return
        }
        app.writeJSON(ctx, http.StatusCreated, doc)
    }
}

func (app *Config) getProjectHandler() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        _, cancel := context.WithTimeout(context.Background(), appTimeout)
        databases := appwrite.NewDatabases(client)
        docId := ctx.Param("projectId")
        defer cancel()

        response, err := databases.GetDocument(databaseId, collectionId, docId)

        if err != nil {
            app.errorJSON(ctx, err)
            return
        }
        var document data.Project
        err = response.Decode(&document)
        if err != nil {
            app.errorJSON(ctx, err)
            return
        }

        app.writeJSON(ctx, http.StatusOK, document)
    }
}

func (app *Config) updateProjectHandler() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        _, cancel := context.WithTimeout(context.Background(), appTimeout)
        databases := appwrite.NewDatabases(client)
        var payload data.ProjectRequest
        docId := ctx.Param("projectId")
        defer cancel()

        app.validateJsonBody(ctx, &payload)
        updates := data.ProjectRequest{
            Name:        payload.Name,
            Description: payload.Description,
        }

        response, err := databases.UpdateDocument(databaseId, collectionId, docId, databases.WithUpdateDocumentData(updates))
        if err != nil {
            app.errorJSON(ctx, err)
            return
        }

        var document data.Project
        err = response.Decode(&document)
        if err != nil {
            app.errorJSON(ctx, err)
            return
        }

        app.writeJSON(ctx, http.StatusOK, document)
    }
}

func (app *Config) deleteProjectHandler() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        _, cancel := context.WithTimeout(context.Background(), appTimeout)
        databases := appwrite.NewDatabases(client)
        docId := ctx.Param("projectId")
        defer cancel()

        response, err := databases.DeleteDocument(databaseId, collectionId, docId)
        if err != nil {
            app.errorJSON(ctx, err)
            return
        }

        app.writeJSON(ctx, http.StatusOK, response)
    }
}
```

**Update the API routes to use handlers**

With that done, update the `routes.go` file with the handlers as shown below:

```go
package api

import "github.com/gin-gonic/gin"

type Config struct {
    Router *gin.Engine
}

func (app *Config) Routes() {
    app.Router.POST("/project", app.createProjectHandler())
    app.Router.GET("/project/:projectId", app.getProjectHandler())
    app.Router.PUT("/project/:projectId", app.updateProjectHandler())
    app.Router.DELETE("/project/:projectId", app.deleteProjectHandler())
}
```

**Putting it all together**

With the APIs fully set up, you need to create the application entry point. To do this, create a `main.go` file inside the `cmd` folder and add the snippet below:

```go
package main

import (
    "go-appwriteSDK/api"
    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()
    //initialize config
    app := api.Config{Router: router}
    //routes
    app.Routes()
    router.Run(":8080")
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Creates a Gin router using the `Default` configuration
-   Initialize the `Config` struct by passing in the `Router`
-   Adds the route and run the application on port `:8080`

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

```bash
go run cmd/main.go
```

![create](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691715978196_Screenshot%2B2023-08-05%2Bat%2B17.11.09.png)

![update](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691715978260_Screenshot%2B2023-08-06%2Bat%2B00.16.12.png)

![Get details](https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fpaper-attachments.dropboxusercontent.com%2Fs_2095423646DCD7D2DA1B88D8D859DA299FF57589D0A10336F58D285B02BBBE7E_1691715978225_Screenshot%2B2023-08-05%2Bat%2B22.31.35.png)

# Conclusion

This post discusses how to quickly build REST APIs with the Appwrite Go SDK, eliminating the need to manually configure headers for API keys and project IDs, switch URLs for different endpoints, handle requests, and convert responses to JSON.

These resources might be helpful:

-   [Appwrite official documentation](https://appwrite.io/docs?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [Appwrite Go SDK](https://github.com/appwrite/sdk-for-go)


This post discusses how to quickly build REST APIs with the Appwrite Go SDK, eliminating the need to manually configure headers for API keys and project IDs, switch URLs for different endpoints, handle requests, and convert responses to JSON.

#product

Xata + Rust: A getting started guide.

Xata + Flutter: A getting started guide.

Beyond Composability: Using Uniform as an Internal Tool

Xata + Go: A getting started guide.

Build APIs faster with Go and Appwrite