Simple CRUD with GoFiber

Creating web APIs with Go is relatively easy and straight forward, especially when using framework, it will help you to fasten the development process.

In this article we’re gonna examine a little bit a simple CRUD web API with GoFiber, one of popular Go web frameworks existed.

First thing first, you have to make sure your environtment supports developing Go apps. You need MySQL on your machine to work with data in this app, you can use any other database if you want, just change the configuration and .env file as much as required.

To know better about this project, go to or get the full code by cloning the repo at https://github.com/uhkrowi/go-simple-crud.

At the /cmd/app/main.go you’ll find main() and setup() function in order to initialize the setup of the application and running its web server.

func main() {
	defer config.CloseDBConnection()

	app := fiber.New(fiber.Config{
		AppName: "CRUD",
	})

	app.Use(cors.New())

	setup(app)

	port := os.Getenv("PORT")

	if port == "" {
		port = "8080"
	}

	err := app.Listen(":" + port)
	if err != nil {
		panic(err)
	}
}

func setup(app *fiber.App) {
	config.InitDB()
	db := config.DBConn
	validate := validator.New()

	apiV1 := app.Group("/api/v1")

	route.ProductRoute(apiV1.Group("/product"), db, validate)
}

Move to /internal/app/model/product.go you’ll find a model of product that has a Variants field which would contains the list of variants of the product.

type Product struct {
	ID       uuid.UUID `gorm:"primaryKey;column:id" json:"id" swaggerignore:"true"`
	Name     string    `gorm:"column:name" json:"name"`
	IsActive bool      `gorm:"column:is_active" json:"is_active"`
	Variants []Variant `gorm:"-" json:"variants"`
}

type VariantReqFilter struct {
	ProductID *uuid.UUID `query:"product_id"`
}

type Variant struct {
	ID          uuid.UUID `gorm:"primaryKey;column:id" json:"id" search:"id" swaggerignore:"true"`
	Name        string    `gorm:"column:name" json:"name"`
	ProductID   uuid.UUID `gorm:"column:product_id" json:"product_id"`
	ProductName string    `gorm:"column:product_name" json:"product_name" `
	Price       float64   `gorm:"column:price" json:"price" `
	Stock       int       `gorm:"column:stock" json:"stock"`
}

From the models above, now we know there’s a model layer, and there are several different layers that will be envolved with the process in the app, such as:

• repository: a layer to work with data from your database.
• usecase: this layer is a place where you put the main logic, usually communicate with repository and other usecase.
• handler: receiving and handling incoming http requests and directing them to the right appropriate usecase.
• route: mapping usecase and handler based on what endpoint being hit.

Now for the rest of examinations, you can explore how the flow create, read, update and delete works by your own through the repo :D