docker volume create pg-todo-db-dev

docker run \
--name todo-db-dev \
-p 2345:5432 \
-e POSTGRES_PASSWORD=mysecretpassword \
-e POSTGRES_DB=todo-db \
-v pg-todo-db-dev:/var/lib/postgresql/data \
-d postgres:14-alpine

mkdir -p goapi-fiber-bun
cd goapi-fiber-bun
go mod init goapi
mkdir cmd
touch cmd/main.go

package config

import (
	"errors"
	"fmt"
	"strings"

	"github.com/spf13/viper"
)

type Config struct {
	Port int
	Dsn  string
}

func LoadConfig() (c Config, err error) {
	viper.AddConfigPath(".")                               // ระบุตำแหน่งของไฟล์ config อยู่ที่ working directory
	viper.SetConfigName("config")                          // กำหนดชื่อไฟล์ config (without extension)
	viper.SetConfigType("yaml")                            // ระบุประเภทของไฟล์ config
	viper.AutomaticEnv()                                   // ให้อ่านค่าจาก env มา replace ในไฟล์ config
	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_")) // แปลง _ underscore ใน env เป็น . dot notation ใน viper

	// อ่านไฟล์ config
	e := viper.ReadInConfig()
	if e != nil { // ถ้าอ่านไฟล์ config ไม่ได้ให้ข้ามไปเพราะให้เอาค่าจาก env มาแทนได้
		fmt.Println("please consider environment variables", e.Error())
	}

	// กำหนด Default Value
	viper.SetDefault("port", 3000)
	// err = viper.Unmarshal(&c) // ใช้กับ AutomaticEnv ไม่ได้ต้องทำเอง
	c = Config{
		Port: viper.GetInt("port"),
		Dsn:  viper.GetString("dsn"),
	}
	err = nil
	if len(c.Dsn) == 0 {
		err = errors.New("env DSN is required")
	}

	return
}

port: 3000
dsn: 'postgres://postgres:mysecretpassword@localhost:5433/todo-db?sslmode=disable'

package main

import (
	"fmt"
	"goapi/pkg/common/config"
)

func main() {
	cfg, err := config.LoadConfig()
	if err != nil {
		panic(err)
	}
	fmt.Println(cfg)
}

package database

import (
	"database/sql"

	"github.com/uptrace/bun"
	"github.com/uptrace/bun/dialect/pgdialect"
	"github.com/uptrace/bun/driver/pgdriver"
	"github.com/uptrace/bun/extra/bundebug"
)

func Init(dsn string) (*bun.DB, func(), error) {
	// Open a PostgreSQL database.
	pgdb := sql.OpenDB(pgdriver.NewConnector(pgdriver.WithDSN(dsn)))

	// Create a Bun db on top of it.
	db := bun.NewDB(pgdb, pgdialect.New())

	// Print all queries to stdout.
	db.AddQueryHook(bundebug.NewQueryHook(bundebug.WithVerbose(true)))

	err := db.Ping()
	if err != nil {
		return nil, nil, err
	}

	closeDb := func() {
		db.Close()
	}

	return db, closeDb, nil
}

package main

import (
	"fmt"
	"goapi/pkg/common/config"
	"goapi/pkg/common/database"
)

func main() {
	cfg, err := config.LoadConfig()
	if err != nil {
		panic(err)
	}

	db, closeDb, err := database.Init(cfg.Dsn)
	if err != nil {
		panic(err)
	}
	defer closeDb()
	fmt.Println(db)
}

package models

import "time"

type Todo struct {
	ID     int    `bun:"id,pk,autoincrement"`
	Title  string `bun:"title,nullzero,notnull"`
	IsDone bool   `bun:"is_done,notnull,default:false"`

	CreatedAt time.Time `bun:",nullzero,notnull,default:current_timestamp"`
	UpdatedAt time.Time `bun:",nullzero,notnull,default:current_timestamp"`
}

package logger

