feat: add proto generation and mapper functionality

- Introduced `gen.go` for generating protobuf files from entity schemas.
- Implemented `graph.go` to manage entity graph loading and annotations.
- Created `converter.go` for converting between entity and protobuf types.
- Developed `generator.go` to handle the generation of mapper code.
- Added `mapper.tmpl` for templating the generated mapper code.
- Enhanced support for various field types and conversions in protobuf.
- Implemented utility functions for handling protobuf packages and imports.

Author: tbxark

cmd/entproto.go

@@ -1,52 +1,103 @@
 package cmd
 
 import (
-	"github.com/go-sphere/sphere-cli/internal/entproto"
+	"github.com/go-sphere/sphere-cli/internal/entity"
+	"github.com/go-sphere/sphere-cli/internal/entity/graph"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
+type EntSharedOptions struct {
+	SchemaPath string
+
+	AllFieldsRequired bool
+	AutoAddAnnotation bool
+	EnumUseRawType    bool
+	SkipUnsupported   bool
+
+	TimeProtoType        string
+	UUIDProtoType        string
+	UnsupportedProtoType string
+
+	ProtoPackages string
+}
+
+func (o *EntSharedOptions) AddFlags(fs *pflag.FlagSet) {
+	fs.StringVar(&o.SchemaPath, "path", "./schema", "path to schema directory")
+
+	fs.StringVar(&o.TimeProtoType, "time_proto_type", "int64", "use proto type for time.Time, one of int64, string, google.protobuf.Timestamp")
+	fs.StringVar(&o.UUIDProtoType, "uuid_proto_type", "string", "use proto type for uuid.UUID, one of string, bytes")
+	fs.StringVar(&o.UnsupportedProtoType, "unsupported_proto_type", "google.protobuf.Any", "use proto type for unsupported types, one of google.protobuf.Any, google.protobuf.Struct, bytes")
+
+	fs.BoolVar(&o.AllFieldsRequired, "all_fields_required", true, "ignore optional, use zero value instead")
+	fs.BoolVar(&o.AutoAddAnnotation, "auto_annotation", true, "auto add annotation to the schema")
+	fs.BoolVar(&o.EnumUseRawType, "enum_raw_type", true, "use string for enum")
+	fs.BoolVar(&o.SkipUnsupported, "skip_unsupported", true, "skip unsupported types, when unsupportedProtoType is not set")
+
+	fs.StringVar(&o.ProtoPackages, "import_proto", "google/protobuf/any.proto,google.protobuf,Any;", "import proto, format: path1,package1,type1,type2;path2,package2,type3,type4;")
+}
+
+func (o *EntSharedOptions) ToGraphOptions() *graph.Options {
+	return &graph.Options{
+		SchemaPath:           o.SchemaPath,
+		AllFieldsRequired:    o.AllFieldsRequired,
+		AutoAddAnnotation:    o.AutoAddAnnotation,
+		EnumUseRawType:       o.EnumUseRawType,
+		SkipUnsupported:      o.SkipUnsupported,
+		TimeProtoType:        o.TimeProtoType,
+		UUIDProtoType:        o.UUIDProtoType,
+		UnsupportedProtoType: o.UnsupportedProtoType,
+	}
+}
+
 var ent2protoCmd = &cobra.Command{
 	Use:     "entproto",
 	Aliases: []string{"ent2proto"},
 	Short:   "Convert Ent schema to Protobuf definitions",
 	Long:    `Convert Ent schema to Protobuf definitions, generating .proto files from Ent schema definitions.`,
 }
 
+var ent2mapperCmd = &cobra.Command{
+	Use:     "entmapper",
+	Aliases: []string{"ent2mapper"},
+	Short:   "Convert Ent schema to Ent mapper",
+	Long:    `Convert Ent schema to Ent mapper, generating mapper files from Ent schema definitions.`,
+}
+
 func init() {
+	shareOptions := &EntSharedOptions{}
+	shareOptions.AddFlags(ent2protoCmd.Flags())
+	shareOptions.AddFlags(ent2mapperCmd.Flags())
 	rootCmd.AddCommand(ent2protoCmd)
+	rootCmd.AddCommand(ent2mapperCmd)
 
-	flag := ent2protoCmd.Flags()
-	schemaPath := flag.String("path", "./schema", "path to schema directory")
-	protoDir := flag.String("proto", "./proto", "path to proto directory")
-
-	timeProtoType := flag.String("time_proto_type", "int64", "use proto type for time.Time, one of int64, string, google.protobuf.Timestamp")
-	uuidProtoType := flag.String("uuid_proto_type", "string", "use proto type for uuid.UUID, one of string, bytes")
-	unsupportedProtoType := flag.String("unsupported_proto_type", "google.protobuf.Any", "use proto type for unsupported types, one of google.protobuf.Any, google.protobuf.Struct, bytes")
-
-	allFieldsRequired := flag.Bool("all_fields_required", true, "ignore optional, use zero value instead")
-	autoAddAnnotation := flag.Bool("auto_annotation", true, "auto add annotation to the schema")
-	enumUseRawType := flag.Bool("enum_raw_type", true, "use string for enum")
-	skipUnsupported := flag.Bool("skip_unsupported", true, "skip unsupported types, when unsupportedProtoType is not set")
-
-	importProto := flag.String("import_proto", "google/protobuf/any.proto,google.protobuf,Any;", "import proto, format: path1,package1,type1,type2;path2,package2,type3,type4;")
-
-	ent2protoCmd.RunE = func(cmd *cobra.Command, args []string) error {
-		options := entproto.Options{
-			SchemaPath: *schemaPath,
-			ProtoDir:   *protoDir,
-
-			TimeProtoType:        *timeProtoType,
-			UUIDProtoType:        *uuidProtoType,
-			UnsupportedProtoType: *unsupportedProtoType,
-			SkipUnsupported:      *skipUnsupported,
-
-			AllFieldsRequired: *allFieldsRequired,
-			AutoAddAnnotation: *autoAddAnnotation,
-			EnumUseRawType:    *enumUseRawType,
+	{
+		flag := ent2protoCmd.Flags()
+		protoDir := flag.String("proto", "./proto", "path to proto directory")
+		ent2protoCmd.RunE = func(cmd *cobra.Command, args []string) error {
+			return entity.GenerateProto(&entity.ProtoOptions{
+				Graph:    shareOptions.ToGraphOptions(),
+				ProtoDir: *protoDir,
+			})
+		}
 
-			ProtoPackages: entproto.ParseProtoPackages(*importProto),
+	}
+	{
+		flag := ent2mapperCmd.Flags()
+		mapperDir := flag.String("mapper", "./mapper", "path to mapper directory")
+		mapperPackage := flag.String("mapper_package", "mapper", "package name for the generated mapper code")
+		entPackage := flag.String("ent_package", "ent", "package name for the ent code")
+		protoPkgPath := flag.String("proto_pkg_path", "github.com/go-sphere/sphere-layout/proto", "go module path for the generated proto code")
+		protoPkgName := flag.String("proto_pkg_name", "proto", "package name for the generated proto code")
+		ent2mapperCmd.RunE = func(cmd *cobra.Command, args []string) error {
+			return entity.GenerateMapper(&entity.MapperOptions{
+				Graph:         shareOptions.ToGraphOptions(),
+				MapperDir:     *mapperDir,
+				MapperPackage: *mapperPackage,
+				EntPackage:    *entPackage,
+				ProtoPkgPath:  *protoPkgPath,
+				ProtoPkgName:  *protoPkgName,
+			})
 		}
-		entproto.Generate(&options)
-		return nil
 	}
 }

internal/entity/gen.go

@@ -0,0 +1,141 @@
+package entity
+
+import (
+	"errors"
+	"fmt"
+	"go/format"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+
+	"entgo.io/contrib/entproto"
+	"entgo.io/ent/entc/gen"
+	"github.com/go-sphere/sphere-cli/internal/entity/graph"
+	"github.com/go-sphere/sphere-cli/internal/entity/mapper"
+	"github.com/jhump/protoreflect/desc"
+	"github.com/jhump/protoreflect/desc/protoprint"
+)
+
+type ProtoOptions struct {
+	Graph    *graph.Options
+	ProtoDir string
+}
+
+func GenerateProto(options *ProtoOptions) error {
+	gh, err := graph.LoadGraph(options.Graph)
+	if err != nil {
+		return err
+	}
+	err = generateProto(gh, options)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func generateProto(g *gen.Graph, options *ProtoOptions) error {
+	entProtoDir := path.Join(g.Target, "proto")
+	if options.ProtoDir != "" {
+		entProtoDir = options.ProtoDir
+	}
+	adapter, err := entproto.LoadAdapter(g)
+	if err != nil {
+		return fmt.Errorf("entproto: failed parsing entity graph: %w", err)
+	}
+	var errs []error
+	for _, schema := range g.Schemas {
+		name := schema.Name
+		_, sErr := adapter.GetFileDescriptor(name)
+		if sErr != nil && !errors.Is(sErr, entproto.ErrSchemaSkipped) {
+			errs = append(errs, sErr)
+		}
+	}
+	if len(errs) > 0 {
+		return fmt.Errorf("entproto: failed parsing some schemas: %w", errors.Join(errs...))
+	}
+	allDescriptors := make([]*desc.FileDescriptor, 0, len(adapter.AllFileDescriptors()))
+	for _, fDesc := range adapter.AllFileDescriptors() {
+		graph.FixProto3Optional(g, fDesc)
+		allDescriptors = append(allDescriptors, fDesc)
+	}
+	var printer protoprint.Printer
+	printer.Compact = true
+	if err = printer.PrintProtosToFileSystem(allDescriptors, entProtoDir); err != nil {
+		return fmt.Errorf("entproto: failed writing .proto files: %w", err)
+	}
+	return nil
+}
+
+type MapperOptions struct {
+	Graph         *graph.Options
+	MapperDir     string
+	MapperPackage string
+	EntPackage    string
+	ProtoPkgPath  string
+	ProtoPkgName  string
+}
+
+func GenerateMapper(options *MapperOptions) error {
+	gh, err := graph.LoadGraph(options.Graph)
+	if err != nil {
+		return err
+	}
+	err = generateMappers(gh, options)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func generateMappers(graph *gen.Graph, options *MapperOptions) error {
+	adapter, err := entproto.LoadAdapter(graph)
+	if err != nil {
+		return fmt.Errorf("entproto: failed loading adapter: %w", err)
+	}
+	_ = os.RemoveAll(options.MapperDir)
+	err = os.MkdirAll(options.MapperDir, 0755)
+	if err != nil {
+		return fmt.Errorf("entproto: failed creating entmapper dir: %w", err)
+	}
+	for _, node := range graph.Nodes {
+		msgDesc, nErr := adapter.GetMessageDescriptor(node.Name)
+		if nErr != nil {
+			continue
+		}
+		fileDesc := msgDesc.GetFile()
+		g, nErr := mapper.NewGenerator(fileDesc, graph, adapter, node, msgDesc)
+		if nErr != nil {
+			return nErr
+		}
+
+		if options.EntPackage != "" {
+			g.EntPackage = mapper.GoImportPath(options.EntPackage)
+		}
+		if options.ProtoPkgPath != "" {
+			g.ProtoImportPath = mapper.GoImportPath(options.ProtoPkgPath)
+		}
+		if options.MapperPackage != "" {
+			g.PackageName = options.MapperPackage
+		}
+		if options.ProtoPkgName != "" {
+			g.ProtoPackageName = options.ProtoPkgName
+		}
+		content, nErr := g.Generate()
+		if nErr != nil {
+			return nErr
+		}
+		formatted, fmtErr := format.Source(content)
+		if fmtErr != nil {
+			return fmt.Errorf("entproto: format entmapper for %s: %w", node.Name, fmtErr)
+		}
+		fileName := gen.Funcs["snake"].(func(string) string)(node.Name) + ".go"
+		outPath := filepath.Join(options.MapperDir, fileName)
+		log.Printf("entproto: generating entmapper for %s to %s", node.Name, outPath)
+		nErr = os.WriteFile(outPath, formatted, 0644)
+		if nErr != nil {
+			return nErr
+		}
+	}
+	return nil
+}

internal/entproto/gen.go internal/entity/graph/graph.gointernal/entproto/gen.go renamed to internal/entity/graph/graph.go

@@ -1,10 +1,8 @@
-package entproto
+package graph
 
 import (
-	"errors"
 	"fmt"
 	"log"
-	"path"
 	"reflect"
 	"sort"
 	"strings"
@@ -16,13 +14,11 @@ import (
 	"entgo.io/ent/schema/field"
 	"github.com/go-viper/mapstructure/v2"
 	"github.com/jhump/protoreflect/desc" //nolint
-	"github.com/jhump/protoreflect/desc/protoprint"
 	"google.golang.org/protobuf/types/descriptorpb"
 )
 
 type Options struct {
 	SchemaPath string
-	ProtoDir   string
 
 	AllFieldsRequired bool
 	AutoAddAnnotation bool
@@ -42,56 +38,20 @@ type ProtoPackage struct {
 	Types []string
 }
 
-func Generate(options *Options) {
+func LoadGraph(options *Options) (*gen.Graph, error) {
 	injectProtoPackages(options.ProtoPackages)
 	graph, err := entc.LoadGraph(options.SchemaPath, &gen.Config{
 		Target: options.SchemaPath,
 	})
 	if err != nil {
-		log.Fatalf("entproto: failed loading ent graph: %v", err)
+		log.Fatalf("entproto: failed loading entity graph: %v", err)
 	}
 	if options.AutoAddAnnotation {
 		for i := 0; i < len(graph.Nodes); i++ {
 			addAnnotationForNode(graph.Nodes[i], options)
 		}
 	}
-	err = generate(graph, options)
-	if err != nil {
-		log.Fatalf("entproto: failed generating protos: %s", err)
-	}
-}
-
-func generate(g *gen.Graph, options *Options) error {
-	entProtoDir := path.Join(g.Target, "proto")
-	if options.ProtoDir != "" {
-		entProtoDir = options.ProtoDir
-	}
-	adapter, err := entproto.LoadAdapter(g)
-	if err != nil {
-		return fmt.Errorf("entproto: failed parsing ent graph: %w", err)
-	}
-	var errs []error
-	for _, schema := range g.Schemas {
-		name := schema.Name
-		_, sErr := adapter.GetFileDescriptor(name)
-		if sErr != nil && !errors.Is(sErr, entproto.ErrSchemaSkipped) {
-			errs = append(errs, sErr)
-		}
-	}
-	if len(errs) > 0 {
-		return fmt.Errorf("entproto: failed parsing some schemas: %w", errors.Join(errs...))
-	}
-	allDescriptors := make([]*desc.FileDescriptor, 0, len(adapter.AllFileDescriptors()))
-	for _, fDesc := range adapter.AllFileDescriptors() {
-		fixProto3Optional(g, fDesc)
-		allDescriptors = append(allDescriptors, fDesc)
-	}
-	var printer protoprint.Printer
-	printer.Compact = true
-	if err = printer.PrintProtosToFileSystem(allDescriptors, entProtoDir); err != nil {
-		return fmt.Errorf("entproto: failed writing .proto files: %w", err)
-	}
-	return nil
+	return graph, err
 }
 
 func addAnnotationForNode(node *gen.Type, options *Options) {
@@ -239,7 +199,7 @@ var (
 	optionalFieldLabel    = descriptorpb.FieldDescriptorProto_LABEL_OPTIONAL
 )
 
-func fixProto3Optional(g *gen.Graph, fDesc *desc.FileDescriptor) {
+func FixProto3Optional(g *gen.Graph, fDesc *desc.FileDescriptor) {
 	messageMap := make(map[string]*desc.MessageDescriptor)
 	for _, message := range fDesc.GetMessageTypes() {
 		messageMap[message.GetName()] = message