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
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.
- 登录 发表评论