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

package main

import (
	"log"
	"net/http"
)

func main() {
	// starting server
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func main() {
  // define route
	http.HandleFunc("/greet", func(w http.ResponseWriter, r *http.Request) {
	  fmt.Fprint(w, "Hello world")
  }

	// starting server
  log.Fatal(http.ListenAndServe(":8080", nil))
}

func main() {
  // define route
	http.HandleFunc("/greet", greet)

	// starting server
  log.Fatal(http.ListenAndServe(":8080", nil))
}

func greet(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello world")
}

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type Test struct {
	Name string
}

func main() {
	// define route
	http.HandleFunc("/tests", handleTest)

	// starting server
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleTest(w http.ResponseWriter, r *http.Request) {
	tests := []Test{
		{Name: "Test 1"},
		{Name: "Test 2"},
		{Name: "Test 3"},
	}

	json.NewEncoder(w).Encode(tests)
}

func handleTest(w http.ResponseWriter, r *http.Request) {
	tests := []Test{
		{Name: "Test 1"},
		{Name: "Test 2"},
    {Name: "Test 3"},
	}

  w.Header().Add("Content-Type", "application/json")
	json.NewEncoder(w).Encode(tests)
}

func handleTest(w http.ResponseWriter, r *http.Request) {
	tests := []Test{
		{Name: "Test 1"},
		{Name: "Test 2"},
    {Name: "Test 3"},
	}

  if r.Header.Get("Accept") == "application/xml" {
		w.Header().Add("Content-Type", "application/xml")
		xml.NewEncoder(w).Encode(tests)
	} else {
		w.Header().Add("Content-Type", "application/json")
		json.NewEncoder(w).Encode(tests)
	}
}

func main() {
  mux := http.NewServeMux()
	// define route
	mux.HandleFunc("/tests", handleTest)

	// starting server
	log.Fatal(http.ListenAndServe(":8080", mux))
}

go get -u [github.com/gorilla/mux](http://github.com/gorilla/mux)

import (
  "log"
  "net/http"
  "github.com/gorilla/mux"
)

func main() {
  // เปลี่ยนตรงนี้
  r := mux.NewRouter()
  // define route
	r.HandleFunc("/tests", handleTest)

	// starting server
  log.Fatal(http.ListenAndServe(":8080", r))
}

func handleTest(w http.ResponseWriter, r *http.Request) {
	query := r.URL.Query()
	w.Header().Add("Content-Type", "application/json")
	json.NewEncoder(w).Encode(query)
}

// http://localhost:8080/tests?name=abc&completed=true
// {
// 	"completed": [
// 		"true"
// 	],
// 	"name": [
// 		"abc"
// 	]
// }

func main() {
	// เปลี่ยนตรงนี้
	r := mux.NewRouter()
	// สามารถใช้ร่วมกับ regx ได้
	r.HandleFunc("/tests/{id:[0-9]+}", func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)
		fmt.Fprint(w, vars["id"])
	})

	// starting server
	log.Fatal(http.ListenAndServe(":8080", r))
}

package main

import (
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
)

func main() {
	// เปลี่ยนตรงนี้
	r := mux.NewRouter()
	// define route for crud
	r.HandleFunc("/tests", createTest).Methods(http.MethodPost)
  r.HandleFunc("/tests", listTest).Methods(http.MethodGet)
  // สามารถใช้ร่วมกับ regx ได้
  r.HandleFunc("/tests/{id:[0-9]+}", getTest).Methods(http.MethodGet)
  r.HandleFunc("/tests/{id:[0-9]+}", updateTest).Methods(http.MethodPut)
  r.HandleFunc("/tests/{id:[0-9]+}", deleteTest).Methods(http.MethodDelete)

	// starting server
	log.Fatal(http.ListenAndServe(":8080", r))
}

mkdir -p pkg/handlers
cd pkg/handlers
touch todo.go

package handlers

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

func CreateTodo(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Create Todo")
}

func ListTodo(w http.ResponseWriter, r *http.Request) {
  todos := []Todo{
		{ID: 1, Text: "Test 1", Completed: true},
		{ID: 2, Text: "Test 2", Completed: false},
		{ID: 3, Text: "Test 3", Completed: false},
	}
  // ส่งข้อมูลทั้งหมดกลับไปในรูปแบบ JSON
	w.Header().Add("Content-Type", "application/json")
	json.NewEncoder(w).Encode(todos)
}

func GetTodo(w http.ResponseWriter, r *http.Request) {
  vars := mux.Vars(r)
	fmt.Fprint(w, "Get Todo by ID:", vars["id"])
}

func UpdateTodoStatus(w http.ResponseWriter, r *http.Request) {
  vars := mux.Vars(r)
	fmt.Fprint(w, "Update Todo Status by ID:", vars["id"])
}

func DeleteTodo(w http.ResponseWriter, r *http.Request) {
  vars := mux.Vars(r)
	fmt.Fprint(w, "Delete Todo by ID:", vars["id"])
}

package main

import (
	"goapi/pkg/handlers"
	"log"
	"net/http"

	"github.com/gorilla/mux"
)

type Test struct {
	Name string
}

func main() {
	// เปลี่ยนตรงนี้
	r := mux.NewRouter()
	// define route
	setupRouter(r)

	// starting server
	log.Fatal(http.ListenAndServe(":8080", r))
}

func setupRouter(r *mux.Router) {
	r.HandleFunc("/api/todos", handlers.CreateTodo).Methods(http.MethodPost)
	r.HandleFunc("/api/todos", handlers.ListTodo).Methods(http.MethodGet)
	// สามารถใช้ร่วมกับ regx ได้
	r.HandleFunc("/api/todos/{id:[0-9]+}", handlers.GetTodo).Methods(http.MethodGet)
	r.HandleFunc("/api/todos/{id:[0-9]+}", handlers.UpdateTodoStatus).Methods(http.MethodPut)
	r.HandleFunc("/api/todos/{id:[0-9]+}", handlers.DeleteTodo).Methods(http.MethodDelete)
}

func setupRouter(r *mux.Router) {
	todo := r.PathPrefix("/api/todos").Subrouter()
	todo.HandleFunc("", handlers.CreateTodo).Methods(http.MethodPost)
	todo.HandleFunc("", handlers.ListTodo).Methods(http.MethodGet)
	// สามารถใช้ร่วมกับ regx ได้
	todo.HandleFunc("/{id:[0-9]+}", handlers.GetTodo).Methods(http.MethodGet)
	todo.HandleFunc("/{id:[0-9]+}", handlers.UpdateTodoStatus).Methods(http.MethodPut)
	todo.HandleFunc("/{id:[0-9]+}", handlers.DeleteTodo).Methods(http.MethodDelete)
}

go get -u gorm.io/gorm
go get -u gorm.io/driver/postgres

package database

import (
	"log"

	"gorm.io/driver/postgres"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

const (
	// TODO fill this in directly or through environment variable
	// Build a DSN e.g. postgres://username:password@host:port/dbName
	// or "host=localhost user=gorm password=gorm dbname=gorm port=5432 sslmode=disable TimeZone=Asia/Bangkok"
	DB_DSN = "postgres://fcricryh:F5a7wATfocTUNww1Dm14AfebtPaysqIn@john.db.elephantsql.com/fcricryh"
)

var DB *gorm.DB

func ConnectDB() {
	var err error
	DB, err = gorm.Open(postgres.Open(DB_DSN), &gorm.Config{
		Logger: logger.Default.LogMode(logger.Info),
	})

	if err != nil {
		log.Fatal("Cannot open DB connection", err)
	}

	log.Println("DB Connected")
}

func main() {
  // เรียกก่อนเริ่มเปิด server เพราะถ้าเชื่อมต่อไม่ได้ให้จะได้ไม่ต้อง start server
	database.ConnectDB()


	r := mux.NewRouter()
	// define route
	setupRouter(r)

	// starting server
	log.Fatal(http.ListenAndServe(":8080", r))
}

type Todo struct {
	ID        int    `json:"id"`
	Text      string `json:"text" gorm:"column:title"`
	Completed bool   `json:"isCompleted" gorm:"column:is_done"`
}

func CreateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: แปลง JSON จาก request body เป็น Todo struct
	var todo Todo

	err := json.NewDecoder(r.Body).Decode(&todo)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

}

func CreateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: แปลง JSON จาก request body เป็น Todo struct
	// step 2: validate
  if todo.Title == "" {
    http.Error(w, "text is required", http.StatusBadRequest)
		return
  }
}

package validator

import (
	"errors"
	"strings"

	"github.com/go-playground/locales/en"
	ut "github.com/go-playground/universal-translator"
	"github.com/go-playground/validator/v10"
	en_translations "github.com/go-playground/validator/v10/translations/en"
)

// use a single instance , it caches struct info
var (
	uni      *ut.UniversalTranslator
	validate *validator.Validate
	trans    ut.Translator
)

func init() {
	en := en.New()
	uni = ut.New(en, en)
	// this is usually know or extracted from http 'Accept-Language' header
	// also see uni.FindTranslator(...)
	trans, _ = uni.GetTranslator("en")
	validate = validator.New()
	en_translations.RegisterDefaultTranslations(validate, trans)
}

func ValidateStruct(s interface{}) error {
	err := validate.Struct(s)
	if err != nil {
		return errors.New(errToMessage(err))
	}
	return nil
}

func errToMessage(err error) (message string) {
	// translate all error at once
	errs := err.(validator.ValidationErrors)
	fields := removeTopStruct(errs.Translate(trans))
	for k, v := range fields {
		message += ", " + k + ": " + v
	}
	return message[2:]
}

func removeTopStruct(fields map[string]string) map[string]string {
	res := map[string]string{}
	for field, err := range fields {
		res[strings.ToUpper(strings.ReplaceAll(field[strings.Index(field, ".")+1:], ".", "_"))] = err
	}
	return res
}

type Todo struct {
	ID        int    `json:"id"`
	Text      string `json:"text" gorm:"column:title" validate:"required" `
	Completed bool   `json:"isCompleted" gorm:"column:is_done"`
}

func CreateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: แปลง JSON จาก request body เป็น Todo struct
	// step 2: validate
  err = validator.ValidateStruct(todo)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
}

func CreateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: แปลง JSON จาก request body เป็น Todo struct
	// step 2: validate
  // step 3: insert
  tx := database.DB.Create(&todo)
  if err := tx.Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func CreateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: แปลง JSON จาก request body เป็น Todo struct
	// step 2: validate
  // step 3: insert
  // step 4: response
  w.Header().Add("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(todo)
}

func ListTodo(w http.ResponseWriter, r *http.Request) {
  // step 1: query all todos from database
	todos := []Todo{}

	tx := database.DB.Find(&todos)

	if err := tx.Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func ListTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: query all todos from database
  // step 2: response
	w.Header().Add("Content-Type", "application/json")
	json.NewEncoder(w).Encode(todos)
}

func ListTodo(w http.ResponseWriter, r *http.Request) {
  // เพิ่มอ่านค่าจาก query params
  query := r.URL.Query()
  wheres := map[string]interface{}{}
  // ถ้าส่ง completed มา ให้ใส่ไปใน map["is_done"] ตามชื่อ column จริงในฐานข้อมูล
	if val, ok := query["completed"]; ok {
		b1, err := strconv.ParseBool(val[0])
		if err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		wheres["is_done"] = b1
	}

  todos := []Todo{}
  // เพิ่ม .Where()
	tx := database.DB.Where(wheres).Find(&todos)

	if err := tx.Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Add("Content-Type", "application/json")
	json.NewEncoder(w).Encode(todos)
}

func GetTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  vars := mux.Vars(r)
	id, _ := strconv.Atoi(vars["id"])
}

func GetTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: select where id
	todo := Todo{}
	tx := database.DB.First(&todo, id)
	if err := tx.Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func GetTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: select where id
  todo := Todo{}
	tx := database.DB.First(&todo, id)
	if err := tx.Error; err != nil {
    // step 3: handle error not found
    if errors.Is(err, gorm.ErrRecordNotFound) {
      http.Error(w, "todo with given id not found", http.StatusNotFound)
		  return
    }
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func GetTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: select where id
  // step 3: handle error not found
  // step 4: response
  w.Header().Add("Content-Type", "application/json")
	json.NewEncoder(w).Encode(todo)
}

func UpdateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  vars := mux.Vars(r)
	id, _ := strconv.Atoi(vars["id"])
}

func UpdateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: แปลง json body เป็น struct เพื่อเอาค่าสถานะที่ส่งมา
  var todo Todo
	err := json.NewDecoder(r.Body).Decode(&todo)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
}

func UpdateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: แปลง json body เป็น struct เพื่อเอาค่าสถานะที่ส่งมา
  // step 3: update only is_done column
  tx := database.DB.Model(Todo{ID: id}).Update("is_done", todo.Completed)
	if err := tx.Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func UpdateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: แปลง json body เป็น struct เพื่อเอาค่าสถานะที่ส่งมา
  // step 3: update only is_done column
  // step 4: handle not found error
  if tx.RowsAffected == 0 {
		http.Error(w, "todo with given id not found", http.StatusNotFound)
		return
	}
}

func UpdateTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: แปลง json body เป็น struct เพื่อเอาค่าสถานะที่ส่งมา
  // step 3: update only is_done column
  // step 4: handle not found error
  // step 5: response
  w.WriteHeader(http.StatusNoContent)
}

func DeleteTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  vars := mux.Vars(r)
	id, _ := strconv.Atoi(vars["id"])
}

func DeleteTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: delete where id
  tx := database.DB.Delete(&Todo{}, id)
	if err := tx.Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func DeleteTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: delete where id
  // step 3: handle not found error
  if tx.RowsAffected <= 0 {
		http.Error(w, "todo with given id not found", http.StatusNotFound)
		return
	}
}

func DeleteTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
  // step 2: delete where id
  // step 3: handle not found error
  // step 4: response
  w.WriteHeader(http.StatusNoContent)
}

func sendJson(w http.ResponseWriter, code int, data interface{}) {
	w.Header().Add("Content-Type", "application/json")
	w.WriteHeader(code)
	json.NewEncoder(w).Encode(data)
}

func GetTodo(w http.ResponseWriter, r *http.Request) {
	// ...
	// step 4: response
	sendJson(w, http.StatusOK, todo)
}

type todoHandler struct {
	db       *gorm.DB
}

func NewTodoHandler(db *gorm.DB, validate *validator.Validate) *todoHandler {
	return &todoHandler{
		db:       db,
		validate: validate,
	}
}

func (h todoHandler) CreateTodo(w http.ResponseWriter, r *http.Request) {
  // ...
	tx := h.db.Create(&todo)
  // ...
}

func (h todoHandler) ListTodo(w http.ResponseWriter, r *http.Request) {
  // ...
	tx := h.db.Where(wheres).Find(&todos)
  // ...
}

func (h todoHandler) GetTodo(w http.ResponseWriter, r *http.Request) {
  // ...
	tx := h.db.First(&todo, id)
  // ...
}

func (h todoHandler) UpdateTodo(w http.ResponseWriter, r *http.Request) {
	// ...
	tx := h.db.Model(Todo{ID: uint(id)}).Update("is_done", todo.Completed)
  // ...
}

func (h todoHandler) DeleteTodo(w http.ResponseWriter, r *http.Request) {
  // ...
	tx := h.db.Delete(&Todo{}, id)
  // ...
}

func main() {
  // ...
}

func setupRouter(r *mux.Router) {
	todo := r.PathPrefix("/api/todos").Subrouter()
	todoHandler := handlers.NewTodoHandler(database.DB)
	todo.HandleFunc("", todoHandler.CreateTodo).Methods(http.MethodPost)
	todo.HandleFunc("", todoHandler.ListTodo).Methods(http.MethodGet)
	// สามารถใช้ร่วมกับ regx ได้
	todo.HandleFunc("/{id:[0-9]+}", todoHandler.GetTodo).Methods(http.MethodGet)
	todo.HandleFunc("/{id:[0-9]+}", todoHandler.UpdateTodo).Methods(http.MethodPut)
	todo.HandleFunc("/{id:[0-9]+}", todoHandler.DeleteTodo).Methods(http.MethodDelete)
}

package errs

import "net/http"

type AppError struct {
	Code    int    `json:"-"`
	Message string `json:"error"`
}

func (e AppError) Error() string {
	return e.Message
}

func NewBadRequestError(message string) error {
	return AppError{
		Code:    http.StatusBadRequest,
		Message: message,
	}
}

func NewNotFoundError(message string) error {
	return AppError{
		Code:    http.StatusNotFound,
		Message: message,
	}
}

func NewUnexpectedError(message string) error {
	return AppError{
		Code:    http.StatusInternalServerError,
		Message: message,
	}
}

func handleError(w http.ResponseWriter, err error) {
	switch e := err.(type) {
	case errs.AppError:
		sendJson(w, e.Code, e)
	case error:
		appErr := errs.AppError{
			Code:    http.StatusInternalServerError,
			Message: e.Error(),
		}
		sendJson(w, appErr.Code, appErr)
	}
}

func (h todoHandler) GetTodo(w http.ResponseWriter, r *http.Request) {
	// step 1: get id from path param
	vars := mux.Vars(r)
	id, _ := strconv.Atoi(vars["id"])
	// step 2: select where id
	todo := Todo{}
	tx := h.db.First(&todo, id)
	if err := tx.Error; err != nil {
		// step 3: handle error not found
		if errors.Is(err, gorm.ErrRecordNotFound) {
			handleError(w, errs.NewNotFoundError("todo with given id not found"))
			return
		}
		handleError(w, errs.NewUnexpectedError(err.Error()))
		return
	}
	// step 4: response
	sendJson(w, http.StatusOK, todo)
}

