Update from https://github.com/cloudimpl/next-coder/commit/c1607fd6c29cd5365b44d3a00cff2ee599fe5ef5

Author: CloudimplBot

go.mod

@@ -5,6 +5,7 @@ go 1.22.0
 require (
 	github.com/fsnotify/fsnotify v1.7.0
 	gopkg.in/yaml.v2 v2.4.0
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require golang.org/x/sys v0.4.0 // indirect

go.sum

@@ -6,3 +6,5 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

lib/service-gen.go

@@ -7,6 +7,8 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
+	"gopkg.in/yaml.v3"
+	"io/fs"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -16,23 +18,30 @@ import (
 )
 
 type MethodInfo struct {
-	OriginalName string
-	Name         string
-	InputType    string
-	InputSchema  map[string]interface{}
-	OutputSchema map[string]interface{}
-	IsWorkflow   bool
-	IsService    bool
-	IsPointer    bool // Whether the input type is a pointer
+	OriginalName    string  `yaml:"originalName"`
+	Name            string  `yaml:"name"`
+	InputType       string  `yaml:"inputType"`
+	IsInputPointer  bool    `yaml:"isInputPointer"` // Whether the input type is a pointer
+	InputSchema     []Field `yaml:"inputSchema"`
+	OutputType      string  `yaml:"outputType"`
+	IsOutputPointer bool    `yaml:"isOutputPointer"` // Whether the output type is a pointer
+	OutputSchema    []Field `yaml:"outputSchema"`
+	IsWorkflow      bool    `yaml:"isWorkflow"`
+	IsService       bool    `yaml:"isService"`
 }
 
 type ServiceInfo struct {
-	ModuleName        string
-	ServiceName       string
-	ServiceStructName string
-	Methods           []MethodInfo
-	IsProduction      bool // New flag to determine if we are in production mode
-	Imports           []string
+	ModuleName        string       `yaml:"moduleName"`
+	ServiceName       string       `yaml:"serviceName"`
+	ServiceStructName string       `yaml:"serviceStructName"`
+	Methods           []MethodInfo `yaml:"methods"`
+	IsProduction      bool         // New flag to determine if we are in production mode
+	Imports           []string     `yaml:"imports"`
+}
+
+type Field struct {
+	Name string `yaml:"name"`
+	Type string `yaml:"type"`
 }
 
 const wrapperTemplate = `package _polycode
@@ -89,7 +98,7 @@ func (t *{{.ServiceStructName}}) ExecuteService(ctx polycode.ServiceContext, met
 	{{range .Methods}}{{if .IsService}}case "{{.Name}}":
 		{
 			// Pass the input correctly as a pointer or value based on the method signature
-			{{if .IsPointer}}
+			{{if .IsInputPointer}}
 			return service.{{.OriginalName}}(ctx, input.(*{{.InputType}}))
 			{{else}}
 			return service.{{.OriginalName}}(ctx, *(input.(*{{.InputType}})))
@@ -110,7 +119,7 @@ func (t *{{.ServiceStructName}}) ExecuteWorkflow(ctx polycode.WorkflowContext, m
 	{{range .Methods}}{{if .IsWorkflow}}case "{{.Name}}":
 		{
 			// Pass the input correctly as a pointer or value based on the method signature
-			{{if .IsPointer}}
+			{{if .IsInputPointer}}
 			return service.{{.OriginalName}}(ctx, input.(*{{.InputType}}))
 			{{else}}
 			return service.{{.OriginalName}}(ctx, *(input.(*{{.InputType}})))
@@ -168,8 +177,46 @@ func getModuleName(filePath string) (string, error) {
 	return "", fmt.Errorf("module name not found in go.mod")
 }
 
-func generateService(appPath string, servicePath string, moduleName string, serviceName string, prod bool) error {
-	methods, imports, err := parseDir(servicePath)
+func extractStructs(root string) (map[string][]Field, error) {
+	structDefs := make(map[string][]Field)
+	err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
+		if err != nil || d.IsDir() || !strings.HasSuffix(path, ".go") {
+			return err
+		}
+
+		fset := token.NewFileSet()
+		file, err := parser.ParseFile(fset, path, nil, parser.AllErrors)
+		if err != nil {
+			return nil
+		}
+
+		for _, decl := range file.Decls {
+			if g, ok := decl.(*ast.GenDecl); ok && g.Tok == token.TYPE {
+				for _, spec := range g.Specs {
+					if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+						if structType, ok := typeSpec.Type.(*ast.StructType); ok {
+							var fields []Field
+							for _, field := range structType.Fields.List {
+								if len(field.Names) > 0 {
+									fields = append(fields, Field{
+										Name: field.Names[0].Name,
+										Type: fmt.Sprint(field.Type),
+									})
+								}
+							}
+							structDefs[typeSpec.Name.Name] = fields
+						}
+					}
+				}
+			}
+		}
+		return nil
+	})
+	return structDefs, err
+}
+
+func generateService(appPath string, servicePath string, moduleName string, serviceName string, structDefs map[string][]Field, prod bool) error {
+	methods, imports, err := parseDir(servicePath, structDefs)
 	if err != nil {
 		fmt.Printf("Error parsing directory: %v\n", err)
 		return err
@@ -180,7 +227,18 @@ func generateService(appPath string, servicePath string, moduleName string, serv
 		return nil
 	}
 
-	generatedCode, err := generateServiceCode(moduleName, serviceName, methods, imports, prod)
+	serviceStructName := toPascalCase(serviceName)
+
+	serviceInfo := ServiceInfo{
+		ModuleName:        moduleName,
+		ServiceName:       serviceName,
+		ServiceStructName: serviceStructName,
+		Methods:           methods,
+		IsProduction:      prod,
+		Imports:           imports,
+	}
+
+	generatedCode, err := generateServiceCode(serviceInfo)
 	if err != nil {
 		fmt.Printf("Error generating code: %v\n", err)
 		return err
@@ -198,6 +256,12 @@ func generateService(appPath string, servicePath string, moduleName string, serv
 		return err
 	}
 
+	err = writeServiceDefinition(appPath, serviceName, serviceInfo)
+	if err != nil {
+		fmt.Printf("Error writing service definition: %v\n", err)
+		return err
+	}
+
 	return nil
 }
 
@@ -208,6 +272,12 @@ func GenerateServices(appPath string, prod bool) error {
 		return err
 	}
 
+	structDefs, err := extractStructs(appPath)
+	if err != nil {
+		fmt.Printf("Error extracting structs: %v\n", err)
+		return err
+	}
+
 	polycodeFolder := filepath.Join(appPath, ".polycode")
 	servicesFolder := filepath.Join(appPath, "services")
 
@@ -226,7 +296,7 @@ func GenerateServices(appPath string, prod bool) error {
 				servicePath := filepath.Join(servicesFolder, entry.Name())
 				println("Generating code for path: ", servicePath)
 				serviceName := entry.Name()
-				err = generateService(appPath, servicePath, moduleName, serviceName, prod)
+				err = generateService(appPath, servicePath, moduleName, serviceName, structDefs, prod)
 				if err != nil {
 					fmt.Printf("Error generating service: %v\n", err)
 					return err
@@ -251,7 +321,7 @@ func GenerateServices(appPath string, prod bool) error {
 	return nil
 }
 
-// Modified validateFunctionParams to check for polycode.ServiceContext or polycode.WorkflowContext
+// ValidateFunctionParams to check for polycode.ServiceContext or polycode.WorkflowContext
 func validateFunctionParams(fn *ast.FuncDecl) (string, error) {
 	// Check if there are at least two parameters (ctx and input)
 	if fn.Type.Params == nil || len(fn.Type.Params.List) < 2 {
@@ -276,7 +346,7 @@ func validateFunctionParams(fn *ast.FuncDecl) (string, error) {
 }
 
 // Updated parseDir function to mark methods as workflow or service
-func parseDir(serviceFolder string) ([]MethodInfo, []string, error) {
+func parseDir(serviceFolder string, structDefs map[string][]Field) ([]MethodInfo, []string, error) {
 	fset := token.NewFileSet()
 
 	var methods []MethodInfo
@@ -317,27 +387,42 @@ func parseDir(serviceFolder string) ([]MethodInfo, []string, error) {
 					// Extract the function name and input/output parameters
 					methodName := strings.ToLower(fn.Name.Name) // Normalize to lowercase
 
-					paramType := ""
-					isPointer := false
+					inputType := ""
+					outputType := ""
+					isInputPointer := false
+					isOutputPointer := false
 					// Handle pointer types and normal types
 					if starExpr, ok := fn.Type.Params.List[1].Type.(*ast.StarExpr); ok {
-						isPointer = true
+						isInputPointer = true
 						if selectorExpr, ok := starExpr.X.(*ast.SelectorExpr); ok {
-							paramType = fmt.Sprintf("%s.%s", selectorExpr.X.(*ast.Ident).Name, selectorExpr.Sel.Name)
+							inputType = fmt.Sprintf("%s.%s", selectorExpr.X.(*ast.Ident).Name, selectorExpr.Sel.Name)
 						}
 					} else if selectorExpr, ok := fn.Type.Params.List[1].Type.(*ast.SelectorExpr); ok {
-						paramType = fmt.Sprintf("%s.%s", selectorExpr.X.(*ast.Ident).Name, selectorExpr.Sel.Name)
+						inputType = fmt.Sprintf("%s.%s", selectorExpr.X.(*ast.Ident).Name, selectorExpr.Sel.Name)
+					}
+
+					if starExpr, ok := fn.Type.Results.List[0].Type.(*ast.StarExpr); ok {
+						isOutputPointer = true
+						if selectorExpr, ok := starExpr.X.(*ast.SelectorExpr); ok {
+							outputType = fmt.Sprintf("%s.%s", selectorExpr.X.(*ast.Ident).Name, selectorExpr.Sel.Name)
+						}
+					} else if selectorExpr, ok := fn.Type.Results.List[0].Type.(*ast.SelectorExpr); ok {
+						outputType = fmt.Sprintf("%s.%s", selectorExpr.X.(*ast.Ident).Name, selectorExpr.Sel.Name)
 					}
 
 					// Append the method and its corresponding input type to methods
-					if paramType != "" {
+					if inputType != "" && outputType != "" {
 						methods = append(methods, MethodInfo{
-							OriginalName: OriginalName,
-							Name:         methodName,
-							InputType:    paramType,
-							IsPointer:    isPointer,                 // Track whether the input type is a pointer
-							IsWorkflow:   contextType == "Workflow", // Mark as workflow or service
-							IsService:    contextType == "Service",
+							OriginalName:    OriginalName,
+							Name:            methodName,
+							InputType:       inputType,
+							IsInputPointer:  isInputPointer, // Track whether the input type is a pointer
+							InputSchema:     structDefs[inputType],
+							OutputType:      outputType,
+							IsOutputPointer: isOutputPointer,
+							OutputSchema:    structDefs[outputType],
+							IsWorkflow:      contextType == "Workflow", // Mark as workflow or service
+							IsService:       contextType == "Service",
 						})
 					}
 				}
@@ -383,19 +468,28 @@ func toPascalCase(input string) string {
 	return strings.Join(words, "")
 }
 
-// GenerateService the wrapper code based on the extracted information
-func generateServiceCode(moduleName string, serviceName string, methods []MethodInfo, imports []string, isProd bool) (string, error) {
-	serviceStructName := toPascalCase(serviceName)
+func writeServiceDefinition(appPath string, serviceName string, serviceInfo ServiceInfo) error {
+	outputDir := filepath.Join(appPath, ".polycode/definition")
+	if err := os.MkdirAll(outputDir, os.ModePerm); err != nil {
+		return err
+	}
 
-	serviceInfo := ServiceInfo{
-		ModuleName:        moduleName,
-		ServiceName:       serviceName,
-		ServiceStructName: serviceStructName,
-		Methods:           methods,
-		IsProduction:      isProd,
-		Imports:           imports,
+	ymlData, err := yaml.Marshal(serviceInfo)
+	if err != nil {
+		return err
 	}
 
+	serviceFile := filepath.Join(outputDir, serviceName+".yml")
+	if err := os.WriteFile(serviceFile, ymlData, 0644); err != nil {
+		return err
+	}
+
+	fmt.Printf("Generated definition for: %s\n", serviceFile)
+	return nil
+}
+
+// GenerateService the wrapper code based on the extracted information
+func generateServiceCode(serviceInfo ServiceInfo) (string, error) {
 	// Use template to generate the code
 	var buf bytes.Buffer
 	tmpl, err := template.New("wrapper").Parse(wrapperTemplate)

main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"flag"
+	"fmt"
 	"github.com/cloudimpl/next-gen/lib"
 	"github.com/fsnotify/fsnotify"
 	"log"
@@ -86,11 +87,13 @@ func watch(appPath string, onChange func()) {
 	<-done
 }
 
-func generate(appPath string) {
+func generate(appPath string) error {
 	err := lib.GenerateServices(appPath, true)
 	if err != nil {
-		log.Fatalf("Error generating services: %s\n", err.Error())
+		return fmt.Errorf("Error generating services: %s\n", err.Error())
 	}
+
+	return nil
 }
 
 func watchAndGenerate(appPath string) {
@@ -103,9 +106,9 @@ func watchAndGenerate(appPath string) {
 	log.Printf("Starting watcher on: %s", servicesPath)
 
 	watch(servicesPath, func() {
-		err := lib.GenerateServices(appPath, true)
+		err := generate(appPath)
 		if err != nil {
-			log.Printf("Error generating services: %v", err)
+			log.Println(err.Error())
 		}
 	})
 }
@@ -151,6 +154,9 @@ func main() {
 	if *watch {
 		watchAndGenerate(appPath)
 	} else {
-		generate(appPath)
+		err := generate(appPath)
+		if err != nil {
+			log.Fatalf(err.Error())
+		}
 	}
 }