As someone who actively builds applications within the JavaScript / Node.js ecosystem leveraging frameworks like Next.js, Vue, Express.js, etc., hot reloading is usually built into the framework or needs to install a package to get it up and running.

While exploring the Go ecosystem, hot reloading seems like an afterthought in most of their popular frameworks. In fact, it became a source of concern for me and led me down the rabbit hole of finding possible solutions on how to include hot reloading in my Go applications.

This guide will explore what hot reloading is and why it is needed. It will also explore two libraries to help build hot reloading into your applications.

# What is hot reloading?

Hot reloading is a technique used during application development, allowing you to observe updated changes to the source code in real-time without reloading the entire application. It preserves the application state, enabling you to continue working without losing the current state of the application. It allows you to view changes instantly, accelerating the development process and enhancing productivity.

# What are the benefits of hot reloading?

The following are the benefits of enabling hot reloading in your applications:

-   Enhanced user experience
-   Fast development
-   Minimal context switching
-   Improved feedback loop

1. **Enhanced user experience**: The ability to make changes to the codebase and see them in real-time improves the development process. With this capability, developers can rapidly prototype and design better applications.
2. **Fast development**: With hot reloading, developers don't have to manually reload the application to see the latest changes. Development time is fast because changes are reflected immediately.
3. **Minimal context switching**: A major source of distraction for developers is having to go back to the terminal to rebuild and run the application every time changes are made. However, with hot reloading, they can focus on the task without any interruptions or worries about their changes being reflected as updates occur in real-time.
4. **Improved feedback loop**: Because changes are visible in real-time, developers receive immediate feedback and can easily fix bugs, identify where the application is broken, and consequently improve the development workflow.

# How to implement hot reloading in a Go application

This section will explore two libraries that make hot reloading possible in a Go application:

-   Modd
-   Air

Before we explore how to use these libraries, let’s set up a sample Go project using the Gin-gonic framework.

Create a directory.

```bash
mkdir sample_go && cd sample_go
```

Next, initialize a Go module to manage project dependencies.

```bash
go mod init sample_go
```

Install the required dependency.

```bash
go get github.com/gin-gonic/gin
```

Create a sample application.

```go
package main

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

func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello world!",
        })
    })

    r.Run()
}
```

## Modd for hot reloading

