添加对常用 CURD 的接口生成

cli/gen_all.go

@@ -12,6 +12,7 @@ var GenAllHooks = []GenHook{
 	runGenMod,
 	runEditorconfig,
 	runGenState,
+	runGenImpl,
 }
 
 var genAllCmd = &cobra.Command{

cli/gen_impl.go

@@ -0,0 +1,27 @@
+package cli
+
+import (
+	"github.com/lazygophers/codegen/codegen"
+	"github.com/lazygophers/log"
+	"github.com/spf13/cobra"
+)
+
+var genImplCmd = &cobra.Command{
+	Use:   "impl",
+	Short: "Generate implementation files",
+	RunE:  runGenImpl,
+}
+
+var runGenImpl = func(cmd *cobra.Command, args []string) (err error) {
+	err = codegen.GenerateImpl(pb)
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	return nil
+}
+
+func init() {
+	genCmd.AddCommand(genImplCmd)
+}

codegen/generate_add_rpc.go

@@ -55,7 +55,7 @@
 			action.Roles = append(action.Roles, p.DefaultRole)
 		}
 
 		action.Roles = candy.Unique(action.Roles)
 	}
 }
 
@@ -152,16 +152,7 @@
 	}
 
 	// NOTE: 寻找主键
-	var pkField *PbNormalField
-	{
-		for _, field := range msg.normalFields {
-			// 先简单粗暴用 id 当作主键，后面再改
-			if field.Name == "id" {
-				pkField = field
-				break
-			}
-		}
-	}
+	pkField := msg.PrimaryField()
 
 	var rpcBlock string
 
@@ -170,15 +161,18 @@
 			args := map[string]interface{}{
 				"PB":          pb,
 				"Model":       opt.Model,
-				"Role":        role,
 				"Action":      action,
 				"GenTo":       opt.GenTo,
 				"ListOptions": opt.ListOptions,
 			}
 
+			if role != "" {
+				args["Role"] = role
+			}
+
 			if pkField != nil {
-				args["PprimaryKey"] = pkField.Name
-				args["PprimaryKeyType"] = pkField.Type()
+				args["PrimaryKey"] = pkField.Name
+				args["PrimaryKeyType"] = pkField.Type()
 			}
 
 			var rpcName string
@@ -217,7 +211,7 @@
 
 			// 处理 server.rpc
 			if rpc := pb.GetRPC(rpcName); rpc == nil {
-				tpl, err := GetTemplate(TemplateTypeProtoService)
+				tpl, err := GetTemplate(TemplateTypeProtoRpc)
 				if err != nil {
 					log.Errorf("err:%v", err)
 					return err

codegen/generate_impl.go

@@ -0,0 +1,176 @@
+package codegen
+
+import (
+	"github.com/lazygophers/log"
+	"github.com/lazygophers/utils/osx"
+	"github.com/pterm/pterm"
+	"io/fs"
+	"os"
+	"path/filepath"
+)
+
+func initImplDirectory(pb *PbPackage) error {
+	if osx.IsDir(GetPath(PathTypeImpl, pb)) {
+		return nil
+	}
+
+	err := os.MkdirAll(GetPath(PathTypeImpl, pb), fs.ModePerm)
+	if err != nil {
+		log.Errorf("err:%s", err)
+		return err
+	}
+
+	return nil
+}
+
+func initImplFile(pb *PbPackage, genTo string) (err error) {
+	p := filepath.Join(GetPath(PathTypeImpl, pb), genTo+".go")
+	if osx.IsFile(p) {
+		return nil
+	}
+
+	tpl, err := GetTemplate(TemplateTypeImpl)
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	file, err := os.OpenFile(p, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, fs.FileMode(0666))
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+	defer file.Close()
+
+	err = tpl.Execute(file, map[string]interface{}{
+		"PB": pb,
+	})
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	_, err = file.WriteString("\n")
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	return nil
+}
+
+func generateImpl(pb *PbPackage, rpc *PbRPC) (err error) {
+	pterm.Info.Printfln("try generate impl %s to %s", rpc.Name, rpc.genOption.GenTo)
+
+	err = initImplFile(pb, rpc.genOption.GenTo)
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	path := filepath.Join(GetPath(PathTypeImpl, pb), rpc.genOption.GenTo+".go")
+
+	log.Infof("gen impl action %s", rpc.genOption.Action)
+
+	// TODO: 缓存
+	goFile, err := ParseGoFile(path)
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	for _, goFunc := range goFile.funcs {
+		if goFunc.RecvType != "" {
+			continue
+		}
+
+		if goFunc.Name == rpc.Name {
+			pterm.Warning.Printfln("%s is exist, skip generate", rpc.Name)
+			return nil
+		}
+	}
+
+	args := map[string]any{
+		"PB":           pb,
+		"RpcName":      rpc.Name,
+		"RequestType":  rpc.rpc.RequestType,
+		"ResponseType": rpc.rpc.ReturnsType,
+	}
+
+	if rpc.genOption.Model != "" {
+		log.Infof("model:%s", rpc.genOption.Model)
+
+		args["Model"] = rpc.genOption.Model
+
+		msg := pb.GetMessage(rpc.genOption.Model)
+		if msg != nil {
+			pkField := msg.PrimaryField()
+			if pkField != nil {
+				args["PrimaryKey"] = pkField.Name
+				args["PrimaryKeyType"] = pkField.Type()
+			}
+		}
+	}
+
+	tpl, err := GetTemplate(TemplateTypeImplAction, rpc.genOption.Action)
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, fs.FileMode(0666))
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+	defer file.Close()
+
+	//_, err = file.Seek(0, io.SeekEnd)
+	//if err != nil {
+	//	log.Errorf("err:%v", err)
+	//	return err
+	//}
+
+	err = tpl.Execute(file, args)
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	_, err = file.WriteString("\n")
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	pterm.Success.Printfln("generate %s success", rpc.Name)
+
+	return nil
+}
+
+func GenerateImpl(pb *PbPackage) (err error) {
+	pterm.Info.Printfln("Generating impl directory...")
+
+	err = initImplDirectory(pb)
+	if err != nil {
+		log.Errorf("err:%v", err)
+		return err
+	}
+
+	log.Info("————————————————————分割线————————————————")
+
+	for _, rpc := range pb.RPCs() {
+		err = generateImpl(pb, rpc)
+		if err != nil {
+			log.Errorf("err:%v", err)
+			return err
+		}
+
+		log.Info(rpc.Name)
+		log.Info(rpc.options)
+		log.Info(rpc.comment)
+		log.Info(rpc.genOption)
+	}
+
+	return nil
+}

codegen/goparse.go

@@ -178,15 +178,15 @@ type GoStruct struct {
 }
 
 type GoFile struct {
-	Imports []*GoImport
-	Funcs   []*GoFunc
-	Structs []*GoStruct
+	imports []*GoImport
+	funcs   []*GoFunc
+	structs []*GoStruct
 }
 
 func (p *GoPackage) buildFuncMap() {
 	p.FuncMap = map[string]*GoFuncNode{}
 	for _, v := range p.FileMap {
-		for _, x := range v.Funcs {
+		for _, x := range v.funcs {
 			p.FuncMap[x.Name] = &GoFuncNode{
 				goFunc: x,
 				goFile: v,
@@ -370,7 +370,7 @@ func fetchImports(ctx *GoContext, f *ast.File, goFile *GoFile) {
 				goImport.Name = path.Base(goImport.Path)
 			}
 		}
-		goFile.Imports = append(goFile.Imports, goImport)
+		goFile.imports = append(goFile.imports, goImport)
 	}
 }
 func getSelectorExprIndents(ctx *GoContext, c ast.Expr, goFunc *GoFunc) []string {
@@ -621,13 +621,12 @@ func parseFuncDecl(ctx *GoContext, f *ast.FuncDecl) *GoFunc {
 }
 
 func fetchFunc(ctx *GoContext, f *ast.FuncDecl, goFile *GoFile) {
-	log.Info(f.Doc)
 	goFunc := parseFuncDecl(ctx, f)
 	if goFunc == nil {
 		return
 	}
 
-	goFile.Funcs = append(goFile.Funcs, goFunc)
+	goFile.funcs = append(goFile.funcs, goFunc)
 }
 func fetchType(ctx *GoContext, ts *ast.TypeSpec, goFile *GoFile) {
 	if ts.Type == nil {
@@ -642,7 +641,7 @@ func fetchType(ctx *GoContext, ts *ast.TypeSpec, goFile *GoFile) {
 	}
 	switch ts.Type.(type) {
 	case *ast.StructType:
-		goFile.Structs = append(goFile.Structs, &GoStruct{
+		goFile.structs = append(goFile.structs, &GoStruct{
 			Name: name,
 		})
 	}
@@ -800,7 +799,7 @@ func (p *ScanErrCodeContext) Scan(mod, name string) {
 			// 找下这个模块的 path
 			goFile := node.goFile
 			var impPath string
-			for _, x := range goFile.Imports {
+			for _, x := range goFile.imports {
 				if x.Name == callMod {
 					impPath = x.Path
 					break

codegen/path.go

@@ -14,11 +14,14 @@ const (
 	PathTypeTableField
 
 	PathTypeInternal
+
 	PathTypeState
 	PathTypeStateTable
 	PathTypeStateConf
 	PathTypeStateCache
 	PathTypeStateState
+
+	PathTypeImpl
 )
 
 func GetPath(t PathType, pb *PbPackage) string {
@@ -59,6 +62,9 @@ func GetPath(t PathType, pb *PbPackage) string {
 	case PathTypeStateState:
 		return filepath.Join(GetPath(PathTypeState, pb), "state.go")
 
+	case PathTypeImpl:
+		return filepath.Join(GetPath(PathTypeInternal, pb), "impl")
+
 	default:
 		panic("unsupported path type")
 	}