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

Author: CloudimplBot

go.mod

@@ -5,7 +5,6 @@ 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,5 +6,3 @@ 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,8 +7,6 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
-	"gopkg.in/yaml.v3"
-	"io/fs"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -18,30 +16,23 @@ import (
 )
 
 type MethodInfo struct {
-	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"`
+	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
 }
 
 type ServiceInfo struct {
-	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"`
+	ModuleName        string
+	ServiceName       string
+	ServiceStructName string
+	Methods           []MethodInfo
+	IsProduction      bool // New flag to determine if we are in production mode
+	Imports           []string
 }
 
 const wrapperTemplate = `package _polycode
@@ -98,7 +89,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 .IsInputPointer}}
+			{{if .IsPointer}}
 			return service.{{.OriginalName}}(ctx, input.(*{{.InputType}}))
 			{{else}}
 			return service.{{.OriginalName}}(ctx, *(input.(*{{.InputType}})))
@@ -119,7 +110,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 .IsInputPointer}}
+			{{if .IsPointer}}
 			return service.{{.OriginalName}}(ctx, input.(*{{.InputType}}))
 			{{else}}
 			return service.{{.OriginalName}}(ctx, *(input.(*{{.InputType}})))
@@ -177,46 +168,8 @@ func getModuleName(filePath string) (string, error) {
 	return "", fmt.Errorf("module name not found in go.mod")
 }
 
-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)
+func generateService(appPath string, servicePath string, moduleName string, serviceName string, prod bool) error {
+	methods, imports, err := parseDir(servicePath)
 	if err != nil {
 		fmt.Printf("Error parsing directory: %v\n", err)
 		return err
@@ -227,18 +180,7 @@ func generateService(appPath string, servicePath string, moduleName string, serv
 		return nil
 	}
 
-	serviceStructName := toPascalCase(serviceName)
-
-	serviceInfo := ServiceInfo{
-		ModuleName:        moduleName,
-		ServiceName:       serviceName,
-		ServiceStructName: serviceStructName,
-		Methods:           methods,
-		IsProduction:      prod,
-		Imports:           imports,
-	}
-
-	generatedCode, err := generateServiceCode(serviceInfo)
+	generatedCode, err := generateServiceCode(moduleName, serviceName, methods, imports, prod)
 	if err != nil {
 		fmt.Printf("Error generating code: %v\n", err)
 		return err
@@ -256,12 +198,6 @@ 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
 }
 
@@ -272,12 +208,6 @@ 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")
 
@@ -296,7 +226,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, structDefs, prod)
+				err = generateService(appPath, servicePath, moduleName, serviceName, prod)
 				if err != nil {
 					fmt.Printf("Error generating service: %v\n", err)
 					return err
@@ -321,7 +251,7 @@ func GenerateServices(appPath string, prod bool) error {
 	return nil
 }
 
-// ValidateFunctionParams to check for polycode.ServiceContext or polycode.WorkflowContext
+// Modified 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 {
@@ -346,7 +276,7 @@ func validateFunctionParams(fn *ast.FuncDecl) (string, error) {
 }
 
 // Updated parseDir function to mark methods as workflow or service
-func parseDir(serviceFolder string, structDefs map[string][]Field) ([]MethodInfo, []string, error) {
+func parseDir(serviceFolder string) ([]MethodInfo, []string, error) {
 	fset := token.NewFileSet()
 
 	var methods []MethodInfo
@@ -387,42 +317,27 @@ func parseDir(serviceFolder string, structDefs map[string][]Field) ([]MethodInfo
 					// Extract the function name and input/output parameters
 					methodName := strings.ToLower(fn.Name.Name) // Normalize to lowercase
 
-					inputType := ""
-					outputType := ""
-					isInputPointer := false
-					isOutputPointer := false
+					paramType := ""
+					isPointer := false
 					// Handle pointer types and normal types
 					if starExpr, ok := fn.Type.Params.List[1].Type.(*ast.StarExpr); ok {
-						isInputPointer = true
+						isPointer = true
 						if selectorExpr, ok := starExpr.X.(*ast.SelectorExpr); ok {
-							inputType = fmt.Sprintf("%s.%s", selectorExpr.X.(*ast.Ident).Name, selectorExpr.Sel.Name)
+							paramType = 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 {
-						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)
+						paramType = fmt.Sprintf("%s.%s", selectorExpr.X.(*ast.Ident).Name, selectorExpr.Sel.Name)
 					}
 
 					// Append the method and its corresponding input type to methods
-					if inputType != "" && outputType != "" {
+					if paramType != "" {
 						methods = append(methods, MethodInfo{
-							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",
+							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",
 						})
 					}
 				}
@@ -468,28 +383,19 @@ func toPascalCase(input string) string {
 	return strings.Join(words, "")
 }
 
-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
-	}
-
-	ymlData, err := yaml.Marshal(serviceInfo)
-	if err != nil {
-		return err
-	}
+// 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)
 
-	serviceFile := filepath.Join(outputDir, serviceName+".yml")
-	if err := os.WriteFile(serviceFile, ymlData, 0644); err != nil {
-		return err
+	serviceInfo := ServiceInfo{
+		ModuleName:        moduleName,
+		ServiceName:       serviceName,
+		ServiceStructName: serviceStructName,
+		Methods:           methods,
+		IsProduction:      isProd,
+		Imports:           imports,
 	}
 
-	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,7 +2,6 @@ package main
 
 import (
 	"flag"
-	"fmt"
 	"github.com/cloudimpl/next-gen/lib"
 	"github.com/fsnotify/fsnotify"
 	"log"
@@ -87,13 +86,11 @@ func watch(appPath string, onChange func()) {
 	<-done
 }
 
-func generate(appPath string) error {
+func generate(appPath string) {
 	err := lib.GenerateServices(appPath, true)
 	if err != nil {
-		return fmt.Errorf("Error generating services: %s\n", err.Error())
+		log.Fatalf("Error generating services: %s\n", err.Error())
 	}
-
-	return nil
 }
 
 func watchAndGenerate(appPath string) {
@@ -106,9 +103,9 @@ func watchAndGenerate(appPath string) {
 	log.Printf("Starting watcher on: %s", servicesPath)
 
 	watch(servicesPath, func() {
-		err := generate(appPath)
+		err := lib.GenerateServices(appPath, true)
 		if err != nil {
-			log.Println(err.Error())
+			log.Printf("Error generating services: %v", err)
 		}
 	})
 }
@@ -154,9 +151,6 @@ func main() {
 	if *watch {
 		watchAndGenerate(appPath)
 	} else {
-		err := generate(appPath)
-		if err != nil {
-			log.Fatalf(err.Error())
-		}
+		generate(appPath)
 	}
 }