Building a REST API with GORM, Echo Framework, and PostgreSQL in Go

Combining GORM, the powerful ORM library for Go, with Echo, a fast and minimalist web framework, along with PostgreSQL, offers a robust foundation for developing efficient and scalable RESTful APIs. In this comprehensive tutorial, we'll create a practical example demonstrating the integration of GORM, Echo, and PostgreSQL to build a fully functional REST API in Go.

Prerequisites

To follow along, ensure you have the following:

• Go installed on your machine

• PostgreSQL installed and running

• Basic knowledge of Go, SQL, and RESTful APIs

Setting Up the Project

Initializing the Project

Start by initializing a new Go module:

go mod init your_project_name

Install the required dependencies:

go get -u github.com/labstack/echo/v4
go get -u github.com/labstack/echo/v4/middleware
go get -u github.com/jinzhu/gorm
go get -u github.com/jinzhu/gorm/dialects/postgres

Creating Database

Create a PostgreSQL database and define a users table with columns id, name, and email.

Building the REST API

Setting Up Echo Server

Create a new Go file, e.g., main.go, and set up the Echo server:

package main

import (
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

var (
    db *gorm.DB
)

func init() {
    var err error
    dsn := "postgresql://user:password@localhost/database_name?sslmode=disable" // Update with your database credentials
    db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect to database")
    }

    // Auto migrate the User model
    db.AutoMigrate(&User{})
}

type User struct {
    gorm.Model
    Name  string `json:"name"`
    Email string `json:"email"`
}

func getUsers(c echo.Context) error {
    var users []User
    db.Find(&users)
    return c.JSON(200, users)
}

func main() {
    e := echo.New()

    // Middleware
    e.Use(middleware.Logger())
    e.Use(middleware.Recover())

    // Routes
    e.GET("/users", getUsers)

    // Start server
    e.Logger.Fatal(e.Start(":8080"))
}

Implementing API Endpoints

GET Users

The GET /users endpoint retrieves all users from the database:

func getUsers(c echo.Context) error {
    var users []User
    db.Find(&users)
    return c.JSON(200, users)
}

POST User

The POST /users endpoint creates a new user:

func createUser(c echo.Context) error {
    user := new(User)
    if err := c.Bind(user); err != nil {
        return err
    }
    db.Create(&user)
    return c.JSON(201, user)
}

GET User by ID

The GET /users/:id endpoint fetches a user by ID:

func getUserByID(c echo.Context) error {
    id := c.Param("id")
    var user User
    db.First(&user, id)
    return c.JSON(200, user)
}

DELETE User by ID

The DELETE /users/:id endpoint deletes a user by ID:

func deleteUserByID(c echo.Context) error {
    id := c.Param("id")
    var user User
    db.Delete(&user, id)
    return c.NoContent(204)
}

Registering API Endpoints

Add the new API endpoints to the Echo server in the main function:

func main() {
    e := echo.New()

    // Middleware
    e.Use(middleware.Logger())
    e.Use(middleware.Recover())

    // Routes
    e.GET("/users", getUsers)
    e.POST("/users", createUser)
    e.GET("/users/:id", getUserByID)
    e.DELETE("/users/:id", deleteUserByID)

    // Start server
    e.Logger.Fatal(e.Start(":8080"))
}

Testing the API

Build and run the application:

go run main.go

Testing Endpoints

• To retrieve all users: GET http://localhost:8080/users

• To create a user: POST http://localhost:8080/users with JSON payload

• To retrieve a user by ID: GET http://localhost:8080/users/:id

• To delete a user by ID: DELETE http://localhost:8080/users/:id

Conclusion

Combining GORM, Echo, and PostgreSQL provides a robust foundation for developing RESTful APIs in Go. This example demonstrates the integration of GORM with Echo and PostgreSQL to create a fully functional API with endpoints for user management.

Building upon this example, developers can extend functionality, and implement authentication, validation, and further endpoints, leveraging the capabilities of GORM and Echo to build scalable and efficient APIs in Go.

I hope this helps, you!!

More such articles:

https://medium.com/techwasti

https://www.youtube.com/@maheshwarligade

https://techwasti.com/series/spring-boot-tutorials

https://techwasti.com/series/go-language