Introduction

If you’re a Node.js developer who wants to learn Golang. Maybe Fiber is the right choice for you. You may recognize that Fiber is inspired by the Node.js framework — but it is written in Go.

We’ll look at Fiber’s features and components, including routing, and context, in this post. Finally, we should be able to use these features to create a demo application that interacts with PostgreSQL.

Prerequisites

We should have at least a basic understanding of the Go programming language in order to follow along with this tutorial. Knowing a little bit of Express could also help to quickly understand Fiber from an architectural perspective.

Also, make sure you have the Postgres for your operating system, which you can get here. You can also install any Postgres GUI client. We’ll be using PGAdmin4 in this article, which you can install alongside the Postgres installer.

You should also make sure that you have the latest version of Go installed on your computer.

Let’s Code

Initialize our project:

go mod init github.com/[YourGithubAccount]/[YourProjectName]
// example
go mod init github.com/adhtanjung/go_rest_api

Here is a screenshot of our project directory:

In today’s example we are going to install only these dependencies, which are as follows:

go get github.com/gofiber/fiber/v2
go get github.com/google/uuid
go get github.com/lib/pq
go get github.com/joho/godotenv
go get -u gorm.io/gorm

ENV

Now let’s start by fill in our .env file, our .env file contains our secrets required for our database connection.

DB_HOST=localhost
DB_PORT=5432
DB_USER=postgres
DB_PASSWORD=
DB_NAME=postgres

Config

Setup our config/config.go

package configimport (
 "fmt"
 "os"
 "github.com/joho/godotenv"
)// Config func to get env value from key ---
func Config(key string) string {
 // load .env file
 err := godotenv.Load(".env")
 if err != nil {
  fmt.Print("Error loading .env file")
 }
 return os.Getenv(key)}

Main.go

Setup our main.go file:

package mainimport (
 "github.com/adhtanjung/go_rest_api/database"
 "github.com/adhtanjung/go_rest_api/router"
 "github.com/gofiber/fiber/v2"
 "github.com/gofiber/fiber/v2/middleware/cors"
 "github.com/gofiber/fiber/v2/middleware/logger"
 _ "github.com/lib/pq"
)func main() {
 database.Connect() app := fiber.New() app.Use(logger.New()) app.Use(cors.New()) router.SetupRoutes(app) // handle unavailable route
 app.Use(func(c *fiber.Ctx) error {
  return c.SendStatus(404) // => 404 "Not Found"
 }) app.Listen(":8080")
}

Database

Next database/database.go:

package databaseimport (
 "fmt"
 "log"
 "os"
 "strconv"
 "gorm.io/driver/postgres"
 "github.com/adhtanjung/go_rest_api/config"
 "github.com/adhtanjung/go_rest_api/model"
 "gorm.io/gorm"
 "gorm.io/gorm/logger"
)// Database instance
type Dbinstance struct {
 Db *gorm.DB
}var DB Dbinstance// Connect function
func Connect() {
 p := config.Config("DB_PORT")
 // because our config function returns a string, we are parsing our      str to int here
 port, err := strconv.ParseUint(p, 10, 32) if err != nil {
  fmt.Println("Error parsing str to int")
 } dsn := fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%d sslmode=disable TimeZone=Asia/Shanghai", config.Config("DB_HOST"), config.Config("DB_USER"), config.Config("DB_PASSWORD"),  config.Config("DB_NAME"), port) db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
  Logger: logger.Default.LogMode(logger.Info),
 }) if err != nil {
  log.Fatal("Failed to connect to database. \n", err)
  os.Exit(2)
 } log.Println("Connected")
 db.Logger = logger.Default.LogMode(logger.Info)
 log.Println("running migrations")
 db.AutoMigrate(&model.User{}) DB = Dbinstance{
  Db: db,
 }
}

Models

Defining our Model, which will have a total of 4 properties:

/model/user.go

package modelimport (
 "github.com/google/uuid"
 "gorm.io/gorm"
)// User struct
type User struct {
 gorm.Model
 ID       uuid.UUID `gorm:"type:uuid;"`
 Username string    `json:"username"`
 Email    string    `json:"email"`
 Password string    `json:"password"`
}// Users struct
type Users struct {
 Users []User `json:"users"`
}func (user *User) BeforeCreate(tx *gorm.DB) (err error) {
 // UUID version 4
 user.ID = uuid.New()
 return
}

Route

router/route.go

package routerimport (
 "github.com/adhtanjung/go_rest_api/handler"
 "github.com/gofiber/fiber/v2"
)// SetupRoutes func
func SetupRoutes(app *fiber.App) {
 // grouping
 api := app.Group("/api")
 v1 := api.Group("/user") // routes
 v1.Get("/", handler.GetAllUsers)
 v1.Get("/:id", handler.GetSingleUser)
 v1.Post("/", handler.CreateUser)
 v1.Put("/:id", handler.UpdateUser)
 v1.Delete("/:id", handler.DeleteUserByID)
}

