feat: scaffold MySQL services with lifecycle and readiness checks

2026-09-20 23:12:47 +08:00
parent ff95692edb
commit affd02d5f7
28 changed files with 1153 additions and 63 deletions
--- a/cmd/go-omni/README.md
+++ b/cmd/go-omni/README.md
@@ -3,7 +3,7 @@
 从远程安装，生成一个带 Handler / Service / Repository / Model 分层的服务骨架：

 ```sh
-go install git.yuntuo.hk/k2safe/go-omni/cmd/go-omni@v0.1.1
+go install git.yuntuo.hk/k2safe/go-omni/cmd/go-omni@v0.2.0
 go-omni new --module example.com/billing ./billing
 cd billing
 go mod tidy
@@ -16,7 +16,7 @@ go run ./cmd/server
 需要选择其他已发布版本时，使用完整版本号：

 ```sh
-go-omni new --framework-version v0.1.1 --module example.com/billing ./billing
+go-omni new --framework-version v0.2.0 --module example.com/billing ./billing
 ```

 `--framework-version` 禁用自动本地替换；`main`、`latest` 等浮动引用不接受为固定版本。
@@ -32,13 +32,24 @@ go-omni new --framework-version v0.1.1 --module example.com/billing ./billing
 go-omni new --framework-dir /path/to/go-omni --module example.com/billing ./billing
 ```

-生成服务默认包含 `/health/live`、`/health/ready` 和示例 `POST /users`。
+默认生成内存存储版本；选择 MySQL 时：
+
+```sh
+go-omni new --database mysql --module example.com/billing ./billing
+```
+
+MySQL 项目额外包含 `schema.sql`、MySQL Repository 和可选的数据库集成测试。
+先应用建表脚本，再设置 `GO_OMNI_DB_DSN` 启动。ServiceContext 负责连接池初始化、表结构检查、
+就绪探针注册和关闭。两种模式都提供用户 CRUD、分页、输入校验和统一错误响应。
+
+生成服务默认包含 `/health/live`、`/health/ready` 和示例 `/users` CRUD。
 退出信号通过 `signal.NotifyContext` 传入 `RunContext`，Logger 的关闭函数注册到应用生命周期。

 发布验收使用 Python 3 标准库脚本，不需要额外 Python 依赖：

 ```sh
-python3 scripts/verifyScaffold.py --version v0.1.1
+python3 scripts/verifyScaffold.py --version v0.2.0
+python3 scripts/verifyDatabase.py --version v0.2.0
 ```

 脚本在源码目录外安装远程 CLI、生成项目，确认固定版本且没有 `replace`，再下载依赖、
@@ -50,4 +61,7 @@ python3 scripts/verifyScaffold.py --version v0.1.1
 ```sh
 go build -o /tmp/go-omni ./cmd/go-omni
 python3 scripts/verifyScaffold.py --cli /tmp/go-omni --framework-dir .
+python3 scripts/verifyDatabase.py --cli /tmp/go-omni --framework-dir .
 ```