import (
	"os"

	"go.elastic.co/ecszap"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

var zlog *zap.Logger

func init() {
	var err error

	mode := os.Getenv("APP_MODE")
	var config zap.Config
	if mode == "production" {
		config = zap.NewProductionConfig()
	} else {
		config = zap.NewDevelopmentConfig()
	}

	config.EncoderConfig = ecszap.ECSCompatibleEncoderConfig(config.EncoderConfig)
	zlog, err = config.Build(ecszap.WrapCoreOption(), zap.AddCallerSkip(1))

	if err != nil {
		panic(err)
	}
}

func WithFields(source map[string]interface{}) *zap.Logger {
	fields := ToFields(source)
	for k, v := range source {
		fields = append(fields, zap.Any(k, v))
	}
	return zlog.With(fields...)
}

func ToFields(source map[string]interface{}) []zapcore.Field {
	fields := []zapcore.Field{}
	for k, v := range source {
		fields = append(fields, zap.Any(k, v))
	}
	return fields
}

func Info(message string, fileds ...zap.Field) {
	zlog.Info(message, fileds...)
}

func Debug(message string, fileds ...zap.Field) {
	zlog.Debug(message, fileds...)
}

func Error(message string, fileds ...zap.Field) {
	zlog.Error(message, fileds...)
}

func Warn(message string, fileds ...zap.Field) {
	zlog.Warn(message, fileds...)
}

func Fatal(message string, fileds ...zap.Field) {
	zlog.Fatal(message, fileds...)
}

func Panic(message string, fileds ...zap.Field) {
	zlog.Panic(message, fileds...)
}

package main

import (
	"fmt"
	"goapi/pkg/common/config"
	"goapi/pkg/common/database"
	"goapi/pkg/common/logger"
)

func main() {
  logger.Info("Starting the service")
	cfg, err := config.LoadConfig()
	if err != nil {
		panic(err)
	}

	db, closeDb, err := database.Init(cfg.Dsn)
	if err != nil {
		panic(err)
	}
	defer closeDb()
	fmt.Println(db)

	logger.Info("Database connected")
}

go get [github.com/gofiber/fiber/v2](http://github.com/gofiber/fiber/v2)

package main

import (
	"fmt"
	"goapi/pkg/common/config"
	"goapi/pkg/common/database"
	"goapi/pkg/common/logger"

	"github.com/gofiber/fiber/v2"
)

func main() {
	// ... load config & init db

	app := fiber.New()

	app.Get("/", func(c *fiber.Ctx) error {
		return c.SendString("Hello, World!")
	})

  logger.Info("The service is ready to listen and serve.")
	app.Listen(fmt.Sprintf(":%v", cfg.Port))
}

go run cmd/main.go

app.Static("/", "./public")

// => http://localhost:3000/doc.pdf
// => http://localhost:3000/profile/user1.jpg

app.Post("/api/v1/todos", func(c *fiber.Ctx) error {
	return c.SendString("Create new Todo")
})

app.Get("/api/v1/todos", func(c *fiber.Ctx) error {
	return c.SendString("List all Todo")
})

app.Get("/api/v1/todos/:id", func(c *fiber.Ctx) error {
	return c.SendString("Get Todo by Id")
})

app.Patch("/api/v1/todos/:id", func(c *fiber.Ctx) error {
	return c.SendString("Update Todo status by Id")
})

app.Delete("/api/v1/todos/:id", func(c *fiber.Ctx) error {
	return c.SendString("Delete Todo by Id")
})

todo := app.Group("/api/v1/todos")

todo.Post("/", func(c *fiber.Ctx) error {
	return c.SendString("Create new Todo")
})

todo.Get("/", func(c *fiber.Ctx) error {
	return c.SendString("List all Todo")
})

todo.Get("/:id", func(c *fiber.Ctx) error {
	return c.SendString("Get Todo by Id")
})

todo.Patch("/:id", func(c *fiber.Ctx) error {
	return c.SendString("Update Todo status by Id")
})

todo.Delete("/:id", func(c *fiber.Ctx) error {
	return c.SendString("Delete Todo by Id")
})

app.Get("/", func(c *fiber.Ctx) error {
  c.Get("Content-Type")       // "text/plain"
  c.Get("CoNtEnT-TypE")       // "text/plain"
  c.Get("something", "john")  // "john"
  // ..
})

todo.Post("/", func(c *fiber.Ctx) error {
	todoForm := struct {
		Text string `json:"text"`
	}{}
	c.BodyParser(&todoForm) // "{"Text":"do something"}"

	return c.SendString("Create new Todo")
})

todo.Patch("/:id", func(c *fiber.Ctx) error {
	todoForm := struct {
		Completed bool `json:"completed"`
	}{}
	c.BodyParser(&todoForm) // "{"Completed":true}"

	return c.SendString("Update Todo status by Id")
})

// GET http://lcoalhost:3000/api/v1/todos?completed=true

app.Get("/", func(c *fiber.Ctx) error {
  c.Query("completed")         // "true"
  c.Query("page", "1")         // "1"
  c.Query("limit", "10")       // "10"

  // ...
})

// GET http://localhost:3000/api/v1/todos?completed=true

todo.Get("/", func(c *fiber.Ctx) error {
	filter := struct {
		// เป็น pointer เพื่อไม่ส่งค่ามาจะให้เป็น nil เพื่อแสดงข้อมูลทั้งหมด
		Completed *bool `query:"completed"`
	}{}
	c.QueryParser(&filter) // "{"Completed":(*bool)(true)}"

	return c.SendString("List all Todo")
})

// GET http://localhost:3000/api/v1/todos/1

todo.Get("/:id", func(c *fiber.Ctx) error {
	id := c.Params("id")

	fmt.Printf("ID: %v", id) // ID: 1

	return c.SendString("Get Todo by Id")
})

// GET http://localhost:3000/api/v1/todos/123

todo.Patch("/:id", func(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id") // int 123 and no error

	// ...
})

// GET http://localhost:3000/api/v1/todos/1

todo.Delete("/:id", func(c *fiber.Ctx) error {
	param := struct {
		ID uint `params:"id"`
	}{}

	c.ParamsParser(&param) // "{"id": 111}"

	return c.SendString("Delete Todo by Id")
})

app.Get("/", func(c *fiber.Ctx) error {
  c.Set("X-Request-Id", "12345")
  // => "X-Request-Id: 12345

  // ...
})

app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("Hello, World!")
  // => "Hello, World!"
})