Handler

handler/handler.go

package handlerimport (
 "github.com/adhtanjung/go_rest_api/database"
 "github.com/adhtanjung/go_rest_api/model"
 "github.com/gofiber/fiber/v2"
 "github.com/google/uuid"
)

Create a User

//Create a user
 func CreateUser(c *fiber.Ctx) error {
  db := database.DB.Db
  user := new(model.User) // Store the body in the user and return error if encountered
  err := c.BodyParser(user)
  if err != nil {
   return c.Status(500).JSON(fiber.Map{"status": "error", "message":  "Something's wrong with your input", "data": err})
  } err = db.Create(&user).Error
  if err != nil {
   return c.Status(500).JSON(fiber.Map{"status": "error", "message":  "Could not create user", "data": err})
  } // Return the created user
  return c.Status(201).JSON(fiber.Map{"status": "success", "message":  "User has created", "data": user})
 }

Get All Users

// Get All Users from db
func GetAllUsers(c *fiber.Ctx) error {
 db := database.DB.Db
 var users []model.User// find all users in the database
 db.Find(&users)// If no user found, return an error
 if len(users) == 0 {
  return c.Status(404).JSON(fiber.Map{"status": "error", "message": "Users not found", "data": nil})
 }// return users
 return c.Status(200).JSON(fiber.Map{"status": "sucess", "message": "Users Found", "data": users})
}

Get Single User

// GetSingleUser from db
func GetSingleUser(c *fiber.Ctx) error {
 db := database.DB.Db// get id params
 id := c.Params("id")var user model.User// find single user in the database by id
 db.Find(&user, "id = ?", id)if user.ID == uuid.Nil {
  return c.Status(404).JSON(fiber.Map{"status": "error", "message": "User not found", "data": nil})
 }return c.Status(200).JSON(fiber.Map{"status": "success", "message": "User Found", "data": user})
}

Update a user

// update a user in db
func UpdateUser(c *fiber.Ctx) error {
 type updateUser struct {
  Username string `json:"username"`
 }db := database.DB.Dbvar user model.User// get id params
 id := c.Params("id")// find single user in the database by id
 db.Find(&user, "id = ?", id)if user.ID == uuid.Nil {
  return c.Status(404).JSON(fiber.Map{"status": "error", "message": "User not found", "data": nil})
 }var updateUserData updateUser
 err := c.BodyParser(&updateUserData)
 if err != nil {
  return c.Status(500).JSON(fiber.Map{"status": "error", "message": "Something's wrong with your input", "data": err})
 }user.Username = updateUserData.Username// Save the Changes
 db.Save(&user)// Return the updated user
 return c.Status(200).JSON(fiber.Map{"status": "success", "message": "users Found", "data": user})}

Delete a user

// delete user in db by ID
func DeleteUserByID(c *fiber.Ctx) error {
 db := database.DB.Db
 var user model.User// get id params
 id := c.Params("id")// find single user in the database by id
 db.Find(&user, "id = ?", id)if user.ID == uuid.Nil {
  return c.Status(404).JSON(fiber.Map{"status": "error", "message": "User not found", "data": nil})}err := db.Delete(&user, "id = ?", id).Errorif err != nil {
  return c.Status(404).JSON(fiber.Map{"status": "error", "message": "Failed to delete user", "data": nil})
 }return c.Status(200).JSON(fiber.Map{"status": "success", "message": "User deleted"})
}

Run the app

go run main.go

GORM provides auto migration as we can see in our code, so every time we run the app, GORM will automatically migrate your schema, to keep your schema up to date.

In addition, a POSTMAN collection is available if you intend to test our API.

Postman examples:

create

getAll

getSingle

update

delete

*Soft Delete in GORM

If a model has a DeletedAt field, it will get a soft delete ability automatically! When calling Delete, the record will not be permanently removed from the database; rather, the DeletedAt‘s value will be set to the current time.

PgAdmin

If you’re facing an error with the uuid_generate_v4() you can run this query on your PGAdmin4 like this:

Select Servers>PostgreSQL14>Databases>postgres[or any databases]>Schemas>Tables> Right-click on it>Query Tool

Copy and paste this query, then run it by pressing execute button or press f5

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

Conclusion

As always, I hope you found it interesting. More details about the project can be found here.

I hope you have a great day!

What’s Next

You have now created a web API in Go from scratch. You learned about Go, Fiber, GORM, and Postgres. We have walked through a basic setup, and you can grow your API into a full-fledged web application.

• Add JWT based authentication
• Add Swagger API documentation.