[Modd](https://github.com/cortesi/modd) is a library that makes hot reloading possible in Go applications. To use it, install it on your machine using the command below:

    go install github.com/cortesi/modd/cmd/modd@latest

In your project directory, create a `modd.conf` file and add the snippet below:

```bash
**/*.go {
    prep: go test @dirmods
}
```

The command above tells **Modd** to watch for changes to any `.go` file and run the changes on `test` directories.

To enable hot reloading, run the command below in your terminal:

```bash
modd
```

> In case you get an error about `go: errors parsing go.mod: /project/path/  invalid go version '1.XX.X': must match format 1.23`. Remove the Go semantic version stated inside the `go.mod` file. For example change `go 1.22.1` to `go 1.22`

## Air for hot reloading

[Air](https://github.com/cosmtrek/air) is another library that enables hot reloading in Go applications. To use it, install it on your machine using the command below:

```
go install github.com/cosmtrek/air@latest
```

Next, initialize **Air** by running the command below:

```
air init
```

The command above will create a `.air.toml` file with default configurations to get your application up and running.

Finally, to enable hot reloading, run the command below:

```
air
```

# Conclusion

Both libraries enable hot reloading and offer extensive configuration and flexibility regarding which files and folders should be excluded or ignored, pattern matching, environment setup, and much more. To learn more, you can check out their official documentation.

Useful resources:

-   [Modd documentation](https://github.com/cortesi/modd)
-   [Air documentation](https://github.com/cosmtrek/air)


This guide will explore what hot reloading is and why it is needed. It will also explore two libraries to help build hot reloading into your applications.

How to implement hot reloading in a Go application

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

Appwrite + Go: Build APIs without technical overhead

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.

Go is a statically typed, compiled high-level programming language for building systems, command-line interfaces (CLI), and more. It is typically designed for use on the backend; however, there are times when you want to use the same language to build a full-stack application with a functional backend and a visual frontend.

In most cases, Go developers opt for frontend frameworks/libraries like React, Vue, Angular, etc., to build the frontend part of the application. This means they must learn JavaScript/TypeScript, framework-specific paradigms, and other frontend-related overheads.

In this guide, you’ll learn how to build a fullstack application with Go using Templ, HTMX, and Xata.

# Technology Overview

**Templ**: is a templating engine that lets you build HTML with Go. It also lets you use Go syntax like `if`, `switch`, and `for` statements to build a robust frontend. You will use Templ to build reusable components and pages for the frontend.

**HTMX**: is a frontend library that lets you access modern browser features directly using HTML rather than JavaScript. You will use HTMX to process the form submission and perform other dynamic operations.

**Xata**: is a serverless database with analytics and free-text search support that makes a wide range of applications easy to build.

# Prerequisites

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

-   [Go version 1.20 or higher installed](https://go.dev/dl/)
-   Basic understanding of Go
-   Xata account. [Signup is free](https://app.xata.io/signin?mode=signup?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)

# Getting started

To get started, you need to install Templ binary. The binary generates Go code from a Templ file.

```bash
go install github.com/a-h/templ/cmd/templ@latest
```

Create a directory.

```bash
mkdir go_fullstack && cd go_fullstack
```

Next, initialize a Go module to manage project dependencies.

```bash
go mod init go-fullstack
```

Finally, we proceed to install the required dependencies with:

```bash
go get github.com/gin-gonic/gin github.com/a-h/templ github.com/joho/godotenv
```

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

`github.com/a-h/templ` is the Templ library used in the project.

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

## Structuring the application

To do this, create a `cmd`, `internals`, and `views` folder in our project directory.

`cmd` is for structuring the application entry point.

`internals` is for structuring API-related files.

`views` is for structuring frontend-related files.

# Setup the database on Xata

Log into the [Xata workspace](https://app.xata.io/workspaces) and create a `todo` database. Inside the `todo` database, create a `Todo` table and add a `description` column of type `String`.

![create project](https://paper-attachments.dropboxusercontent.com/s_724B5DB0ED02FBEDE105C37DC2102A0D29EC66EAFDCC27146EA9AEF451272040_1703592508608_Screenshot+2023-12-26+at+13.07.33.png)

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

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.

![](https://paper-attachments.dropboxusercontent.com/s_724B5DB0ED02FBEDE105C37DC2102A0D29EC66EAFDCC27146EA9AEF451272040_1703596013324_Screenshot+2023-12-26+at+14.04.29.png)
![](https://paper-attachments.dropboxusercontent.com/s_724B5DB0ED02FBEDE105C37DC2102A0D29EC66EAFDCC27146EA9AEF451272040_1703596030165_Screenshot+2023-12-21+at+23.42.03.png)

**Setup environment variable**

Create a `.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>
```

# Build the application Frontend

To build the frontend, you’ll use Templ and HTMX to structure the application and add dynamism to a Todo application.

## Create the application components

Inside the `views` folder, create a `components/header.templ` file and add the snippet below:

```go
package components

templ Header() {
    <head>
        <script
            src="https://unpkg.com/htmx.org@1.9.10"
            integrity="sha384-D1Kt99CQMDuVetoL1lrYwg5t+9QdHe7NLX/SoJYkXDFfX37iInKRy5xLSi8nO7UC"
            crossorigin="anonymous"
        ></script>
        <script src="https://cdn.tailwindcss.com"></script>
        <meta charset="UTF-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>GO Fullstack</title>
    </head>
}
```

The snippet creates a `Header` component and adds HTMX and TailwindCSS CDNs. TailwindCSS is a low-level framework for styling.

Next, create a `components/footer.templ` file to create the application footer and style using TailwindCSS classes.

```go
package components

templ Footer() {
    <footer class="fixed p-1 bottom-0 bg-gray-100 w-full border-t">
    <div class="rounded-lg p-4 text-xs italic text-gray-700 text-center">
        &copy; Go Fullstack
    </div>
    </footer>
}
```

Finally, create an `index.templ` file inside the same `views` folder and add the snippet below:

```go
package views

import (
    "fmt"
    "go_fullstack/views/components"
)

type Todo struct {
    Id          string
    Description string
}

templ Index(todos []*Todo) {
    <!DOCTYPE html>
    <html lang="en">
        @components.Header()
        <body>
            <main class="min-h-screen w-full">
                <nav class="flex w-full border border-b-zinc-200 px-4 py-4">
                    <h3 class="text-base lg:text-lg font-medium text-center">
                        GO Fullstack app
                    </h3>
                </nav>
                <div class="mt-6 w-full flex justify-center items-center flex-col">
                    // FORM PROCESSING
                    <form
                        hx-post="/"
                        hx-trigger="submit"
                        hx-swap="none"
                        onsubmit="reloadPage()"
                        class="w-96"
                    >
                        <textarea
                            name="description"
                            cols="30"
                            rows="2"
                            class="w-full border rounded-lg mb-2 p-4"
                            placeholder="Input todo details"
                            required
                        ></textarea>
                        <button
                            class="py-1 px-4 w-full h-10 rounded-lg text-white bg-zinc-800"
                        >
                            Create
                        </button>
                    </form>
                    <section class="border-t border-t-zinc-200 mt-6 px-2 py-4 w-96">
                        // LOOP THROUGH THE TODOS
                        <ul id="todo-list">
                            for _, todo := range todos {
                                <li class="ml-4 ml-4 border p-2 rounded-lg mb-2" id={ fmt.Sprintf("%s", todo.Id) }>
                                    <p class="font-medium text-sm">Todo item { todo.Id }</p>
                                    <p class="text-sm text-zinc-500 mb-2">
                                        { todo.Description }
                                    </p>
                                    <div class="flex gap-4 items-center mt-2">
                                        <a
                                            href="#"
                                            class="flex items-center border py-1 px-2 rounded-lg"
                                        >
                                            <p class="text-sm">Edit</p>
                                        </a>
                                        <button
                                            hx-delete={ fmt.Sprintf("/%s", todo.Id) }
                                            hx-swap="delete"
                                            hx-target={ fmt.Sprintf("#%s", todo.Id) }
                                            class="flex items-center border py-1 px-2 rounded-lg hover:bg-red-300"
                                        >
                                            <p class="text-sm">Delete</p>
                                        </button>
                                    </div>
                                </li>
                            }
                        </ul>
                    </section>
                </div>
            </main>
        </body>
        @components.Footer()
    </html>
    <script>
        function reloadPage() {
                setTimeout(function() {
            window.location.reload();
        }, 2000);
        }
    </script>
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Creates a `Todo` struct to represent the response data coming from the backend
-   Creates an `Index` component that uses the `Header` and `Footer` components to structure the page. Then, it uses the HTMX attributes to process form submissions and deletion of todos by calling the respective endpoints `/` and `/{todo.Id}`

## Generating Go files from the Templ files

Next, use the Templ binary you installed earlier to Generate Go codes from the views created above by running the command below in your terminal:

```bash
templ generate
```

After you run this command, you’ll see new Go files generated for each view. You use generated file to render your frontend in next section.

![Generated files](https://paper-attachments.dropboxusercontent.com/s_F11F11938F7C8DFA1B769A23ABB6104DEEFCB6B159F515F54CB1BDB5F18F2959_1713349771513_Screenshot+2024-04-17+at+11.28.49.png)

> The generated files are not to be edited.

# Putting it together and building the backend

With that done, you can use it to build the backend and render the required page.

## Create the API models and helper function

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

```go
package internals

type Todo struct {
    Id          string `json:"id,omitempty"`
    Description string `json:"description,omitempty"`
}

type TodoRequest struct {
    Description string `json:"description,omitempty"`
}

type TodoResponse struct {
    Id string `json:"id,omitempty"`
}
```

The snippet above creates a `Todo`, `TodoRequest`, and `TodoResponse` 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.

```go
package internals

import (
    "log"
    "os"
    "github.com/joho/godotenv"
)

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

## Create the application and API routes

Create a `route.go` file for configuring the API routes 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 services

With that done, create a `xata_service.go` file for the application and update it by doing the following:

First, import the required dependencies and create a helper function:

```go
package internals

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

var xataAPIKey = GetEnvVariable("XATA_API_KEY")
var baseURL = GetEnvVariable("XATA_DATABASE_URL")

func createRequest(method, url string, bodyData *bytes.Buffer) (*http.Request, error) {
    var req *http.Request
    var err error'

    if method == "GET" || method == "DELETE" || bodyData == nil {
        req, err = http.NewRequest(method, url, nil)
    } else {
        req, err = http.NewRequest(method, url, bodyData)
    }

    if err != nil {
        return nil, err
    }

    req.Header.Add("Content-Type", "application/json")
    req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", xataAPIKey))

    return req, nil
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Creates required environment variables
-   Creates a `createRequest` function that creates HTTP requests with the required headers

Lastly, add a `createTodoService`, `deleteTodoService`, and `getAllTodosService` methods to create, delete, and get the list of todos.

```go
//imports goes here

func createRequest(method, url string, bodyData *bytes.Buffer) (*http.Request, error) {
    //createRequest code goes here
}

func (app *Config) createTodoService(newTodo *TodoRequest) (*TodoResponse, error) {
    createTodo := TodoResponse{}
    jsonData := Todo{
        Description: newTodo.Description,
    }

    bodyData := new(bytes.Buffer)
    json.NewEncoder(bodyData).Encode(jsonData)

    fullURL := fmt.Sprintf("%s:main/tables/Todo/data", baseURL)
    req, err := createRequest("POST", fullURL, bodyData)
    if err != nil {
        return nil, err
    }

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

    defer resp.Body.Close()
    if err := json.NewDecoder(resp.Body).Decode(&createTodo); err != nil {
        return nil, err
    }

    return &createTodo, nil
}
func (app *Config) deleteTodoService(id string) (string, error) {
    fullURL := fmt.Sprintf("%s:main/tables/Todo/data/%s", baseURL, id)
    client := &http.Client{}
    req, err := createRequest("DELETE", fullURL, nil)
    if err != nil {
        return "", err
    }

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

    return id, nil
}

func (app *Config) getAllTodosService() ([]*Todo, error) {
    var todos []*Todo

    fullURL := fmt.Sprintf("%s:main/tables/Todo/query", baseURL)
    client := &http.Client{}
    req, err := createRequest("POST", fullURL, nil)
    if err != nil {
        return nil, err
    }

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

    defer resp.Body.Close()
    var response struct {
        Records []*Todo `json:"records"`
    }

    decoder := json.NewDecoder(resp.Body)
    if err := decoder.Decode(&response); err != nil {
        return nil, err
    }

    todos = response.Records
    return todos, nil
}
```

## Create the API handlers

With that done, you can use the services to create the API handlers. Create a `handler.go` file inside `internals` folder and add the snippet below:

```go
package internals

import (
    "context"
    "fmt"
    "go_fullstack/views"
    "net/http"
    "time"
    "github.com/a-h/templ"
    "github.com/gin-gonic/gin"
)

const appTimeout = time.Second * 10

func render(ctx *gin.Context, status int, template templ.Component) error {
    ctx.Status(status)
    return template.Render(ctx.Request.Context(), ctx.Writer)
}

func (app *Config) indexPageHandler() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        _, cancel := context.WithTimeout(context.Background(), appTimeout)
        defer cancel()

        todos, err := app.getAllTodosService()
        if err != nil {
            ctx.JSON(http.StatusBadRequest, err.Error())
            return
        }

        var viewsTodos []*views.Todo
        for _, todo := range todos {
            viewsTodo := &views.Todo{
                Id:          todo.Id,
                Description: todo.Description,
            }
            viewsTodos = append(viewsTodos, viewsTodo)
        }

        render(ctx, http.StatusOK, views.Index(viewsTodos))
    }
}

func (app *Config) createTodoHandler() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        _, cancel := context.WithTimeout(context.Background(), appTimeout)
        description := ctx.PostForm("description")
        defer cancel()

        newTodo := TodoRequest{
            Description: description,
        }

        data, err := app.createTodoService(&newTodo)
        if err != nil {
            ctx.JSON(http.StatusBadRequest, err.Error())
            return
        }

        ctx.JSON(http.StatusCreated, data)
    }
}

func (app *Config) deleteTodoHandler() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        _, cancel := context.WithTimeout(context.Background(), appTimeout)
        id := ctx.Param("id")
        defer cancel()

        data, err := app.deleteTodoService(id)
        if err != nil {
            ctx.JSON(http.StatusBadRequest, err.Error())
            return
        }

        ctx.JSON(http.StatusAccepted, fmt.Sprintf("Todo with ID: %s deleted successfully!!", data))
    }
}
```

The snippet above does the following

-   Imports the required dependencies
-   Creates a `render` function that uses the `Templ` package to render matching template
-   Creates an `indexPageHandler` function that returns a Gin-gonic handler and takes in the `Config` struct as a pointer. Inside the returned handler, use the `getAllTodosService` service to get the list of todos and then render the appropriate page using the generated code from the views package (frontend)
-   Creates a `createdTodoHandler` and `deleteProjectHandler` functions that return a Gin-gonic handler and take in the `Config` struct as a pointer. Use the service created earlier to perform the corresponding action inside the returned handler

## Update the API routes to use handlers

Update the `routes.go` file with the handlers as shown below:

```go
package internals

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

type Config struct {
    Router *gin.Engine
}

func (app *Config) Routes() {
    //views
    app.Router.GET("/", app.indexPageHandler())

    //apis
    app.Router.POST("/", app.createTodoHandler())
    app.Router.DELETE("/:id", app.deleteTodoHandler())
}
```

## Putting it all together

Create the application entry point to use to serve the routes. To do this, create a `main.go` file inside the `cmd` folder and add the snippet below:

```go
package main

import (
    "go_fullstack/internals"
    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()

    //initialize config
    app := internals.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, you can start a development server using the command below:

    go run cmd/main.go

![](https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExdmh4OGFocG9qMndmbXpsbW1hY2Q3dXRhYjA5OG9wdXppc3d3MjRrdCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/gPVi98WZGeVZuCgBG9/giphy.gif)

The complete source code can be found on [GitHub](https://github.com/Mr-Malomz/go_fullstack).

# Conclusion

This post discusses how to build a fullstack application with Go, Templ, HTMX, and Xata. You can extend the application further to support viewing and editing todos.

These resources may also be helpful:

-   [Xata documentation](https://xata.io/docs?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [Templ documentation](https://templ.guide/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [HTMX documentation](https://htmx.org/docs/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [Go + Xata](https://fullstackwriter.dev/post/xata-go-a-getting-started-guide?category=Golang)


In this guide, you’ll learn how to build a fullstack application with Go using Templ, HTMX, and Xata.

How to build a fullstack application with Go, Templ, and HTMX

Microservices architecture is one of the preferred methods of building scalable and robust applications. It involves breaking large applications into smaller components that are well-defined, performs a specific task and uses sets of application programming interface (API) for their communication.

Communication is an essential part of microservices; it plays an important role in letting services talk to each other within the larger application context. Some examples of protocol microservices use to communicate with each other includes HTTP, **gRPC**, message brokers, etc.

In this article, we will explore what gRPC is and how to get started by building a user management service using gRPC, MongoDB and Golang.

## What is gRPC?

gRPC is a modern communication framework that can run in any environment and helps connect services efficiently. It was introduced in 2015 and governed by the Cloud Native Computing Platform (CNCF). Beyond efficiently connecting services across a distributed system, mobile applications, frontend to backend, etc., it supports health checking, load balancing, tracing, and authentication.

gRPC offers a fresh perspective to developers building medium to complex applications as it can generate client and server bindings for multiple languages. The following are some of its benefits:

**Service definition**

gRPC uses Protocol Buffers as its interface description language, similar to JSON and provides features like authentication, cancellation, timeouts, etc.

**Lightweight and performant**

gRPC definitions are 30 percent smaller than JSON definitions and are 5 to 7 times faster than a traditional REST API.

**Multiple platform support**

gRPC is language agnostic and has automated code generation for client and server-supported languages.

**Scalable**

From the developer’s environment to production, gRPC is designed to scale millions ler seconds requests.

# Getting started

Now that we understand gRPC's importance in building scalable applications, let’s build a user management service with gRPC, MongoDB, and Golang. The project source code can be found [here](https://github.com/Mr-Malomz/grpc_go).

## Prerequisites

To fully grasp the concepts presented in this tutorial, the following are required:

-   Basic understanding of Golang
-   Basic understanding of Protocol Buffer
-   Protocol Buffer [compiler](https://grpc.io/docs/protoc-installation/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog) installed
-   A [MongoDB account](https://www.mongodb.com/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog) to host the database. [**Signup**](https://www.mongodb.com/cloud/atlas/register?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog) **is completely free**.
-   [Postman](https://www.postman.com/downloads/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog) or any gRPC testing application

## Project and Dependencies setup

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

```bash
mkdir grpc_go && cd grpc_go
```

This command creates a Golang project called `grpc_go` and navigates into the project directory.

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

```bash
go mod init grpc_go
```

This command will create a `go.mod` file for tracking project dependencies.

We proceed to install the required dependencies with:

```bash
go get google.golang.org/grpc go.mongodb.org/mongo-driver/mongo github.com/joho/godotenv google.golang.org/protobuf
```

`google.golang.org/grpc` is the Golang implementation of gRPC.

`go.mongodb.org/mongo-driver/mongo` is a driver for connecting to MongoDB.

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

`google.golang.org/protobuf` is the Golang implementation of Protocol Buffers.

## Defining the user management Protocol Buffer and compilation

To get started, we need to define a Protocol Buffer to represent all the operations and responses involved in the user management service. To do this, first, we need to create a `proto` folder in the root directory, and in this folder, create a `user.proto` file and add the snippet below:

```proto
syntax = "proto3";
package user;
option go_package = "grpc_go/proto";

service UserService {
    rpc GetUser (UserRequest) returns (UserResponse);
    rpc CreateUser (CreateUserRequest) returns (CreateUserResponse);
    rpc UpdateUser (UpdateUserRequest) returns (UpdateUserResponse);
    rpc DeleteUser (DeleteUserRequest) returns (DeleteUserResponse);
    rpc GetAllUsers (Empty) returns (GetAllUsersResponse);
}

message UserRequest {
    string id = 1;
}

message UserResponse {
    string id = 1;
    string name = 2;
    string location = 3;
    string title = 4;
}

message CreateUserRequest {
    string name = 2;
    string location = 3;
    string title = 4;
}

message CreateUserResponse {
    string data = 1;
}

message UpdateUserRequest {
    string id = 1;
    string name = 2;
    string location = 3;
    string title = 4;
}

message UpdateUserResponse {
    string data = 1;
}

message DeleteUserRequest {
    string id = 1;
}

message DeleteUserResponse {
    string data = 1;
}

message Empty {}

message GetAllUsersResponse {
    repeated UserResponse users = 1;
}
```

The snippet above does the following:

-   Specifies the use of `proto3` syntax
-   Declares `user` as the package name
-   Uses the `go_package` option to define the import path of the package and where the generated code will be stored
-   Creates a `service` to Create, Read, Edit, and Delete (CRUD) a user and their corresponding responses as `message`s.

Lastly, we need to compile the `user.proto` file using the command below:

```bash
protoc --go_out=. --go_opt=paths=source_relative \
    --go-grpc_out=. --go-grpc_opt=paths=source_relative \
    proto/user.proto
```

The command above uses the Protocol Buffer [compiler](https://grpc.io/docs/protoc-installation/?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog) to generate Golang server and client code by specifying the relative part and using the `user.proto` file.

> To avoid errors, we must ensure we add Golang to the path.

On successful compilation, we should see `user_grpc.pb.go` and `user.pb.go` files added to the `proto` folder. These files contain the gRPC-generated server and client code. In this article, we will only use the server code.

![gRPC-generated files](https://paper-attachments.dropboxusercontent.com/s_342FCE23FB720A94B62FAADA71BB64C7EAFA3BCC57C036F2CB5FC2D41E7F294F_1683671528193_Screenshot+2023-05-07+at+23.04.33.png)

## Using the generated code from gRPC in our application

With the compilation process done, we can start using the generated code in our application.

**Database setup and integration**

First, we need to set up a database and a collection on MongoDB as shown below:

![database setup](https://paper-attachments.dropboxusercontent.com/s_342FCE23FB720A94B62FAADA71BB64C7EAFA3BCC57C036F2CB5FC2D41E7F294F_1683672826154_Screenshot+2023-05-09+at+23.49.07.png)

We also need to get our database connection string by clicking on the **Connect** button and changing the Driver to `Go`.

![](https://paper-attachments.dropboxusercontent.com/s_342FCE23FB720A94B62FAADA71BB64C7EAFA3BCC57C036F2CB5FC2D41E7F294F_1683672832009_Screenshot+2023-05-09+at+23.52.03.png)

Secondly, we must modify the copied connection string with the user's password we created earlier and change the database name. To do this, we need to create a `.env` file in the root directory and add the snippet copied:

```bash
MONGOURI=mongodb+srv://<YOUR USERNAME HERE>:<YOUR PASSWORD HERE>@cluster0.e5akf.mongodb.net/<DATABASE NAME>?retryWrites=true&w=majority
```

Sample of a properly filled connection string below:

```bash
MONGOURI=mongodb+srv://malomz:malomzPassword@cluster0.e5akf.mongodb.net/projectMngt?retryWrites=true&w=majority
```

Thirdly, we need to create a helper function to load the environment variable using the `github.com/joho/godotenv` library. To do this, we need to create a `configs` folder in the root directory; here, create an `env.go` file and add the snippet below:

```go
package configs

import (
    "log"
    "os"
    "github.com/joho/godotenv"
)

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

Fourthly, we need to create a model to represent our application data. To do this, we need to create `user_model.go` file in the same `configs` folder and add the snippet below:

```go
package configs

import "go.mongodb.org/mongo-driver/bson/primitive"

type User struct {
    Id       primitive.ObjectID `json:"id,omitempty"`
    Name     string             `json:"name,omitempty" validate:"required"`
    Location string             `json:"location,omitempty" validate:"required"`
    Title    string             `json:"title,omitempty" validate:"required"`
}
```

Lastly, we need to create a `db.go` file to implement our database logic in the same `configs` folder and add the snippet below:

```go
package configs

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

type dbHandler interface {
    GetUser(id string) (*User, error)
    CreateUser(user User) (*mongo.InsertOneResult, error)
    UpdateUser(id string, user User) (*mongo.UpdateResult, error)
    DeleteUser(id string) (*mongo.DeleteResult, error)
    GetAllUsers() ([]*User, error)
}

type DB struct {
    client *mongo.Client
}

func NewDBHandler() dbHandler {
    client, err := mongo.NewClient(options.Client().ApplyURI(EnvMongoURI()))
    if err != nil {
        log.Fatal(err)
    }

    ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
    err = client.Connect(ctx)
    if err != nil {
        log.Fatal(err)
    }

    //ping the database
    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Connected to MongoDB")

    return &DB{client: client}
}

func colHelper(db *DB) *mongo.Collection {
    return db.client.Database("projectMngt").Collection("User")
}

func (db *DB) CreateUser(user User) (*mongo.InsertOneResult, error) {
    col := colHelper(db)
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    newUser := User{
        Id:       primitive.NewObjectID(),
        Name:     user.Name,
        Location: user.Location,
        Title:    user.Title,
    }
    res, err := col.InsertOne(ctx, newUser)

    if err != nil {
        return nil, err
    }

    return res, err
}

func (db *DB) GetUser(id string) (*User, error) {
    col := colHelper(db)
    var user User
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    objId, _ := primitive.ObjectIDFromHex(id)

    err := col.FindOne(ctx, bson.M{"_id": objId}).Decode(&user)

    if err != nil {
        return nil, err
    }

    return &user, err
}

func (db *DB) UpdateUser(id string, user User) (*mongo.UpdateResult, error) {
    col := colHelper(db)
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    objId, _ := primitive.ObjectIDFromHex(id)

    update := bson.M{"name": user.Name, "location": user.Location, "title": user.Title}
    result, err := col.UpdateOne(ctx, bson.M{"_id": objId}, bson.M{"$set": update})

    if err != nil {
        return nil, err
    }

    return result, err
}

func (db *DB) DeleteUser(id string) (*mongo.DeleteResult, error) {
    col := colHelper(db)
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    objId, _ := primitive.ObjectIDFromHex(id)

    result, err := col.DeleteOne(ctx, bson.M{"_id": objId})

    if err != nil {
        return nil, err
    }

    return result, err
}

func (db *DB) GetAllUsers() ([]*User, error) {
    col := colHelper(db)
    var users []*User
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    results, err := col.Find(ctx, bson.M{})

    if err != nil {
        return nil, err
    }

    for results.Next(ctx) {
        var singleUser *User
        if err = results.Decode(&singleUser); err != nil {
            return nil, err
        }
        users = append(users, singleUser)
    }

    return users, err
}
```

The snippet above does the following:

-   Imports the required dependencies
-   **Line 15 - 21**: Defines a `dbHandler` interface that describes all the associated functions in our user management service
-   **Line 23 - 25**: Creates a `DB` struct with `col` property that will implement the `dbHandler` interface
-   **Line 27 - 48**: Creates a `NewDBHandler` constructor function that ties the `DB` struct and the `dbHandler` interface it implements by initializing the database connection to MongoDB and returning the appropriate response
-   **Line 50 - 52**: Creates a `colHelper` function that accepts the database connection by specifying the database name and associated collection
-   **Line 54 - 145**: Creates the required methods `CreateUser`, `GetUser`, `UpdateUser`, `DeleteUser`, and `GetAllUsers` with a `DB` pointer receiver and returns the appropriate responses. The methods also use the appropriate methods from MongoDB to perform the required operations

**Integrating the database logic with gRPC-generated code**

With our database logic setup, we can use the methods to create our application handlers. To do this, we need to create a `service` folder; here, create a `user_service.go` file and add the snippet below:

```go
package services

import (
    "context"
    "grpc_go/configs"
    pb "grpc_go/proto"
)

var db = configs.NewDBHandler()

type UserServiceServer struct {
    pb.UnimplementedUserServiceServer
}

func (service *UserServiceServer) GetUser(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
    resp, err := db.GetUser(req.Id)

    if err != nil {
        return nil, err
    }

    return &pb.UserResponse{Id: resp.Id.String(), Name: resp.Name, Location: resp.Location, Title: resp.Title}, nil
}

func (service *UserServiceServer) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.CreateUserResponse, error) {
    newUser := configs.User{Name: req.Name, Location: req.Location, Title: req.Title}
    _, err := db.CreateUser(newUser)

    if err != nil {
        return nil, err
    }

    return &pb.CreateUserResponse{Data: "User created successfully!"}, nil
}

func (service *UserServiceServer) UpdateUser(ctx context.Context, req *pb.UpdateUserRequest) (*pb.UpdateUserResponse, error) {
    newUser := configs.User{Name: req.Name, Location: req.Location, Title: req.Title}
    _, err := db.UpdateUser(req.Id, newUser)

    if err != nil {
        return nil, err
    }

    return &pb.UpdateUserResponse{Data: "User updated successfully!"}, nil
}

func (service *UserServiceServer) DeleteUser(ctx context.Context, req *pb.DeleteUserRequest) (*pb.DeleteUserResponse, error) {
    _, err := db.DeleteUser(req.Id)

    if err != nil {
        return nil, err
    }

    return &pb.DeleteUserResponse{Data: "User details deleted successfully!"}, nil
}

func (service *UserServiceServer) GetAllUsers(context.Context, *pb.Empty) (*pb.GetAllUsersResponse, error) {
    resp, err := db.GetAllUsers()
    var users []*pb.UserResponse

    if err != nil {
        return nil, err
    }

    for _, v := range resp {
        var singleUser = &pb.UserResponse{
            Id:       v.Id.String(),
            Name:     v.Name,
            Location: v.Location,
            Title:    v.Title,
        }
        users = append(users, singleUser)
    }

    return &pb.GetAllUsersResponse{Users: users}, nil
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Initializes the database using the `NewDBHandler` constructor function
-   Creates a `UserServiceServer` that implements the gRPC-generated `UserServiceServer` interface inside the `user_grpc.pb.go` file
-   Creates the required methods by passing the `UserServiceServer` struct as a pointer and returning the appropriate responses as generated by gRPC

**Creating the server**

With that done, we can create the application gRPC server by creating a `main.go` file in the root directory and add the snippet below:

```go
package main

import (
    "log"
    "net"

    pb "grpc_go/proto"
    "grpc_go/services"
    "google.golang.org/grpc"
)
func main() {
    lis, err := net.Listen("tcp", "[::1]:8080")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    grpcServer := grpc.NewServer()
    service := &services.UserServiceServer{}

    pb.RegisterUserServiceServer(grpcServer, service)
    err = grpcServer.Serve(lis)

    if err != nil {
        log.Fatalf("Error strating server: %v", err)
    }
}
```

The snippet above does the following:

-   Imports the required dependencies
-   Specifies the application port using the in-built `net` package
-   Creates an instance of gRPC server using the `NewServer` method and specifies the associated service using the `UserServiceServer` struct
-   Register the service implementation with the gRPC server
-   Starts the server using the `Serve` method by passing the required port and handling errors appropriately

With that done, we can test our application by running the command below in our terminal.

```bash
go run main.go
```

## Testing with Postman

With our server up and running, we can test our application by creating a new **gRPC Request**.

![Create new](https://paper-attachments.dropboxusercontent.com/s_80F8DDD905BBAA506022F629DD8AAC7F4C11E43711F085CB17CB09D07EC7D70E_1683337484831_Screenshot+2023-04-28+at+00.18.35.png)

![Select gRPC Request](https://paper-attachments.dropboxusercontent.com/s_80F8DDD905BBAA506022F629DD8AAC7F4C11E43711F085CB17CB09D07EC7D70E_1683337484805_Screenshot+2023-04-28+at+00.19.06.png)

Input `grpc://[::1]:8080` as the URL, select the **Import a .proto file** option and upload the `user.proto` file we created earlier.

![URL and upload proto file](https://paper-attachments.dropboxusercontent.com/s_80F8DDD905BBAA506022F629DD8AAC7F4C11E43711F085CB17CB09D07EC7D70E_1683337591306_Screenshot+2023-04-28+at+00.27.32.png)

With that done, the corresponding method will be populated and we can test them accordingly.

![getAllUsers](https://paper-attachments.dropboxusercontent.com/s_80F8DDD905BBAA506022F629DD8AAC7F4C11E43711F085CB17CB09D07EC7D70E_1683337760054_Screenshot+2023-04-28+at+00.43.19.png)
![getAUser](https://paper-attachments.dropboxusercontent.com/s_80F8DDD905BBAA506022F629DD8AAC7F4C11E43711F085CB17CB09D07EC7D70E_1683337760024_Screenshot+2023-04-28+at+00.43.59.png)

We can also validate that our gRPC server works by checking our MongoDB collection

![Collection](https://paper-attachments.dropboxusercontent.com/s_342FCE23FB720A94B62FAADA71BB64C7EAFA3BCC57C036F2CB5FC2D41E7F294F_1683757798244_Screenshot+2023-05-10+at+23.29.30.png)

## Conclusion

This post discussed what gRPC is, its role in building scalable applications and how to get started by building a user management service with Golang and MongoDB. Beyond what was discussed above, gRPC offers robust techniques around authentication, error handling, performance, etc.

These resources might be helpful:

-   [Golang gRPC implementation](https://pkg.go.dev/google.golang.org/grpc?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [Golang Protocol Buffer implementation](https://pkg.go.dev/google.golang.org/protobuf?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)
-   [MongoDB Golang driver](https://github.com/mongodb/mongo-go-driver?utm_source=fullstackwriter&utm_medium=fullstackwriter-blog)

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

Getting started with gRPC in Golang

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

Golang

How to implement hot reloading in a Go application

Appwrite + Go: Build APIs without technical overhead

Xata + Go: A getting started guide.

How to build a fullstack application with Go, Templ, and HTMX

Getting started with gRPC in Golang

Build APIs faster with Go and Appwrite

blog

Contact