package middleware

import (
	"log"
	"net/http"
	"time"
)

func Logging(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		start := time.Now()
		next.ServeHTTP(w, req)
		log.Printf("%s %s %s", req.Method, req.RequestURI, time.Since(start))
	})
}

type authenticationMiddleware struct {
	tokenUsers map[string]string
}

func NewAuthenticationMiddleware() *authenticationMiddleware {
	m := map[string]string{}
	m["1111"] = "user1"
	m["2222"] = "user2"

	return &authenticationMiddleware{
		tokenUsers: m,
	}
}

// Middleware function, which will be called for each request
func (amw *authenticationMiddleware) Middleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		token := r.Header.Get("x-token")

		if user, found := amw.tokenUsers[token]; found {
			// We found the token in our map
			log.Printf("Authenticated user %s\n", user)
			// Pass down the request to the next middleware (or final handler)
			next.ServeHTTP(w, r)
		} else {
			// Write an error and stop the handler chain
			http.Error(w, "Forbidden", http.StatusForbidden)
		}
	})
}

func setupRouter(r *mux.Router) {
	todo := r.PathPrefix("/api/todos").Subrouter()
  todoHandler := handlers.NewTodoHandler(database.DB, validate)
	todo.HandleFunc("", todoHandler.CreateTodo).Methods(http.MethodPost)
	todo.HandleFunc("", todoHandler.ListTodo).Methods(http.MethodGet)
	// สามารถใช้ร่วมกับ regx ได้
	todo.HandleFunc("/{id:[0-9]+}", todoHandler.GetTodo).Methods(http.MethodGet)
	todo.HandleFunc("/{id:[0-9]+}", todoHandler.UpdateTodo).Methods(http.MethodPut)
	todo.HandleFunc("/{id:[0-9]+}", todoHandler.DeleteTodo).Methods(http.MethodDelete)

	// Set up middleware.
	amw := middleware.NewAuthenticationMiddleware()
	r.Use(amw.Middleware)
	r.Use(middleware.Logging)
}

// request -> logging -> authen -> router

func setupRouter(r *mux.Router) {
	todo := r.PathPrefix("/api/todos").Subrouter()
	todo.HandleFunc("", handlers.CreateTodo).Methods(http.MethodPost)
	todo.HandleFunc("", handlers.ListTodo).Methods(http.MethodGet)
	// สามารถใช้ร่วมกับ regx ได้
	todo.HandleFunc("/{id:[0-9]+}", handlers.GetTodo).Methods(http.MethodGet)
	todo.HandleFunc("/{id:[0-9]+}", handlers.UpdateTodo).Methods(http.MethodPut)
	todo.HandleFunc("/{id:[0-9]+}", handlers.DeleteTodo).Methods(http.MethodDelete)

  r.HandleFunc("/public", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "This is public route")
	})
	// Set up middleware.
	amw := middleware.NewAuthenticationMiddleware()
	todo.Use(amw.Middleware)  // <-- เปลี่ยนจาก r เป็น todo แทน
	r.Use(middleware.Logging)
}

// request -> logging -> authen -> router

func main() {
	// ...
	// รับ handler กลับมา
	handler := setupRouter(r)

	// starting server
	log.Fatal(http.ListenAndServe(":8080", handler))
}

// เพิ่ม return http.Handler
func setupRouter(r *mux.Router) http.Handler {
	// ...

	r.Use(middleware.Logging)

	// Handling CORS Requests
	c := cors.New(cors.Options{
		AllowCredentials: true,
		AllowedMethods:   []string{"GET", "POST", "PATCH", "DELETE", "OPTIONS"},
	})

	handler := c.Handler(r)
	return handler
}

FROM golang:1.18-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 ls
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 8080
USER nonroot:nonroot
CMD ["/app"]

version: '2.4'
services:
  db:
    image: postgres:12-alpine
    container_name: todo-db
    restart: always
    environment:
      - TZ=Asia/Bangkok
      - PGTZ=Asia/Bangkok
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=S3cretp@ssw0rd
      - POSTGRES_DB=todos
    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

  api:
    image: todo-api:1.0.0
    container_name: todo-api
    restart: always
    ports:
      - 8080:8080
    environment:
      - TZ=Asia/Bangkok
      - DB_DRIVER=postgres
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USERNAME=postgres
      - DB_PASSWORD=S3cretp@ssw0rd
      - DB_DATABASE=todos
    depends_on:
      db:
        condition: service_healthy

volumes:
  pg_data: