gorig-cli 1.0.24 → 1.0.25

package/templates/crud.mongo.config.yaml.ejs

@@ -0,0 +1,19 @@
+  <%= dbName %>:
+    uri: mongodb://127.0.0.1:27017  # MongoDB URI；环境变量 GORIG_MONGO_<%= dbEnvName %>_URI
+    db:
+      name: <%= dbSchema %>         # 数据库名；环境变量 GORIG_MONGO_<%= dbEnvName %>_DB_NAME
+    auth:
+      need: false                   # 是否启用认证
+      source: admin                 # 认证数据库；环境变量 GORIG_MONGO_<%= dbEnvName %>_AUTH_SOURCE
+      user: ""                      # 用户名；环境变量 GORIG_MONGO_<%= dbEnvName %>_AUTH_USER
+      password: ""                  # 密码；建议使用 GORIG_MONGO_<%= dbEnvName %>_AUTH_PASSWORD
+    retry:
+      writes: true                  # 是否自动重试写操作
+      reads: true                   # 是否自动重试读操作
+    pool:
+      max: 10                       # 最大连接池大小
+      min: 1                        # 最小连接池大小
+    conn:
+      idle:
+        time:
+          max: 10                   # 最大空闲时间，单位秒

package/templates/crud.mysql.config.yaml.ejs

@@ -0,0 +1,14 @@
+  <%= dbName %>:
+    GormInit: 1                 # 1: 启动时初始化此 MySQL 连接；0: 不初始化
+    IsOpenReadDb: 0             # 1: 启用读写分离；0: 仅使用 Write
+    SlowThreshold: 30           # 慢 SQL 阈值，单位秒
+    Write:
+      Host: 127.0.0.1           # MySQL 地址；环境变量 GORIG_MYSQL_<%= dbEnvName %>_WRITE_HOST
+      Port: 3306                # MySQL 端口；环境变量 GORIG_MYSQL_<%= dbEnvName %>_WRITE_PORT
+      DataBase: <%= dbSchema %> # 数据库名；环境变量 GORIG_MYSQL_<%= dbEnvName %>_WRITE_DATABASE
+      User: root                # 用户名；环境变量 GORIG_MYSQL_<%= dbEnvName %>_WRITE_USER
+      Pass: ""                  # 密码；建议使用 GORIG_MYSQL_<%= dbEnvName %>_WRITE_PASS
+      Charset: "utf8mb4"        # 连接字符集
+      SetMaxIdleConns: 10       # 最大空闲连接数
+      SetMaxOpenConns: 100      # 最大打开连接数
+      SetConnMaxLifetime: 60    # 连接最大存活时间，单位秒

package/templates/crud.router.go.ejs

@@ -0,0 +1,18 @@
+package <%= moduleName %>
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/jom-io/gorig/httpx"
+)
+
+func init() {
+	httpx.RegisterRouter(func(root *gin.RouterGroup) {
+		group := root.Group("/<%= moduleName %>")
+		group.POST("/create", CreateHTTP)
+		group.GET("/info", InfoHTTP)
+		group.GET("/list", ListHTTP)
+		group.GET("/page", PageHTTP)
+		group.POST("/update", UpdateHTTP)
+		group.DELETE("/delete", DeleteHTTP)
+	})
+}

package/templates/crud.service.go.ejs

@@ -0,0 +1,179 @@
+package <%= moduleName %>
+
+import (
+	"context"
+
+	"<%= projectName %>/domain/<%= moduleName %>/model"
+
+	"github.com/jom-io/gorig/apix/load"
+	"github.com/jom-io/gorig/domainx"
+	"github.com/jom-io/gorig/domainx/dx"
+	"github.com/jom-io/gorig/utils/errors"
+	"github.com/jom-io/gorig/utils/logger"
+	"go.uber.org/zap"
+)
+
+func init() {
+	domainx.AutoMigrate(
+		func() domainx.ConTable {
+			return dx.On[model.D](context.Background()).Complex()
+		},
+		domainx.CtIdx(domainx.Unique, "name"),
+		domainx.CtIdx(domainx.Idx, "status"),
+	)
+}
+
+func Create(ctx context.Context, req *CreateReq) (int64, *errors.Error) {
+	if err := req.Validate(); err != nil {
+		return 0, err
+	}
+
+	exists, err := dx.On[model.D](ctx).Eq("name", req.Name).Exists()
+	if err != nil {
+		logger.Error(ctx, "<%= moduleName %> duplicate check failed", zap.Error(err))
+		return 0, err
+	}
+	if exists {
+		return 0, errors.VerifyCode(409, "name already exists")
+	}
+
+	d := model.D{
+		Name:   req.Name,
+		Status: req.Status,
+		Remark: req.Remark,
+	}
+	id, err := dx.On[model.D](ctx, &d).Save()
+	if err != nil {
+		logger.Error(ctx, "<%= moduleName %> create failed", zap.Error(err))
+		return 0, err
+	}
+	logger.Info(ctx, "<%= moduleName %> created", zap.Int64("id", id), zap.String("name", req.Name))
+	return id, nil
+}
+
+func Info(ctx context.Context, id int64) (*Resp, *errors.Error) {
+	if id <= 0 {
+		return nil, errors.VerifyCode(400, "id is required")
+	}
+	item, err := dx.On[model.D](ctx).WithID(id).Get()
+	if err != nil {
+		logger.Error(ctx, "<%= moduleName %> get failed", zap.Int64("id", id), zap.Error(err))
+		return nil, err
+	}
+	if item == nil || item.IsNil() || item.Data == nil {
+		return nil, errors.VerifyCode(404, "<%= moduleName %> not found")
+	}
+	return toResp(item), nil
+}
+
+func List(ctx context.Context, req *QueryReq) ([]*Resp, *errors.Error) {
+	query, err := buildQuery(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	result, err := query.Sort("id").Find()
+	if err != nil {
+		logger.Error(ctx, "<%= moduleName %> list failed", zap.Error(err))
+		return nil, err
+	}
+	return listToResp(result), nil
+}
+
+func Page(ctx context.Context, req *QueryReq, pageReq *load.Page) (*load.PageResp, *errors.Error) {
+	if pageReq == nil {
+		pageReq = load.BuildPage(ctx, 1, 10, 0)
+	}
+	query, err := buildQuery(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	result, err := query.Sort("id").Page(pageReq.Page, pageReq.Size, pageReq.LastID)
+	if err != nil {
+		logger.Error(ctx, "<%= moduleName %> page failed", zap.Error(err))
+		return nil, err
+	}
+	resp := &load.PageResp{
+		Page:   result.Page,
+		Size:   result.Size,
+		Total:  result.Total,
+		LastID: result.LastID,
+		Result: pageToResp(result.Result),
+	}
+	return resp, nil
+}
+
+func Update(ctx context.Context, req *UpdateReq) *errors.Error {
+	fields, err := req.Updates()
+	if err != nil {
+		return err
+	}
+	if _, err = Info(ctx, req.ID); err != nil {
+		return err
+	}
+	if err = dx.On[model.D](ctx).WithID(req.ID).Updates(fields); err != nil {
+		logger.Error(ctx, "<%= moduleName %> update failed", zap.Int64("id", req.ID), zap.Error(err))
+		return err
+	}
+	logger.Info(ctx, "<%= moduleName %> updated", zap.Int64("id", req.ID))
+	return nil
+}
+
+func Delete(ctx context.Context, id int64) *errors.Error {
+	if _, err := Info(ctx, id); err != nil {
+		return err
+	}
+	if err := dx.On[model.D](ctx).WithID(id).Delete(); err != nil {
+		logger.Error(ctx, "<%= moduleName %> delete failed", zap.Int64("id", id), zap.Error(err))
+		return err
+	}
+	logger.Info(ctx, "<%= moduleName %> deleted", zap.Int64("id", id))
+	return nil
+}
+
+func buildQuery(ctx context.Context, req *QueryReq) (dx.DQuery[model.D], *errors.Error) {
+	if req == nil {
+		req = &QueryReq{}
+	}
+	if err := req.Normalize(); err != nil {
+		return nil, err
+	}
+	return dx.On[model.D](ctx).
+		NEmpty("name").
+		Like("name", req.Name).
+		Eq("status", req.Status), nil
+}
+
+func toResp(item *domainx.Complex[model.D]) *Resp {
+	if item == nil || item.Data == nil {
+		return nil
+	}
+	return &Resp{
+		ID:     item.GetID().Int64(),
+		Name:   item.Data.Name,
+		Status: item.Data.Status,
+		Remark: item.Data.Remark,
+	}
+}
+
+func listToResp(items domainx.ComplexList[model.D]) []*Resp {
+	resp := make([]*Resp, 0, len(items))
+	for _, item := range items {
+		if r := toResp(item); r != nil {
+			resp = append(resp, r)
+		}
+	}
+	return resp
+}
+
+func pageToResp(items *[]*domainx.Complex[model.D]) []*Resp {
+	if items == nil {
+		return []*Resp{}
+	}
+	resp := make([]*Resp, 0, len(*items))
+	for _, item := range *items {
+		if r := toResp(item); r != nil {
+			resp = append(resp, r)
+		}
+	}
+	return resp
+}

package/templates/crud.test.go.ejs

@@ -0,0 +1,52 @@
+package test
+
+import (
+	"testing"
+
+	"<%= projectName %>/domain/<%= moduleName %>"
+)
+
+func Test<%= ModuleName %>CreateReqValidate(t *testing.T) {
+	req := &<%= moduleName %>.CreateReq{Name: "  demo  "}
+	if err := req.Validate(); err != nil {
+		t.Fatalf("Validate failed: %v", err)
+	}
+	if req.Name != "demo" {
+		t.Fatalf("expected trimmed name, got %q", req.Name)
+	}
+	if req.Status != <%= moduleName %>.StatusEnabled {
+		t.Fatalf("expected default enabled status, got %q", req.Status)
+	}
+}
+
+func Test<%= ModuleName %>CreateReqValidateRejectsEmptyName(t *testing.T) {
+	req := &<%= moduleName %>.CreateReq{Name: " "}
+	if err := req.Validate(); err == nil {
+		t.Fatal("expected validation error")
+	}
+}
+
+func Test<%= ModuleName %>UpdateReqUpdates(t *testing.T) {
+	req := &<%= moduleName %>.UpdateReq{ID: 1, Status: <%= moduleName %>.StatusDisabled}
+	fields, err := req.Updates()
+	if err != nil {
+		t.Fatalf("Updates failed: %v", err)
+	}
+	if fields["status"] != <%= moduleName %>.StatusDisabled {
+		t.Fatalf("expected disabled status, got %#v", fields["status"])
+	}
+}
+
+func Test<%= ModuleName %>UpdateReqRejectsEmptyUpdate(t *testing.T) {
+	req := &<%= moduleName %>.UpdateReq{ID: 1}
+	if _, err := req.Updates(); err == nil {
+		t.Fatal("expected empty update error")
+	}
+}
+
+func Test<%= ModuleName %>QueryReqRejectsInvalidStatus(t *testing.T) {
+	req := &<%= moduleName %>.QueryReq{Status: "bad"}
+	if err := req.Normalize(); err == nil {
+		t.Fatal("expected invalid status error")
+	}
+}

package/templates/dto.go.ejs

@@ -0,0 +1,16 @@
+package <%= moduleName %>
+
+import "<%= projectName %>/domain/<%= moduleName %>/model"
+
+type EchoReq struct {
+	Message string `json:"message" form:"message"`
+}
+
+type InfoResp struct {
+	Item    model.D `json:"item"`
+	Message string  `json:"message"`
+}
+
+type EchoResp struct {
+	Message string `json:"message"`
+}

package/templates/gitignore.ejs

@@ -1,64 +1,33 @@
-# Binaries and other executable files
-/bin/
-/pkg/
-/vendor/
-
-# Output of the Go build process
-# If you prefer the allow list template instead of the deny list, see community template:
-# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
-#
-# Binaries for programs and plugins
+# Build output
+<%= projectName %>
+bin/
 *.exe
-*.exe~
-*.dll
-*.so
-*.dylib
 *.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
-# Dependency directories (remove the comment below to include it)
-# vendor/
+# Runtime state
+.cache/
+.logs/
+.deploy/
+tokens.json
+*.log
+*.jsonl
 
-# Ignore profile files that may be created
-cpu.out
-mem.out
-trace.out
+# Secrets and local overrides
+.env
+_bin/*.secret.yaml
+*.pem
+*.crt
+*.key
 
-# IDEs and editors
+# Editors and operating systems
 .vscode/
 .idea/
 *.swp
-*.swo
-*.swn
 *~
-
-# Operating system files
 .DS_Store
 Thumbs.db
 
-# If using dotenv for configuration, ignore the environment file
-.env
-
-
-# Ignore everything
-*.sh
-*.log
-*.jsonl
-.logs
-_bin/
-*.yaml
-*.pem
-*.crt
-/test/output/
-*.html
-*.json
-*.cache
-*.cache.json
-
-# Go workspace file
+# Go workspace files
 go.work
 go.work.sum
-
-# env file

package/templates/hello.controller.go.ejs

@@ -0,0 +1,19 @@
+package hello
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/jom-io/gorig/apix"
+	"github.com/jom-io/gorig/global/consts"
+)
+
+func Get(ctx *gin.Context) {
+	defer apix.HandlePanic(ctx)
+
+	name, err := apix.GetParamType[string](ctx, "name", apix.NotForce, "world")
+	if err != nil {
+		return
+	}
+
+	result, serviceErr := Greeting(ctx, name)
+	apix.HandleData(ctx, consts.CurdSelectFailCode, result, serviceErr)
+}

package/templates/hello.router.go.ejs

@@ -0,0 +1,12 @@
+package hello
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/jom-io/gorig/httpx"
+)
+
+func init() {
+	httpx.RegisterRouter(func(root *gin.RouterGroup) {
+		root.GET("/hello", Get)
+	})
+}

package/templates/hello.service.go.ejs

@@ -0,0 +1,31 @@
+package hello
+
+import (
+	"context"
+	"strings"
+
+	"github.com/jom-io/gorig/utils/errors"
+	"github.com/jom-io/gorig/utils/logger"
+	"<%= moduleName %>/global"
+	"go.uber.org/zap"
+)
+
+type Info struct {
+	App     string `json:"app"`
+	Mode    string `json:"mode"`
+	Message string `json:"message"`
+}
+
+func Greeting(ctx context.Context, name string) (*Info, *errors.Error) {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return nil, errors.Verify("name cannot be empty")
+	}
+
+	logger.Info(ctx, "building greeting", zap.String("name", name))
+	return &Info{
+		App:     global.SysName,
+		Mode:    global.RunMode,
+		Message: "hello " + name,
+	}, nil
+}

package/templates/hello.test.go.ejs

@@ -0,0 +1,34 @@
+package test
+
+import (
+	"context"
+	"testing"
+
+	"<%= moduleName %>/domain/hello"
+)
+
+func TestGreeting(t *testing.T) {
+	result, err := hello.Greeting(context.Background(), "Gorig")
+	if err != nil {
+		t.Fatalf("Greeting failed: %v", err)
+	}
+	if result == nil {
+		t.Fatal("expected result, got nil")
+	}
+	if result.Mode != "local" {
+		t.Fatalf("expected local mode, got %q", result.Mode)
+	}
+	if result.Message != "hello Gorig" {
+		t.Fatalf("unexpected message: %q", result.Message)
+	}
+}
+
+func TestGreetingRejectsEmptyName(t *testing.T) {
+	result, err := hello.Greeting(context.Background(), " ")
+	if err == nil {
+		t.Fatal("expected validation error")
+	}
+	if result != nil {
+		t.Fatalf("expected nil result, got %#v", result)
+	}
+}

package/templates/init.go.ejs

@@ -1,29 +1,3 @@
 package domain
 
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/jom-io/gorig/apix/response"
-	"github.com/jom-io/gorig/httpx"
-	"github.com/jom-io/gorig/serv"
-	configure "github.com/jom-io/gorig/utils/cofigure"
-	"github.com/jom-io/gorig/utils/sys"
-)
-
-func init() {
-	httpx.RegisterRouter(func(groupRouter *gin.RouterGroup) {
-		groupRouter.GET("/", func(ctx *gin.Context) {
-			response.Success(ctx, "Hello world, this is <%= projectNameUpper %> project generated by gorig-cli", nil)
-		})
-	})
-	err := serv.RegisterService(
-		serv.Service{
-			Code:     "<%= projectNameUpper %>_HTTP",
-			PORT:     configure.GetString("api.rest.addr", ":9527"),
-			Startup:  httpx.Startup,
-			Shutdown: httpx.Shutdown,
-		},
-	)
-	if err != nil {
-		sys.Exit(err)
-	}
-}
+import _ "<%= moduleName %>/domain/hello"

package/templates/main.go.ejs

@@ -1,11 +1,8 @@
 package main
 
-import (
-	"github.com/jom-io/gorig/bootstrap"
-)
+import "github.com/jom-io/gorig/bootstrap"
 
-import _ "<%= projectName %>/cron"
-import _ "<%= projectName %>/domain"
+import _ "<%= moduleName %>/domain"
 
 func main() {
 	bootstrap.StartUp()

package/templates/model.go.ejs

@@ -1,7 +1,6 @@
 package model
 
-type <%= moduleName.charAt(0).toUpperCase() + moduleName.slice(1) %>D struct {
-    UserID   int64  `gorm:"column:user_id;type:bigint(20);comment:user_id" json:"userID" form:"userID"`
-    FiledStr string `gorm:"column:fieldStr;type:varchar(255);comment:fieldStr" json:"fieldStr" form:"fieldStr"`
-    FieldInt int64  `gorm:"column:fieldInt;type:bigint(20);comment:fieldInt" json:"fieldInt" form:"fieldInt"`
+type D struct {
+	ID   string `json:"id" form:"id"`
+	Name string `json:"name" form:"name"`
 }

package/templates/project.README.md.ejs

@@ -0,0 +1,35 @@
+# <%= projectName %>
+
+Basic Gorig backend generated by `gorig-cli`.
+
+## Requirements
+
+- Go 1.23+
+- Gorig `<%= gorigVersion %>`
+
+## Run
+
+```sh
+GORIG_SYS_MODE=local go run ./_cmd
+```
+
+Environment configuration:
+
+| Mode | File | Default port |
+|---|---|---|
+| local | `_bin/local.yaml` | <%= localPort %> |
+| dev | `_bin/dev.yaml` | <%= devPort %> |
+| prod | `_bin/prod.yaml` | <%= prodPort %> |
+
+Select a configuration with `GORIG_SYS_MODE`. Override individual values with variables such as `GORIG_API_REST_ADDR`.
+
+## Verify
+
+```sh
+go fmt ./...
+go vet ./...
+go build ./...
+go test ./... -v
+curl 'http://127.0.0.1:<%= localPort %>/ping'
+curl 'http://127.0.0.1:<%= localPort %>/hello?name=Gorig'
+```

package/templates/router.go.ejs

@@ -6,13 +6,9 @@ import (
 )
 
 func init() {
-	httpx.RegisterRouter(func(groupRouter *gin.RouterGroup) {
-		<%= moduleName %> := groupRouter.Group("<%= moduleName %>")
-		//<%= moduleName %>.Use(mid.SignMP())
-		<%= moduleName %>.GET("page", Page<%= ModuleName %>)
-		<%= moduleName %>.GET("list", List<%= ModuleName %>)
-		<%= moduleName %>.POST("save", Save<%= ModuleName %>)
-		<%= moduleName %>.GET("info", Get<%= ModuleName %>)
-		<%= moduleName %>.DELETE("delete", Delete<%= ModuleName %>)
+	httpx.RegisterRouter(func(root *gin.RouterGroup) {
+		group := root.Group("/<%= moduleName %>")
+		group.GET("/info", Info)
+		group.POST("/echo", Echo)
 	})
 }