app.Get("/not-found", func(c *fiber.Ctx) error {
  return c.SendFile("./public/404.html");

  // Disable compression
  return c.SendFile("./public/index.html", false);
})

todo.Post("/", func(c *fiber.Ctx) error {
	todoForm := struct {
		Text string `json:"text"`
	}{}
	c.BodyParser(&todoForm) // "{"Text":"do something"}"

	return c.JSON(todoForm)
})

todo.Post("/", func(c *fiber.Ctx) error {
	newTodo := struct {
		Text string `json:"text"`
	}{}
	c.BodyParser(&newTodo) // "{"Text":"do something"}"

	return c.Status(201).JSON(newTodo)
})

todo.Delete("/:id", func(c *fiber.Ctx) error {
	// ...

	return c.SendStatus(204)
})

// หรือใช้ทำ health check
app.Get("/healthz", func(c *fiber.Ctx) error {
  return c.SendStatus(200)
})

// http://localhost:3000/api/v1/todos/123abc

todo.Get("/:id", func(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id") // 1
	if err != nil {
		return err
	}

	return c.SendString(fmt.Sprintf("Get Todo by Id: %v", id))
})

// 500 strconv.Atoi: parsing "123abc": invalid syntax

// http://localhost:3000/api/v1/todos/123abc

todo.Get("/:id", func(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id") // 1
	if err != nil {
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}

	return c.SendString(fmt.Sprintf("Get Todo by Id: %v", id))
})

// 400 strconv.Atoi: parsing "123abc": invalid syntax

// http://localhost:3000/api/v1/todos/123abc

todo.Get("/:id", func(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id") // 1
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	return c.SendString(fmt.Sprintf("Get Todo by Id: %v", id))
})

//{
//  "message": "strconv.Atoi: parsing \"123abc\": invalid syntax"
//}

package handlers

import "github.com/uptrace/bun"

type todoHandler struct {
	db *bun.DB
}

func NewTodoHandler(db *bun.DB) *todoHandler {
	return &todoHandler{db}
}

func (h todoHandler) CreateTodo(c *fiber.Ctx) error {
	todoForm := struct {
		Text string `json:"text"`
	}{}
	c.BodyParser(&todoForm) // "{"Text":"do something"}"

	return c.Status(201).JSON(todoForm)
}

func (h todoHandler) ListTodo(c *fiber.Ctx) error {
	filter := struct {
		// เป็น pointer เพื่อไม่ส่งค่ามาจะให้เป็น nil เพื่อแสดงข้อมูลทั้งหมด
		Completed *bool `query:"completed"`
	}{}
	c.QueryParser(&filter) // "{"Completed":<nil>}"

	return c.SendString("List all Todo")
}

func (h todoHandler) GetTodo(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id") // 1
	if err != nil {
		// return err
		return fiber.NewError(fiber.StatusBadRequest, err.Error())
	}

	return c.SendString(fmt.Sprintf("Get Todo by Id: %v", id))
}

func (h todoHandler) UpdateTodoStatus(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id") // 1
	if err != nil {
		return err
	}
	fmt.Printf("ID: %v", id)

	todoForm := struct {
		Completed bool `json:"completed"`
	}{}
	c.BodyParser(&todoForm) // "{"Completed":true}"

	return c.JSON(todoForm)
}

func (h todoHandler) DeleteTodo(c *fiber.Ctx) error {
	param := struct {
		ID uint `params:"id"`
	}{}

	c.ParamsParser(&param) // "{"id": 111}"

	return c.SendStatus(204)
}

package handlers

import (
	"github.com/gofiber/fiber/v2"
	"github.com/uptrace/bun"
)

func RegisterRoutes(app *fiber.App, db *bun.DB) {
	app.Get("/healthz", func(c *fiber.Ctx) error {
		return c.SendStatus(200)
	})

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

	todoH := NewTodoHandler(db)
	todo := v1.Group("/todos")  // /api/v1/todos
	todo.Post("/", todoH.CreateTodo)
	todo.Get("/", todoH.ListTodo)
	todo.Get("/:id", todoH.GetTodo)
	todo.Patch("/:id", todoH.UpdateTodoStatus)
	todo.Delete("/:id", todoH.DeleteTodo)
}

func main() {
	// ...

	app := fiber.New()

	handlers.RegisterRoutes(app, db)

	app.Listen(fmt.Sprintf(":%v", cfg.Port))
}

func (h todoHandler) CreateTodo(c *fiber.Ctx) error {
	todoForm := struct {
		Text string `json:"text"`
	}{}
	err := c.BodyParser(&todoForm)
	// 1. validate request body
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	if len(todoForm.Text) == 0 {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message":"text is required",
		})
	}

	// 2. insert to database
	// TODO: insert to database
	todo := models.Todo{Title: todoForm.Text}
	err = nil
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 3. response result
	return c.Status(201).JSON(todo)
}

func (h todoHandler) ListTodo(c *fiber.Ctx) error {
	filter := struct {
		// เป็น pointer เพื่อไม่ส่งค่ามาจะให้เป็น nil เพื่อแสดงข้อมูลทั้งหมด
		Completed *bool `query:"completed"`
	}{}
	err := c.QueryParser(&filter)

	// 1. validate request body
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 2. select from database
	// TODO: select from database
	todos, err := []models.Todo{}, nil
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 3. response result
	return c.JSON(todos)
}

func (h todoHandler) GetTodo(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id")
	// 1. validate request body
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 2. select from database by id
	// TODO: select from database by id
	todo, err := models.Todo{ID: id}, nil
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 3. response result
	return c.JSON(todo)
}

