สร้าง Go REST API ด้วย Gin และ GORM: โครงสร้างโปรเจกต์, Migration และ CRUD

articles-api/
├── main.go
├── .env.example
├── go.mod
├── config/
│   ├── config.go      # environment variables
│   └── database.go    # GORM connection
├── models/            # structs mapped to tables
├── migrations/        # versioned schema changes
├── seeds/             # demo and initial data
├── controllers/       # HTTP handlers
└── routes/            # route groups and wiring

go mod init example.com/articles-api
go get github.com/gin-gonic/gin gorm.io/gorm gorm.io/driver/postgres \
  github.com/joho/godotenv github.com/gin-contrib/cors \
  github.com/go-gormigrate/gormigrate/v2

# .env (never commit this; commit .env.example instead)
PORT=8080
DATABASE_URL=postgres://articles:secret@localhost:5432/articles?sslmode=disable
CORS_ORIGINS=http://localhost:3000

package config

import (
	"errors"
	"io/fs"
	"log"
	"os"
	"strings"

	"github.com/joho/godotenv"
)

type Config struct {
	Port        string
	DatabaseURL string
	CORSOrigins []string
}

func Load() Config {
	// .env is a development convenience. In production the variables
	// come from the container or platform, so a missing file is fine.
	if err := godotenv.Load(); err != nil && !errors.Is(err, fs.ErrNotExist) {
		log.Fatalf("load .env: %v", err)
	}

	cfg := Config{
		Port:        getEnv("PORT", "8080"),
		DatabaseURL: os.Getenv("DATABASE_URL"),
		CORSOrigins: strings.Split(getEnv("CORS_ORIGINS", "http://localhost:3000"), ","),
	}
	if cfg.DatabaseURL == "" {
		log.Fatal("DATABASE_URL is required")
	}
	return cfg
}

func getEnv(key, fallback string) string {
	if v := os.Getenv(key); v != "" {
		return v
	}
	return fallback
}

package config

import (
	"time"

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

func OpenDB(dsn string) (*gorm.DB, error) {
	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
		// Map unique and foreign key violations to gorm.ErrDuplicatedKey
		// and gorm.ErrForeignKeyViolated so handlers can return 409/422.
		TranslateError: true,
	})
	if err != nil {
		return nil, err
	}

	sqlDB, err := db.DB()
	if err != nil {
		return nil, err
	}
	sqlDB.SetMaxOpenConns(20)
	sqlDB.SetMaxIdleConns(10)
	sqlDB.SetConnMaxLifetime(30 * time.Minute)
	return db, nil
}

package models

import (
	"time"

	"gorm.io/gorm"
)

type Category struct {
	ID   uint   `gorm:"primaryKey" json:"id"`
	Name string `gorm:"size:100;uniqueIndex;not null" json:"name"`
}

type Article struct {
	ID         uint           `gorm:"primaryKey" json:"id"`
	Title      string         `gorm:"size:200;uniqueIndex;not null" json:"title"`
	Excerpt    string         `gorm:"size:500;not null" json:"excerpt"`
	Body       string         `gorm:"type:text;not null" json:"body"`
	Image      string         `gorm:"size:255" json:"image"`
	CategoryID uint           `gorm:"not null;index" json:"categoryId"`
	Category   *Category      `json:"category,omitempty"`
	CreatedAt  time.Time      `json:"createdAt"`
	UpdatedAt  time.Time      `json:"updatedAt"`
	DeletedAt  gorm.DeletedAt `gorm:"index" json:"-"`
}

package migrations

import (
	"time"

	"github.com/go-gormigrate/gormigrate/v2"
	"gorm.io/gorm"
)

func Run(db *gorm.DB) error {
	m := gormigrate.New(db, gormigrate.DefaultOptions, []*gormigrate.Migration{
		{
			ID: "202609240001_create_categories_and_articles",
			Migrate: func(tx *gorm.DB) error {
				// Snapshot structs: later edits to models/ must not
				// change what this migration does.
				type Category struct {
					ID   uint   `gorm:"primaryKey"`
					Name string `gorm:"size:100;uniqueIndex;not null"`
				}
				type Article struct {
					ID         uint   `gorm:"primaryKey"`
					Title      string `gorm:"size:200;uniqueIndex;not null"`
					Excerpt    string `gorm:"size:500;not null"`
					Body       string `gorm:"type:text;not null"`
					Image      string `gorm:"size:255"`
					CategoryID uint   `gorm:"not null;index"`
					Category   Category
					CreatedAt  time.Time
					UpdatedAt  time.Time
					DeletedAt  gorm.DeletedAt `gorm:"index"`
				}
				return tx.AutoMigrate(&Category{}, &Article{})
			},
			Rollback: func(tx *gorm.DB) error {
				return tx.Migrator().DropTable("articles", "categories")
			},
		},
	})
	return m.Migrate()
}