+
+数据库验收需要本地 Docker，使用独立 MySQL 8.4 容器；不会连接已有业务数据库，结束后清理测试容器与数据卷。
--- a/cmd/go-omni/main.go
+++ b/cmd/go-omni/main.go
@@ -39,6 +39,17 @@ func runNew(args []string) error {
 		switch {
 		case arg == "--force":
 			options.Force = true
+		case arg == "--database":
+			if index+1 >= len(args) || strings.TrimSpace(args[index+1]) == "" {
+				return errors.New("--database requires memory or mysql")
+			}
+			index++
+			options.Database = args[index]
+		case strings.HasPrefix(arg, "--database="):
+			options.Database = strings.TrimPrefix(arg, "--database=")
+			if strings.TrimSpace(options.Database) == "" {
+				return errors.New("--database requires memory or mysql")
+			}
 		case arg == "--module":
 			if index+1 >= len(args) {
 				return errors.New("--module requires a value")
@@ -95,4 +106,5 @@ func usage() {
 	fmt.Fprintln(os.Stderr, "  go-omni new [--module <module>] [--force] <directory>")
 	fmt.Fprintln(os.Stderr, "  --framework-version <version>  Pin a remote framework version (defaults to CLI version)")
 	fmt.Fprintln(os.Stderr, "  --framework-dir <directory>    Use a local framework checkout")
+	fmt.Fprintln(os.Stderr, "  --database <memory|mysql>       Select generated storage (default memory)")
 }
--- a/cmd/go-omni/main_test.go
+++ b/cmd/go-omni/main_test.go
@@ -31,3 +31,21 @@ func TestNewRejectsEmptyFrameworkVersion(t *testing.T) {
 		}
 	}
 }
+
+func TestNewMySQLDatabaseOptions(t *testing.T) {
+	for _, flag := range [][]string{{"--database", "mysql"}, {"--database=mysql"}} {
+		project := filepath.Join(t.TempDir(), "billing")
+		args := append([]string{"--module", "example.com/billing"}, flag...)
+		if err := runNew(append(args, project)); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := os.Stat(filepath.Join(project, "schema.sql")); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, args := range [][]string{{"--database"}, {"--database="}, {"--database", " "}} {
+		if err := runNew(args); err == nil {
+			t.Fatalf("accepted missing database type: %v", args)
+		}
+	}
+}
--- a/cmd/go-omni/scaffold/scaffold.go
+++ b/cmd/go-omni/scaffold/scaffold.go
@@ -4,6 +4,7 @@ import (
 	"embed"
 	"errors"
 	"fmt"
+	"go/format"
 	"io/fs"
 	"os"
 	"path/filepath"
@@ -22,6 +23,7 @@ type Options struct {
 	Module           string
 	FrameworkDir     string
 	FrameworkVersion string
+	Database         string
 	Force            bool
 }

@@ -30,6 +32,8 @@ var files = map[string]string{
 	"README.md":                          "templates/README.md.tmpl",
 	"cmd/server/main.go":                 "templates/cmd-server-main.go.tmpl",
 	"internal/model/user.go":             "templates/internal-model-user.go.tmpl",
+	"internal/model/errors.go":           "templates/internal-model-errors.go.tmpl",
+	"internal/repository/users.go":       "templates/internal-repository-users.go.tmpl",
 	"internal/repository/memory.go":      "templates/internal-repository-memory.go.tmpl",
 	"internal/servicecontext/context.go": "templates/internal-servicecontext-context.go.tmpl",
 	"internal/service/user.go":           "templates/internal-service-user.go.tmpl",
@@ -44,6 +48,13 @@ func Generate(options Options) error {
 	if strings.TrimSpace(options.Module) == "" {
 		return errors.New("module path is required")
 	}
+	database := strings.ToLower(strings.TrimSpace(options.Database))
+	if database == "" {
+		database = "memory"
+	}
+	if database != "memory" && database != "mysql" {
+		return fmt.Errorf("unsupported database %q: choose memory or mysql", database)
+	}
 	version := strings.TrimSpace(options.FrameworkVersion)
 	if version == "" {
 		version = currentFrameworkVersion()
@@ -72,17 +83,34 @@ func Generate(options Options) error {
 		Module:           options.Module,
 		FrameworkVersion: version,
 		FrameworkReplace: replace,
+		Database:         database,
 	}
-	paths := make([]string, 0, len(files))
-	for path := range files {
+	projectFiles := make(map[string]string, len(files)+3)
+	for path, source := range files {
+		projectFiles[path] = source
+	}
+	if database == "mysql" {
+		projectFiles["internal/repository/mysql.go"] = "templates/internal-repository-mysql.go.tmpl"
+		projectFiles["schema.sql"] = "templates/schema.sql.tmpl"
+		projectFiles["internal/servicecontext/databaseIntegration_test.go"] = "templates/databaseIntegration_test.go.tmpl"
+	}
+	paths := make([]string, 0, len(projectFiles))
+	for path := range projectFiles {
 		paths = append(paths, path)
 	}
 	sort.Strings(paths)
 	for _, path := range paths {
-		content, err := render(files[path], data)
+		content, err := render(projectFiles[path], data)
 		if err != nil {
 			return fmt.Errorf("render %s: %w", path, err)
 		}
+		if strings.HasSuffix(path, ".go") {
+			formatted, err := format.Source([]byte(content))
+			if err != nil {
+				return fmt.Errorf("format %s: %w", path, err)
+			}
+			content = string(formatted)
+		}
 		target := filepath.Join(directory, filepath.FromSlash(path))
 		if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
 			return fmt.Errorf("create %s: %w", filepath.Dir(path), err)
@@ -105,6 +133,7 @@ type templateData struct {
 	Module           string
 	FrameworkVersion string
 	FrameworkReplace string
+	Database         string
 }

 func render(name string, data templateData) (string, error) {
--- a/cmd/go-omni/scaffold/scaffold_test.go
+++ b/cmd/go-omni/scaffold/scaffold_test.go
@@ -39,7 +39,7 @@ func TestGenerateCreatesServiceLayout(t *testing.T) {
 	if err != nil {
 		t.Fatalf("read generated server: %v", err)
 	}
-	for _, expected := range []string{"config.LoadFromEnv(\"\")", "logx.SetDefault(logger)", "omni.WithConfig(settings)", "servicecontext.New(logger, users)", "health.New()", "application.RunContext(ctx, settings.Address)"} {
+	for _, expected := range []string{"config.LoadFromEnv(\"\")", "logx.SetDefault(logger)", "omni.WithConfig(settings)", "servicecontext.New(ctx, logger)", "services.Health.ReadinessHandler()", "application.RunContext(ctx, settings.Address)"} {
 		if !strings.Contains(string(mainContent), expected) {
 			t.Fatalf("generated server missing %q: %s", expected, mainContent)
 		}
@@ -56,6 +56,35 @@ func TestGenerateRejectsNonEmptyDirectory(t *testing.T) {
 	}
 }

+func TestGenerateMySQLLayout(t *testing.T) {
+	project := filepath.Join(t.TempDir(), "billing")
+	if err := Generate(Options{Dir: project, Module: "example.com/billing", Database: "mysql", FrameworkDir: frameworkRoot(t)}); err != nil {
+		t.Fatal(err)
+	}
+	for _, path := range []string{"schema.sql", "internal/repository/mysql.go", "internal/repository/users.go", "internal/model/errors.go", "internal/servicecontext/databaseIntegration_test.go"} {
+		if _, err := os.Stat(filepath.Join(project, path)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	content, err := os.ReadFile(filepath.Join(project, "go.mod"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(content), "github.com/go-sql-driver/mysql v1.9.3") {
+		t.Fatal("mysql driver version is not pinned")
+	}
+}
+
+func TestGenerateRejectsUnknownDatabaseBeforeWriting(t *testing.T) {
+	project := filepath.Join(t.TempDir(), "billing")
+	if err := Generate(Options{Dir: project, Module: "example.com/billing", Database: "unknown"}); err == nil {
+		t.Fatal("accepted unknown backend")
+	}
+	if _, err := os.Stat(project); !os.IsNotExist(err) {
+		t.Fatalf("invalid backend created files: %v", err)
+	}
+}
+
 func TestFrameworkReplaceUsesCanonicalPaths(t *testing.T) {
 	root := frameworkRoot(t)
 	project := filepath.Join(t.TempDir(), "generated")
--- a/cmd/go-omni/scaffold/templates/README.md.tmpl
+++ b/cmd/go-omni/scaffold/templates/README.md.tmpl
@@ -4,6 +4,26 @@ This service was generated with `go-omni new`.

 Framework dependency: `git.yuntuo.hk/k2safe/go-omni {{.FrameworkVersion}}`.

+Storage: `{{.Database}}`.
+
+{{if eq .Database "mysql"}}
+先创建业务数据库，再执行项目的建表脚本（替换示例数据库名、账号和地址）：
+
+```sh
+mysql -h 127.0.0.1 -u app -p app < schema.sql
+```
+
+配置数据库连接后启动；初始化失败或缺少表结构时，服务会退出并关闭已创建的连接池：
+
+```sh
+export GO_OMNI_DB_DSN='app:password@tcp(127.0.0.1:3306)/app?parseTime=true'
+```
+
+应用只检查表结构，不会自动建库、建表或迁移。MySQL 驱动由本项目注册，核心框架仍依赖标准库 `database/sql`。
+{{else}}
+默认使用进程内存存储，服务重启后数据清空。需要 MySQL 时，生成新项目时选择 `--database mysql`。
+{{end}}
+
 ```sh
 go mod tidy
 go run ./cmd/server
@@ -26,10 +46,59 @@ go build -o server ./cmd/server
 ./server
 ```

-`GO_OMNI_SHUTDOWN_TIMEOUT` 控制等待请求完成的时间，默认 `10s`。健康探针目前没有
-数据库依赖检查；接入数据库后需要向 Checker 注册探针。
+`GO_OMNI_SHUTDOWN_TIMEOUT` 控制等待请求完成的时间，默认 `10s`。
+{{if eq .Database "mysql"}}
+`/health/ready` 已注册数据库探针：连接失败返回 `503`，数据库恢复后重新返回 `200`。
+`/health/live` 始终只检查服务存活。`GO_OMNI_DB_PING_TIMEOUT` 限制初始化检查和数据库探针的等待时间。
+退出时先排空 HTTP 请求，再关闭数据库连接池，最后关闭日志。

-The generated layout keeps HTTP handlers, business services, repositories,
-models and a project-owned ServiceContext separate. Replace the memory
-repository with a database implementation when the service is ready for
-persistence, then add it to `internal/servicecontext`.
+数据库连接池参数：
+
+```text
+GO_OMNI_DB_MAX_OPEN_CONNS=10
+GO_OMNI_DB_MAX_IDLE_CONNS=5
+GO_OMNI_DB_CONN_MAX_LIFETIME=30m
+GO_OMNI_DB_CONN_MAX_IDLE_TIME=5m
+GO_OMNI_DB_PING_TIMEOUT=5s
+```
+
+`MAX_IDLE_CONNS=0` 禁用空闲连接，`MAX_OPEN_CONNS=0` 表示不限制连接数。
+项目会启用 MySQL `parseTime` 并按 UTC 读取 DATETIME 字段，JSON 字段保持 lowerCamelCase。
+
+事务内复用 Repository（在业务代码中导入 `database/sql` 和项目的 `internal/repository`）：
+
+```go
+err := services.DB.InTx(ctx, nil, func(tx *sql.Tx) error {
+	users := repository.NewMySQLUsers(tx)
+	_, err := users.Create(ctx, input)
+	return err
+})
+```
+
+业务函数返回错误、发生 panic 或 context 取消时会回滚。事务内必须使用基于 `tx` 创建的 Repository。
+
+可选集成测试（只针对已应用 schema.sql 的独立测试数据库）：
+
+```sh
+GO_OMNI_TEST_MYSQL_DSN='app:password@tcp(127.0.0.1:3306)/test?parseTime=true' go test -race ./...
+```
+
+未设置 `GO_OMNI_TEST_MYSQL_DSN` 时跳过数据库集成测试。框架仓库中的 `scripts/verifyDatabase.py`
+可以自动创建、验收和清理独立的 MySQL 容器。
+{{else}}
+内存模式没有外部依赖探针；后续添加依赖时，在 `internal/servicecontext` 注册检查与资源清理。
+{{end}}
+
+示例接口（无认证，接入实际业务时按项目需求添加认证中间件）：
+
+| 方法 | 路径 | 说明 |
+| --- | --- | --- |
+| POST | `/users` | 创建，JSON 包含 name、email |
+| GET | `/users/:id` | 查询 |
+| GET | `/users?page=1&pageSize=20` | 分页 |
+| PUT | `/users/:id` | 更新 name、email |
+| DELETE | `/users/:id` | 删除，返回 204 |
+
+接口使用 GoOmni 统一响应，包含 code、message、data 和 requestId。邮箱按小写存储，重复返回 409；
+无效输入返回 400，找不到记录返回 404。项目按 Handler / Service / Repository / Model 分层，
+基础依赖集中放在 `internal/servicecontext`。
--- a/cmd/go-omni/scaffold/templates/cmd-server-main.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/cmd-server-main.go.tmpl
@@ -10,10 +10,8 @@ import (

 	omni "git.yuntuo.hk/k2safe/go-omni"
 	"git.yuntuo.hk/k2safe/go-omni/config"
-	"git.yuntuo.hk/k2safe/go-omni/health"
 	"git.yuntuo.hk/k2safe/go-omni/logx"
 	"{{.Module}}/internal/handler"
-	"{{.Module}}/internal/repository"
 	"{{.Module}}/internal/service"
 	"{{.Module}}/internal/servicecontext"
 )
@@ -43,19 +41,17 @@ func run() error {
 	// Access logs and business logs share the same configured sink.
 	logx.SetDefault(logger)

-	users := repository.NewMemoryUsers()
-	services := servicecontext.New(logger, users)
+	services, err := servicecontext.New(ctx, logger)
+	if err != nil { return err }
+	defer services.Close()
 	userService := service.NewUsers(services)
 	userHandler := handler.NewUsers(userService)
-	checker, err := health.New()
-	if err != nil {
-		return err
-	}

 	application := omni.New(omni.WithConfig(settings))
 	application.OnShutdown(logger.Close)
-	application.GET("/health/live", checker.LivenessHandler())
-	application.GET("/health/ready", checker.ReadinessHandler())
+	application.OnShutdown(services.Close)
+	application.GET("/health/live", services.Health.LivenessHandler())
+	application.GET("/health/ready", services.Health.ReadinessHandler())
 	userHandler.RegisterRoutes(application)
 	return application.RunContext(ctx, settings.Address)
 }
--- a/cmd/go-omni/scaffold/templates/databaseIntegration_test.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/databaseIntegration_test.go.tmpl
@@ -0,0 +1,106 @@
+package servicecontext_test
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"testing"
+	"time"
+
+	"git.yuntuo.hk/k2safe/go-omni/database"
+	"git.yuntuo.hk/k2safe/go-omni/logx"
+	"{{.Module}}/internal/model"
+	"{{.Module}}/internal/repository"
+	"{{.Module}}/internal/servicecontext"
+)
+
+// These tests require a dedicated database with schema.sql applied. Ordinary
+// go test runs skip them; scripts/verifyDatabase.py provisions an isolated DB.
+func databaseContext(t *testing.T) *servicecontext.Context {
+	t.Helper()
+	dsn := os.Getenv("GO_OMNI_TEST_MYSQL_DSN")
+	if dsn == "" { t.Skip("set GO_OMNI_TEST_MYSQL_DSN to a dedicated test database") }
+	for _, key := range []string{"MAX_OPEN_CONNS", "MAX_IDLE_CONNS", "CONN_MAX_LIFETIME", "CONN_MAX_IDLE_TIME", "PING_TIMEOUT"} {
+		t.Setenv("GO_OMNI_DB_"+key, "")
+	}
+	t.Setenv("GO_OMNI_DB_DSN", dsn)
+	t.Setenv("GO_OMNI_DB_DRIVER", "mysql")
+	logger, err := logx.New(logx.Config{Writer: io.Discard})
+	if err != nil { t.Fatal(err) }
+	t.Cleanup(func() { _ = logger.Close() })
+	services, err := servicecontext.New(context.Background(), logger)
+	if err != nil { t.Fatal(err) }
+	t.Cleanup(func() { _ = services.Close() })
+	return services
+}
+
+func TestDatabaseTransactions(t *testing.T) {
+	services := databaseContext(t)
+	ctx := context.Background()
+	for _, mode := range []string{"commit", "error", "panic", "cancel"} {
+		t.Run(mode, func(t *testing.T) {
+			email := fmt.Sprintf("transaction-%d-%s@example.com", time.Now().UnixNano(), mode)
+			t.Cleanup(func() { _, _ = services.DB.ExecContext(ctx, "DELETE FROM users WHERE email = ?", email) })
+			txCtx, cancel := context.WithCancel(ctx)
+			defer cancel()
+			abort := errors.New("abort business operation")
+			var err error
+			var recovered any
+			func() {
+				defer func() { recovered = recover() }()
+				err = services.DB.InTx(txCtx, nil, func(tx *sql.Tx) error {
+					users := repository.NewMySQLUsers(tx)
+					if _, err := users.Create(txCtx, model.UserInput{Name: "transaction", Email: email}); err != nil { return err }
+					switch mode {
+					case "error": return abort
+					case "panic": panic(abort)
+					case "cancel": cancel(); return txCtx.Err()
+					}
+					return nil
+				})
+			}()
+			switch mode {
+			case "commit": if err != nil || recovered != nil { t.Fatalf("commit: error=%v panic=%v", err, recovered) }
+			case "error": if !errors.Is(err, abort) { t.Fatalf("lost business error: %v", err) }
+			case "panic": if recovered != abort { t.Fatalf("lost panic: %v", recovered) }
+			case "cancel": if !errors.Is(err, context.Canceled) { t.Fatalf("lost cancellation: %v", err) }
+			}
+			var count int
+			if err := services.DB.QueryRowContext(ctx, "SELECT COUNT(*) FROM users WHERE email = ?", email).Scan(&count); err != nil { t.Fatal(err) }
+			want := 0
+			if mode == "commit" { want = 1 }
+			if count != want { t.Fatalf("%s persisted %d rows, want %d", mode, count, want) }
+		})
+	}
+}
+
+func TestDatabasePoolHealthAndClose(t *testing.T) {
+	services := databaseContext(t)
+	ctx := context.Background()
+	if result := services.Health.Check(ctx); !result.Ready() || len(result.Checks) != 1 { t.Fatalf("missing database readiness: %+v", result) }
+
+	cfg := services.DB.Config()
+	cfg.MaxOpenConns, cfg.MaxIdleConns = 1, 0
+	pool, err := database.Open(ctx, cfg)
+	if err != nil { t.Fatal(err) }
+	if idle := pool.Stats().Idle; idle != 0 { t.Fatalf("zero idle config retained %d connections", idle) }
+	_ = pool.Close()
+
+	cfg.MaxIdleConns, cfg.PingTimeout = 1, 50*time.Millisecond
+	pool, err = database.Open(ctx, cfg)
+	if err != nil { t.Fatal(err) }
+	defer pool.Close()
+	connection, err := pool.Conn(ctx)
+	if err != nil { t.Fatal(err) }
+	defer connection.Close()
+	started := time.Now()
+	err = pool.Health(ctx)
+	if !errors.Is(err, context.DeadlineExceeded) || time.Since(started) > time.Second { t.Fatalf("health did not bound pool waiting: %v", err) }
+
+	if err := services.Close(); err != nil { t.Fatal(err) }
+	if err := services.Close(); err != nil { t.Fatal(err) }
+	if result := services.Health.Check(ctx); result.Ready() { t.Fatal("closed database was still ready") }
+}
--- a/cmd/go-omni/scaffold/templates/go.mod.tmpl
+++ b/cmd/go-omni/scaffold/templates/go.mod.tmpl
@@ -3,6 +3,8 @@ module {{.Module}}
 go 1.22

 require git.yuntuo.hk/k2safe/go-omni {{.FrameworkVersion}}
+{{if eq .Database "mysql"}}require github.com/go-sql-driver/mysql v1.9.3
+{{end}}
 {{- if .FrameworkReplace}}
 replace git.yuntuo.hk/k2safe/go-omni => {{.FrameworkReplace}}
 {{- end}}
--- a/cmd/go-omni/scaffold/templates/internal-handler-user.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/internal-handler-user.go.tmpl
@@ -1,9 +1,10 @@
 package handler

 import (
+	"errors"
 	"net/http"

-	omni "git.yuntuo.hk/k2safe/go-omni"
+	"git.yuntuo.hk/k2safe/go-omni"
 	"{{.Module}}/internal/model"
 	"{{.Module}}/internal/service"
 )
@@ -12,20 +13,109 @@ type Users struct {
 	service *service.Users
 }

-func NewUsers(service *service.Users) *Users { return &Users{service: service} }
+func NewUsers(service *service.Users) *Users {
+	return &Users{service: service}
+}

 func (h *Users) RegisterRoutes(application *omni.App) {
-	application.POST("/users", h.Create)
+	users := application.Group("/users")
+	users.POST("", h.Create)
+	users.GET("", h.List)
+	users.GET("/:id", h.Get)
+	users.PUT("/:id", h.Update)
+	users.DELETE("/:id", h.Delete)
+}
+
+// HTTP-specific validation tags stay here, outside the business model.
+type userBody struct {
+	Name  string `json:"name" binding:"required,max=100"`
+	Email string `json:"email" binding:"required,email,max=254"`
+}
+
+type userPath struct {
+	ID int64 `uri:"id" binding:"gt=0"`
+}
+
+type listQuery struct {
+	Page     int `form:"page,default=1" binding:"gte=1"`
+	PageSize int `form:"pageSize,default=20" binding:"gte=1,lte=100"`
 }

 func (h *Users) Create(ctx *omni.Context) error {
-	var input model.UserInput
-	if err := ctx.BindJSON(&input); err != nil {
+	var body userBody
+	if err := ctx.BindJSON(&body); err != nil {
 		return err
 	}
-	user, err := h.service.Create(ctx.Context(), input)
+	user, err := h.service.Create(ctx.Request().Context(), model.UserInput(body))
 	if err != nil {
+		return userError(err)
+	}
+	return ctx.Created(user)
+}
+
+func (h *Users) Get(ctx *omni.Context) error {
+	var path userPath
+	if err := ctx.BindURI(&path); err != nil {
+		return err
+	}
+	user, err := h.service.Get(ctx.Request().Context(), path.ID)
+	if err != nil {
+		return userError(err)
+	}
+	return ctx.OK(user)
+}
+
+func (h *Users) List(ctx *omni.Context) error {
+	var query listQuery
+	if err := ctx.BindQuery(&query); err != nil {
+		return err
+	}
+	page, err := h.service.List(ctx.Request().Context(), query.Page, query.PageSize)
+	if err != nil {
+		return userError(err)
+	}
+	return ctx.OK(page)
+}
+
+func (h *Users) Update(ctx *omni.Context) error {
+	var path userPath
+	if err := ctx.BindURI(&path); err != nil {
+		return err
+	}
+	var body userBody
+	if err := ctx.BindJSON(&body); err != nil {
+		return err
+	}
+	user, err := h.service.Update(ctx.Request().Context(), path.ID, model.UserInput(body))
+	if err != nil {
+		return userError(err)
+	}
+	return ctx.OK(user)
+}
+
+func (h *Users) Delete(ctx *omni.Context) error {
+	var path userPath
+	if err := ctx.BindURI(&path); err != nil {
+		return err
+	}
+	if err := h.service.Delete(ctx.Request().Context(), path.ID); err != nil {
+		return userError(err)
+	}
+	return ctx.NoContent()
+}
+
+func userError(err error) error {
+	switch {
+	case errors.Is(err, model.ErrUserNotFound):
+		return omni.NotFound("USER_NOT_FOUND", "user was not found").WithCause(err)
+	case errors.Is(err, model.ErrEmailTaken):
+		return omni.NewError(http.StatusConflict, "EMAIL_TAKEN", "email is already in use").WithCause(err)
+	case errors.Is(err, model.ErrInvalidUser):
+		return omni.BadRequest("INVALID_USER", "name or email is invalid").WithCause(err)
+	case errors.Is(err, model.ErrInvalidPage):
+		return omni.BadRequest("INVALID_QUERY", "pagination is invalid").WithCause(err)
+	default:
+		// GoOmni masks unexpected errors; internal details stay in server logs.
 		return err
 	}
-	return ctx.JSON(http.StatusCreated, user)
 }
--- a/cmd/go-omni/scaffold/templates/internal-model-errors.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/internal-model-errors.go.tmpl
@@ -0,0 +1,11 @@
+package model
+
+import "errors"
+
+// Domain errors are translated into HTTP responses only by the handler layer.
+var (
+	ErrUserNotFound = errors.New("user not found")
+	ErrEmailTaken   = errors.New("email already in use")
+	ErrInvalidUser  = errors.New("invalid user")
+	ErrInvalidPage  = errors.New("invalid pagination")
+)
--- a/cmd/go-omni/scaffold/templates/internal-model-user.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/internal-model-user.go.tmpl
@@ -2,6 +2,7 @@ package model

 import "time"

+// User is the business entity; it has no dependency on HTTP or a database driver.
 type User struct {
 	ID        int64     `json:"id"`
 	Name      string    `json:"name"`
@@ -10,7 +11,15 @@ type User struct {
 	UpdatedAt time.Time `json:"updatedAt"`
 }

+// UserInput is shared by creation and full replacement (PUT).
 type UserInput struct {
-	Name  string `json:"name"`
-	Email string `json:"email"`
+	Name  string
+	Email string
+}
+
+type UserPage struct {
+	Items    []User `json:"items"`
+	Total    int    `json:"total"`
+	Page     int    `json:"page"`
+	PageSize int    `json:"pageSize"`
 }
--- a/cmd/go-omni/scaffold/templates/internal-repository-memory.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/internal-repository-memory.go.tmpl
@@ -2,30 +2,125 @@ package repository

 import (
 	"context"
+	"sort"
 	"sync"
 	"time"

 	"{{.Module}}/internal/model"
 )

-type UserRepository interface {
-	Create(context.Context, model.UserInput) (model.User, error)
-}
-
+// MemoryUsers stores data only for this process. Replace it with a database
+// implementation of UserRepository when persistence is required.
 type MemoryUsers struct {
-	mu     sync.Mutex
+	mu     sync.RWMutex
+	users  map[int64]model.User
+	emails map[string]int64
 	nextID int64
-	users  []model.User
 }

-func NewMemoryUsers() *MemoryUsers { return &MemoryUsers{nextID: 1} }
+func NewMemoryUsers() *MemoryUsers {
+	return &MemoryUsers{
+		users:  make(map[int64]model.User),
+		emails: make(map[string]int64),
+		nextID: 1,
+	}
+}

-func (r *MemoryUsers) Create(_ context.Context, input model.UserInput) (model.User, error) {
+func (r *MemoryUsers) Create(ctx context.Context, input model.UserInput) (model.User, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
+	if err := ctx.Err(); err != nil {
+		return model.User{}, err
+	}
+	if _, exists := r.emails[input.Email]; exists {
+		return model.User{}, model.ErrEmailTaken
+	}
 	now := time.Now().UTC()
-	user := model.User{ID: r.nextID, Name: input.Name, Email: input.Email, CreatedAt: now, UpdatedAt: now}
+	user := model.User{
+		ID: r.nextID, Name: input.Name, Email: input.Email,
+		CreatedAt: now, UpdatedAt: now,
+	}
 	r.nextID++
-	r.users = append(r.users, user)
+	r.users[user.ID] = user
+	r.emails[user.Email] = user.ID
 	return user, nil
 }
+
+func (r *MemoryUsers) Get(ctx context.Context, id int64) (model.User, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if err := ctx.Err(); err != nil {
+		return model.User{}, err
+	}
+	user, exists := r.users[id]
+	if !exists {
+		return model.User{}, model.ErrUserNotFound
+	}
+	return user, nil
+}
+
+func (r *MemoryUsers) List(ctx context.Context, page, pageSize int) (model.UserPage, error) {
+	if page < 1 || pageSize < 1 || pageSize > 100 {
+		return model.UserPage{}, model.ErrInvalidPage
+	}
+	r.mu.RLock()
+	if err := ctx.Err(); err != nil {
+		r.mu.RUnlock()
+		return model.UserPage{}, err
+	}
+	users := make([]model.User, 0, len(r.users))
+	for _, user := range r.users {
+		users = append(users, user)
+	}
+	r.mu.RUnlock()
+
+	// A stable order is essential: Go map iteration order changes between calls.
+	sort.Slice(users, func(i, j int) bool { return users[i].ID < users[j].ID })
+	result := model.UserPage{
+		Items: []model.User{}, Total: len(users), Page: page, PageSize: pageSize,
+	}
+	// Check the page before multiplying so even a very large page cannot overflow.
+	if len(users) == 0 || page-1 > (len(users)-1)/pageSize {
+		return result, nil
+	}
+	start := (page - 1) * pageSize
+	count := min(pageSize, len(users)-start)
+	result.Items = users[start : start+count]
+	return result, nil
+}
+
+func (r *MemoryUsers) Update(ctx context.Context, id int64, input model.UserInput) (model.User, error) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if err := ctx.Err(); err != nil {
+		return model.User{}, err
+	}
+	user, exists := r.users[id]
+	if !exists {
+		return model.User{}, model.ErrUserNotFound
+	}
+	if owner, exists := r.emails[input.Email]; exists && owner != id {
+		return model.User{}, model.ErrEmailTaken
+	}
+	delete(r.emails, user.Email)
+	user.Name, user.Email = input.Name, input.Email
+	user.UpdatedAt = time.Now().UTC()
+	r.users[id] = user
+	r.emails[user.Email] = id
+	return user, nil
+}
+
+func (r *MemoryUsers) Delete(ctx context.Context, id int64) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	user, exists := r.users[id]
+	if !exists {
+		return model.ErrUserNotFound
+	}
+	delete(r.users, id)
+	delete(r.emails, user.Email)
+	return nil
+}
--- a/cmd/go-omni/scaffold/templates/internal-repository-mysql.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/internal-repository-mysql.go.tmpl
@@ -0,0 +1,139 @@
+package repository
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+
+	"{{.Module}}/internal/model"
+	"github.com/go-sql-driver/mysql"
+)
+
+// SQLExecutor is implemented by both *sql.DB and *sql.Tx. A repository created
+// with a transaction keeps all of its queries on that same transaction.
+type SQLExecutor interface {
+	ExecContext(context.Context, string, ...any) (sql.Result, error)
+	QueryContext(context.Context, string, ...any) (*sql.Rows, error)
+	QueryRowContext(context.Context, string, ...any) *sql.Row
+}
+
+// MySQLUsers is the persistent implementation of UserRepository.
+// The schema is documented in schema.sql; migrations stay outside the framework.
+type MySQLUsers struct {
+	db SQLExecutor
+}
+
+func NewMySQLUsers(db SQLExecutor) *MySQLUsers {
+	return &MySQLUsers{db: db}
+}
+
+// CheckSchema validates that the application's migration has been applied.
+// Runtime startup never creates or alters tables.
+func (r *MySQLUsers) CheckSchema(ctx context.Context) error {
+	rows, err := r.db.QueryContext(ctx, `SELECT id, name, email, created_at, updated_at FROM users LIMIT 0`)
+	if err != nil { return err }
+	return rows.Close()
+}
+
+func (r *MySQLUsers) Create(ctx context.Context, input model.UserInput) (model.User, error) {
+	result, err := r.db.ExecContext(ctx, `
+		INSERT INTO users (name, email, created_at, updated_at)
+		VALUES (?, ?, UTC_TIMESTAMP(6), UTC_TIMESTAMP(6))`, input.Name, input.Email)
+	if err != nil {
+		return model.User{}, mapMySQLError(err)
+	}
+	id, err := result.LastInsertId()
+	if err != nil {
+		return model.User{}, err
+	}
+	return r.Get(ctx, id)
+}
+
+func (r *MySQLUsers) Get(ctx context.Context, id int64) (model.User, error) {
+	var user model.User
+	err := r.db.QueryRowContext(ctx, `
+		SELECT id, name, email, created_at, updated_at
+		FROM users WHERE id = ?`, id).Scan(
+		&user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt,
+	)
+	if errors.Is(err, sql.ErrNoRows) {
+		return model.User{}, model.ErrUserNotFound
+	}
+	if err != nil {
+		return model.User{}, err
+	}
+	return user, nil
+}
+
+func (r *MySQLUsers) List(ctx context.Context, page, pageSize int) (model.UserPage, error) {
+	if page < 1 || pageSize < 1 || pageSize > 100 { return model.UserPage{}, model.ErrInvalidPage }
+	var total int
+	if err := r.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM users`).Scan(&total); err != nil {
+		return model.UserPage{}, err
+	}
+	result := model.UserPage{Items: []model.User{}, Total: total, Page: page, PageSize: pageSize}
+	if total == 0 || page-1 > (total-1)/pageSize {
+		return result, nil
+	}
+	offset := (page - 1) * pageSize
+	rows, err := r.db.QueryContext(ctx, `
+		SELECT id, name, email, created_at, updated_at
+		FROM users ORDER BY id LIMIT ? OFFSET ?`, pageSize, offset)
+	if err != nil {
+		return model.UserPage{}, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var user model.User
+		if err := rows.Scan(&user.ID, &user.Name, &user.Email, &user.CreatedAt, &user.UpdatedAt); err != nil {
+			return model.UserPage{}, err
+		}
+		result.Items = append(result.Items, user)
+	}
+	if err := rows.Err(); err != nil {
+		return model.UserPage{}, err
+	}
+	return result, nil
+}
+
+func (r *MySQLUsers) Update(ctx context.Context, id int64, input model.UserInput) (model.User, error) {
+	result, err := r.db.ExecContext(ctx, `
+		UPDATE users SET name = ?, email = ?, updated_at = UTC_TIMESTAMP(6)
+		WHERE id = ?`, input.Name, input.Email, id)
+	if err != nil {
+		return model.User{}, mapMySQLError(err)
+	}
+	changed, err := result.RowsAffected()
+	if err != nil {
+		return model.User{}, err
+	}
+	if changed == 0 {
+		// MySQL may report zero affected rows when the replacement is identical;
+		// distinguish that from an ID that does not exist.
+		return r.Get(ctx, id)
+	}
+	return r.Get(ctx, id)
+}
+
+func (r *MySQLUsers) Delete(ctx context.Context, id int64) error {
+	result, err := r.db.ExecContext(ctx, `DELETE FROM users WHERE id = ?`, id)
+	if err != nil {
+		return err
+	}
+	deleted, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+	if deleted == 0 {
+		return model.ErrUserNotFound
+	}
+	return nil
+}
+
+func mapMySQLError(err error) error {
+	var mysqlErr *mysql.MySQLError
+	if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 {
+		return model.ErrEmailTaken
+	}
+	return err
+}
--- a/cmd/go-omni/scaffold/templates/internal-repository-users.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/internal-repository-users.go.tmpl
@@ -0,0 +1,16 @@
+package repository
+
+import (
+"context"
+"{{.Module}}/internal/model"
+)
+
+// UserRepository describes the storage operations the business needs.
+// Implementations must atomically enforce unique, normalized email addresses.
+type UserRepository interface {
+	Create(context.Context, model.UserInput) (model.User, error)
+	Get(context.Context, int64) (model.User, error)
+	List(context.Context, int, int) (model.UserPage, error)
+	Update(context.Context, int64, model.UserInput) (model.User, error)
+	Delete(context.Context, int64) error
+}
--- a/cmd/go-omni/scaffold/templates/internal-service-user.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/internal-service-user.go.tmpl
@@ -2,20 +2,61 @@ package service

 import (
 	"context"
+	"net/mail"
+	"strings"
+	"unicode/utf8"

 	"{{.Module}}/internal/model"
 	"{{.Module}}/internal/servicecontext"
 )

 type Users struct {
-	context *servicecontext.Context
+	services *servicecontext.Context
 }

-func NewUsers(context *servicecontext.Context) *Users {
-	return &Users{context: context}
+func NewUsers(services *servicecontext.Context) *Users {
+	return &Users{services: services}
 }

 func (s *Users) Create(ctx context.Context, input model.UserInput) (model.User, error) {
-	// Put business normalization and rules here.
-	return s.context.Users.Create(ctx, input)
+	input, err := normalize(input)
+	if err != nil {
+		return model.User{}, err
+	}
+	return s.services.Users.Create(ctx, input)
+}
+
+func (s *Users) Get(ctx context.Context, id int64) (model.User, error) {
+	return s.services.Users.Get(ctx, id)
+}
+
+func (s *Users) List(ctx context.Context, page, pageSize int) (model.UserPage, error) {
+	if page < 1 || pageSize < 1 || pageSize > 100 {
+		return model.UserPage{}, model.ErrInvalidPage
+	}
+	return s.services.Users.List(ctx, page, pageSize)
+}
+
+func (s *Users) Update(ctx context.Context, id int64, input model.UserInput) (model.User, error) {
+	input, err := normalize(input)
+	if err != nil {
+		return model.User{}, err
+	}
+	return s.services.Users.Update(ctx, id, input)
+}
+
+func (s *Users) Delete(ctx context.Context, id int64) error {
+	return s.services.Users.Delete(ctx, id)
+}
+
+func normalize(input model.UserInput) (model.UserInput, error) {
+	input.Name = strings.TrimSpace(input.Name)
+	// This example treats the entire email address as case-insensitive.
+	input.Email = strings.ToLower(strings.TrimSpace(input.Email))
+	address, err := mail.ParseAddress(input.Email)
+	if input.Name == "" || utf8.RuneCountInString(input.Name) > 100 ||
+		len(input.Email) > 254 || err != nil || address.Address != input.Email {
+		return model.UserInput{}, model.ErrInvalidUser
+	}
+	return input, nil
 }
--- a/cmd/go-omni/scaffold/templates/internal-servicecontext-context.go.tmpl
+++ b/cmd/go-omni/scaffold/templates/internal-servicecontext-context.go.tmpl
@@ -1,6 +1,12 @@
 package servicecontext

 import (
+	"context"
+	{{if eq .Database "mysql"}}"fmt"
+	"time"
+	"git.yuntuo.hk/k2safe/go-omni/database"
+	"github.com/go-sql-driver/mysql"{{end}}
+	"git.yuntuo.hk/k2safe/go-omni/health"
 	"git.yuntuo.hk/k2safe/go-omni/logx"
 	"{{.Module}}/internal/repository"
 )
@@ -10,8 +16,51 @@ import (
 type Context struct {
 	Logger *logx.Logger
 	Users  repository.UserRepository
+	Health *health.Checker
+	{{if eq .Database "mysql"}}DB *database.DB{{end}}
 }

-func New(logger *logx.Logger, users repository.UserRepository) *Context {
-	return &Context{Logger: logger, Users: users}
+// New initializes the project's dependencies before the HTTP listener opens.
+// The caller owns Logger; Close releases only resources created here.
+func New(ctx context.Context, logger *logx.Logger) (*Context, error) {
+	if ctx == nil { ctx = context.Background() }
+	if err := ctx.Err(); err != nil { return nil, err }
+	checker, err := health.New()
+	if err != nil { return nil, err }
+	services := &Context{Logger: logger, Health: checker}
+	{{if eq .Database "mysql"}}
+	cfg, err := database.ConfigFromEnv("")
+	if err != nil { return nil, err }
+	if cfg.Driver != "mysql" { return nil, fmt.Errorf("this project requires GO_OMNI_DB_DRIVER=mysql") }
+	dsn, err := mysql.ParseDSN(cfg.DSN)
+	if err != nil { return nil, fmt.Errorf("parse mysql connection settings: %w", err) }
+	if dsn.DBName == "" { return nil, fmt.Errorf("mysql connection settings require a database name") }
+	// DATETIME columns are returned as time.Time in UTC in the business model.
+	dsn.ParseTime = true
+	dsn.Loc = time.UTC
+	cfg.DSN = dsn.FormatDSN()
+	db, err := database.Open(ctx, cfg)
+	if err != nil { return nil, err }
+	users := repository.NewMySQLUsers(db.DB)
+	checkCtx, cancel := context.WithTimeout(ctx, cfg.PingTimeout)
+	defer cancel()
+	if err := users.CheckSchema(checkCtx); err != nil {
+		_ = db.Close()
+		return nil, fmt.Errorf("check users schema (apply schema.sql before starting): %w", err)
+	}
+	if err := checker.Add(health.Probe{Name: "database", Timeout: cfg.PingTimeout, Check: db.Health}); err != nil {
+		_ = db.Close()
+		return nil, err
+	}
+	services.DB, services.Users = db, users
+	{{else}}
+	services.Users = repository.NewMemoryUsers()
+	{{end}}
+	return services, nil
+}
+
+// Close is safe to call on startup failure and again during application exit.
+func (c *Context) Close() error {
+	{{if eq .Database "mysql"}}if c != nil && c.DB != nil { return c.DB.Close() }{{end}}
+	return nil
 }
--- a/cmd/go-omni/scaffold/templates/schema.sql.tmpl
+++ b/cmd/go-omni/scaffold/templates/schema.sql.tmpl
@@ -0,0 +1,9 @@
+CREATE TABLE users (
+    id BIGINT NOT NULL AUTO_INCREMENT,
+    name VARCHAR(100) NOT NULL,
+    email VARCHAR(254) NOT NULL,
+    created_at DATETIME(6) NOT NULL,
+    updated_at DATETIME(6) NOT NULL,
+    PRIMARY KEY (id),
+    UNIQUE KEY uq_users_email (email)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;
--- a/cmd/go-omni/scaffold/version.go
+++ b/cmd/go-omni/scaffold/version.go
@@ -10,7 +10,7 @@ const frameworkModule = "git.yuntuo.hk/k2safe/go-omni"
 // Source builds can carry an unpublished VCS version (including +dirty).
 // Keep this fallback in sync with the next release; installed CLIs use their
 // downloaded module version, which also has a module checksum.
-const defaultFrameworkVersion = "v0.1.1"
+const defaultFrameworkVersion = "v0.2.0"

 var frameworkVersionPattern = regexp.MustCompile(`^v[01]\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-((0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)(\.(0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*))?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$`)