func (h todoHandler) UpdateTodoStatus(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id")
	// 1. validate request body
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}
	todoForm := struct {
		Completed bool `json:"completed"`
	}{}
	err = c.BodyParser(&todoForm)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 2. update to database by id
	// TODO: update to database by id
	todo, err := models.Todo{ID: id, IsDone: updateTodo.Completed}, nil
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 3. response result
	return c.JSON(todo)
}

func (h todoHandler) DeleteTodo(c *fiber.Ctx) error {
	id, err := c.ParamsInt("id")
	// 1. validate request body
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 2. delete from to database by id
	// TODO: delete from database by id
	fmt.Println(id)
	err = nil
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// 3. response result
	return c.SendStatus(204)
}

func (h todoHandler) CreateTodo(c *fiber.Ctx) error {
	// ...

	// 2. insert to database
	todo := models.Todo{Title: todoForm.Text}
	_, err = h.db.NewInsert().Model(&todo).Exec(c.UserContext())
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// ...
}

func (h todoHandler) ListTodo(c *fiber.Ctx) error {
	// ...

	// 2. select from database
	todos := []models.Todo{}
	q := h.db.NewSelect().Model(&todos)
	if filter.Completed != nil {
		q.Where("is_done = ?", *filter.Completed)
	}
	err = q.Scan(c.UserContext())
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// ...
}

func (h todoHandler) GetTodo(c *fiber.Ctx) error {
	// ..

	// 2. select from database by id
	todo := models.Todo{ID: id}
	err = h.db.NewSelect().Model(&todo).WherePK().Scan(c.UserContext())
	if err != nil {
		if err.Error() == sql.ErrNoRows.Error() {
			return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
				"message": "todo with given id not found",
			})
		}
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// ..
}

func (h todoHandler) UpdateTodoStatus(c *fiber.Ctx) error {
	// ...

	// 2. update to database by id
	todo := models.Todo{ID: id, IsDone: updateTodo.Completed}
	res, err := h.db.NewUpdate().
		Model(&todo).
		Column("is_done").
    SetColumn("updated_at", "DEFAULT").
		WherePK().
		Returning("*").
		Exec(c.UserContext())
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}
	rows, _ := res.RowsAffected()
	if rows == 0 {
		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
				"message": "todo with given id not found",
			})
	}

	// ...
}

func (h todoHandler) DeleteTodo(c *fiber.Ctx) error {
	// ...

	// 2. delete from to database by id
	res, err := h.db.NewDelete().
		Model((*models.Todo)(nil)).
		Where("id = ?", id).
		Exec(c.UserContext())
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}
	rows, _ := res.RowsAffected()
	if rows == 0 {
		return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
			"message": "todo with given id not found",
		})
	}

	// ...
}

package dtos

type CreateTodoForm struct {
	Text string `json:"text"`
}

type UpdateTodoForm struct {
	Completed bool `json:"completed"`
}

func (h todoHandler) CreateTodo(c *fiber.Ctx) error {
	todoForm := dtos.CreateTodoForm{}
	err := c.BodyParser(&todoForm)
	// 1. validate request body
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

  // ...
}

func (h todoHandler) UpdateTodoStatus(c *fiber.Ctx) error {
	// ...

	updateTodo := dtos.UpdateTodoForm{}
	err = c.BodyParser(&updateTodo)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

	// ...
}

package dtos

type CreateTodoForm struct {
	Text string `json:"text" validate:"required"`
}

type UpdateTodoForm struct {
	Completed bool `json:"completed" validate:"required"`
}

package validator

import "github.com/go-playground/validator/v10"

// use a single instance , it caches struct info
var validate *validator.Validate

func init() {
	validate = validator.New()
}

type ErrorResponse struct {
	FailedField string `json:"failed_field"`
	Tag         string `json:"tag"`
	Value       string `json:"value"`
}