package seeds

import (
	"example.com/articles-api/models"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

func Run(db *gorm.DB) error {
	return db.Transaction(func(tx *gorm.DB) error {
		var goCat models.Category
		if err := tx.FirstOrCreate(&goCat, models.Category{Name: "Go"}).Error; err != nil {
			return err
		}

		articles := []models.Article{
			{Title: "Hello, Gin", Excerpt: "A first route.", Body: "...", CategoryID: goCat.ID},
		}
		// ON CONFLICT DO NOTHING skips titles that already exist.
		return tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&articles).Error
	})
}

package controllers

import (
	"errors"
	"net/http"
	"strconv"

	"example.com/articles-api/models"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

type ArticleHandler struct{ db *gorm.DB }

func NewArticleHandler(db *gorm.DB) *ArticleHandler { return &ArticleHandler{db: db} }

type articleRequest struct {
	Title      string `json:"title" binding:"required,max=200"`
	Excerpt    string `json:"excerpt" binding:"required,max=500"`
	Body       string `json:"body" binding:"required"`
	CategoryID uint   `json:"categoryId" binding:"required"`
}

func parseID(c *gin.Context) (uint64, bool) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid id"})
		return 0, false
	}
	return id, true
}

func (h *ArticleHandler) List(c *gin.Context) {
	var articles []models.Article
	err := h.db.WithContext(c.Request.Context()).
		Preload("Category").Order("created_at DESC").Limit(20).
		Find(&articles).Error
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "could not load articles"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"data": articles})
}

func (h *ArticleHandler) Create(c *gin.Context) {
	var req articleRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	article := models.Article{
		Title: req.Title, Excerpt: req.Excerpt, Body: req.Body, CategoryID: req.CategoryID,
	}
	err := h.db.WithContext(c.Request.Context()).Create(&article).Error
	switch {
	case errors.Is(err, gorm.ErrDuplicatedKey):
		c.JSON(http.StatusConflict, gin.H{"error": "an article with this title already exists"})
	case errors.Is(err, gorm.ErrForeignKeyViolated):
		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "category does not exist"})
	case err != nil:
		c.JSON(http.StatusInternalServerError, gin.H{"error": "could not create article"})
	default:
		c.JSON(http.StatusCreated, gin.H{"data": article})
	}
}

package routes

import (
	"net/http"

	"example.com/articles-api/controllers"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

func Register(r *gin.Engine, db *gorm.DB) {
	articles := controllers.NewArticleHandler(db)

	r.GET("/healthz", func(c *gin.Context) { c.Status(http.StatusOK) })

	api := r.Group("/api/v1")
	{
		a := api.Group("/articles")
		a.GET("", articles.List)
		a.GET("/:id", articles.Get)
		a.POST("", articles.Create)
		a.PUT("/:id", articles.Update)
		a.DELETE("/:id", articles.Delete)
	}
}

package main

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

	"example.com/articles-api/config"
	"example.com/articles-api/migrations"
	"example.com/articles-api/routes"
	"example.com/articles-api/seeds"
	"github.com/gin-contrib/cors"
	"github.com/gin-gonic/gin"
)

func main() {
	seed := flag.Bool("seed", false, "insert seed data and exit")
	flag.Parse()

	cfg := config.Load()
	db, err := config.OpenDB(cfg.DatabaseURL)
	if err != nil {
		log.Fatalf("connect database: %v", err)
	}
	if err := migrations.Run(db); err != nil {
		log.Fatalf("migrate: %v", err)
	}
	if *seed {
		if err := seeds.Run(db); err != nil {
			log.Fatalf("seed: %v", err)
		}
		log.Println("seed complete")
		return
	}

	r := gin.Default() // Logger and Recovery middleware
	if err := r.SetTrustedProxies(nil); err != nil {
		log.Fatal(err)
	}
	r.Use(cors.New(cors.Config{
		AllowOrigins:     cfg.CORSOrigins,
		AllowMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"},
		AllowHeaders:     []string{"Origin", "Content-Type", "Authorization"},
		AllowCredentials: true,
		MaxAge:           12 * time.Hour,
	}))
	routes.Register(r, db)

	srv := &http.Server{Addr: ":" + cfg.Port, Handler: r, ReadHeaderTimeout: 5 * time.Second}
	log.Fatal(srv.ListenAndServe())
}