func ValidateStruct(s interface{}) []*ErrorResponse {
	var errors []*ErrorResponse
	err := validate.Struct(s)
	if err != nil {
		for _, err := range err.(validator.ValidationErrors) {
			var element ErrorResponse
			element.FailedField = err.StructNamespace()
			element.Tag = err.Tag()
			element.Value = err.Param()
			errors = append(errors, &element)
		}
	}
	return errors
}

func (h todoHandler) CreateTodo(c *fiber.Ctx) error {
	// ...

	// if len(todoForm.Text) == 0 {
	// 	return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
	//		"message":"text is required",
	//	})
	// }

	errors := validator.ValidateStruct(&todoForm)
	if errors != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
			"message": "invalidate JSON",
			"errors":  errors,
		})
	}

	// ...
}

{
  "ID": 1,
  "Title": "do something",
  "IsDone": false,
  "CreatedAt": "2022-09-15T09:40:12.981316Z",
  "UpdatedAt": "2022-09-15T09:40:12.981316Z"
}

{
  "id": 1,
  "text": "do something",
  "completed": false
}

package models

import "time"

type Todo struct {
	ID     int    `json:"id" bun:"id,pk,autoincrement"`
	Title  string `json:"text" bun:"title,nullzero,notnull"`
	IsDone bool   `json:"completed" bun:"is_done,notnull,default:false"`

	CreatedAt time.Time `json:"-" bun:",nullzero,notnull,default:current_timestamp"`
	UpdatedAt time.Time `json:"-" bun:",nullzero,notnull,default:current_timestamp"`
}

type TodoResponse struct {
	ID        int    `json:"id"`
	Text      string `json:"text"`
	Completed bool   `json:"completed"`
}

func (h todoHandler) GetTodo(c *fiber.Ctx) error {
	// ..

	// 2. select from database by id
	// ...

  serialized := dtos.TodoResponse{
		ID:        todo.ID,
		Text:      todo.Title,
		Completed: todo.IsDone,
	}

	// 3. response result
	return c.JSON(serialized)
}

package mapper

import (
	"goapi/pkg/dtos"
	"goapi/pkg/models"
)

func CreateTodoFormToModel(dto dtos.NewTodoForm) *models.Todo {
	return &models.Todo{
		Title: dto.Text,
	}
}

func TodoToDto(m *models.Todo) *dtos.TodoResponse {
	return &dtos.TodoResponse{
		ID:        m.ID,
		Text:      m.Title,
		Completed: m.IsDone,
	}
}

func TodosToDto(todos []*models.Todo) []*dtos.TodoResponse {
	dtos := make([]*dtos.TodoResponse, len(todos))
	for i, t := range todos {
		dtos[i] = TodoToDto(t)
	}

	return dtos
}

func (h todoHandler) CreateTodo(c *fiber.Ctx) error {
	// ...

	// 2. insert to database
- todo := models.Todo{Title: todoForm.Text}
+	todo := mapper.CreateTodoFormToModel(&todoForm)
	_, err = h.db.NewInsert().Model(todo).Exec(c.UserContext())
	if err != nil {
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
			"message": err.Error(),
		})
	}

+	serialized := mapper.TodoToDto(todo)

	// 3. response result
- return c.Status(201).JSON(todo)
+	return c.Status(201).JSON(serialized)
}

import (
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/fiber/v2/middleware/cors"
)

// Default config
app.Use(cors.New())

// Or extend your config for customization
app.Use(cors.New(cors.Config{
    AllowOrigins: "https://gofiber.io, https://gofiber.net",
    AllowHeaders:  "Origin, Content-Type, Accept",
}))

import (
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/fiber/v2/middleware/requestid"
)

// Default middleware config
app.Use(requestid.New())

// Or extend your config for customization
app.Use(requestid.New(requestid.Config{
    Header:    "X-Custom-Header",
    Generator: func() string {
        return "static-id"
    },
}))

import (
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/logger"
)

// Default middleware config
app.Use(logger.New())

// ใช้ร่วมกับ Request ID
app.Use(requestid.New())

app.Use(logger.New(logger.Config{
    // For more options, see the Config section
  Format: "${pid} ${locals:requestid} ${status} - ${method} ${path}\n",
}))

import (
  "github.com/gofiber/fiber/v2"
  "github.com/gofiber/fiber/v2/middleware/recover"
)

// Default middleware config
app.Use(recover.New())

// This panic will be catch by the middleware
app.Get("/", func(c *fiber.Ctx) error {
    panic("I'm an error")
})

func main() {
	// ...

	app := fiber.New()

	// use middlewere
	app.Use(cors.New())
	app.Use(requestid.New())
	app.Use(recover.New())
	app.Use(logger.New())

	handlers.RegisterRoutes(app, db)

	app.Listen(fmt.Sprintf(":%v", cfg.Port))
}

func MyMiddleware(c *fiber.Ctx}) error {
	c.Next()
}

package middlewares

import (
	"goapi/pkg/common/logger"
	"os"
	"time"

	"github.com/gofiber/fiber/v2"
)

func Logger(c *fiber.Ctx) error {
	start := time.Now()

	appName := os.Getenv("APP_NAME")

	if len(appName) == 0 {
		appName = "goapi"
	}

	fileds := map[string]interface{}{
		"app":       appName,
		"domain":    c.Hostname(),
		"requestId": c.GetRespHeader("X-Request-ID"),
		"userAgent": c.Get("User-Agent"),
		"ip":        c.IP(),
		"method":    c.Method(),
		"uri":       c.Path(),
	}

	log := logger.WithFields(fileds)

	c.Locals("log", log) // ส่งต่อ log ที่มี fileds ข้างบนไปให้ handler ใช้งาน

	err := c.Next()

	fileds["status"] = c.Response().StatusCode()
	fileds["latency"] = time.Since(start)

	logger.Info("access log", logger.ToFields(fileds)...)

	return err
}

func main() {
	// ...

	app := fiber.New()

	// use middlewere
	app.Use(cors.New())
	app.Use(requestid.New())
	app.Use(recover.New())
-	app.Use(logger.New())
+ app.Use(middlewares.Logger)

	handlers.RegisterRoutes(app, db)

	app.Listen(fmt.Sprintf(":%v", cfg.Port))
}

FROM golang:1.19-buster AS build
WORKDIR /app
COPY go.mod ./
COPY go.sum ./
RUN go mod download
COPY cmd ./cmd
COPY pkg ./pkg
ENV GOARCH=amd64
RUN go build -o /go/bin/app cmd/main.go

# Deploy
FROM gcr.io/distroless/base-debian11
COPY --from=build /go/bin/app /app
EXPOSE 3000
USER nonroot:nonroot
CMD ["/app"]

version: '3.8'
services:
  db:
    image: postgres:14-alpine
    container_name: todo-db
    restart: always
    environment:
      - TZ=Asia/Bangkok
      - PGTZ=Asia/Bangkok
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=mysecretpassword
      - POSTGRES_DB=todo-db
    volumes:
      - pg_data:/var/lib/postgresql/data
    logging:
      options:
        max-size: 10m
        max-file: '3'
    healthcheck:
      test: pg_isready -U postgres -h 127.0.0.1
      interval: 10s
      timeout: 5s
      retries: 5

  migrate:
    image: migrate/migrate
    volumes:
      - ./migrations:/migrations
    command: -verbose -path=/migrations/ -database postgres://postgres:mysecretpassword@db:5432/todo-db?sslmode=disable up
    depends_on:
      db:
        condition: service_healthy

  api:
    build: .
    image: todo-api:1.0.0
    container_name: todo-api
    restart: always
    ports:
      - 3000:3000
    environment:
      - TZ=Asia/Bangkok
      - APP_MODE=production
      - DSN=postgres://postgres:mysecretpassword@db:5432/todo-db?sslmode=disable
    depends_on:
      db:
        condition: service_healthy
      migrate:
        condition: service_completed_successfully

volumes:
  pg_data: