feat: full methods generation

internal/writer.go

@@ -1,12 +1,14 @@
 package internal
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"go/ast"
 	"go/parser"
 	"go/printer"
 	"go/token"
+	"html/template"
 	"log"
 	"os"
 	"path/filepath"
@@ -181,8 +183,105 @@ func MaintainImports(fileSet *token.FileSet, file *ast.File) error {
 	return nil
 }
 
-func ImplementMethods(structName string, methodName string, template string, node ast.Node) {
+func GenerateCrudMethodCode(methodName string, context CrudTemplatesContext) string {
+	templateCode, templateExists := RawTemplates[methodName]
+	if !templateExists {
+		panic(fmt.Sprintf("Template doesn't exist: %s \n", methodName))
+	}
+	var buffer bytes.Buffer
+	templateCode = "package services\n\n" + templateCode
+	tmpl, err := template.New("CrudMethodTemplate").Parse(templateCode)
+	if err != nil {
+		panic(err)
+	}
+	if err := tmpl.Execute(&buffer, context); err != nil {
+		panic(err)
+	}
+	return buffer.String()
+}
 
+func MethodCodeToDeclaration(methodCode string) (ast.FuncDecl, error) {
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "src.go", methodCode, parser.SkipObjectResolution)
+	if err != nil {
+		return ast.FuncDecl{}, err
+	}
+
+	methodDecl := ast.FuncDecl{}
+	ast.Inspect(file, func(node ast.Node) bool {
+		funcDecl, ok := node.(*ast.FuncDecl)
+		if !ok {
+			return true
+		}
+		methodDecl = *funcDecl
+		return false
+	})
+	return methodDecl, nil
+}
+
+func ImplementCrudMethods(modelName string, serviceName string, file *ast.File, reimplement bool) error {
+	templateContext := CrudTemplatesContext{
+		ServiceName:  serviceName,
+		EntityType:   modelName,
+		EntityPlural: ToPlural(modelName),
+	}
+
+	for _, methodName := range []string{CreateMethod, GetAllMethod, GetByIdMethod, UpdateMethod, CountMethod} {
+		methodCode := GenerateCrudMethodCode(methodName, templateContext)
+		methodDecl, err := MethodCodeToDeclaration(methodCode)
+		if err != nil {
+			fmt.Println(methodDecl)
+			panic(err)
+		}
+		err = ImplementMethod(file, &methodDecl, reimplement)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func ImplementMethod(file *ast.File, methodDecl *ast.FuncDecl, reimplement bool) error {
+	var decls []ast.Decl
+	methodImplemented := false
+
+	methodStructure := methodDecl.Recv.List[0].Names[0].Name
+	methodName := methodDecl.Name.Name
+	log.Printf("Standard method structure: %s\n", methodStructure)
+	log.Printf("Standard method name: %s\n", methodName)
+
+	for _, decl := range file.Decls {
+		decls = append(decls, decl)
+		funcDecl, ok := decl.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		if len(funcDecl.Recv.List) > 0 && len(funcDecl.Recv.List[0].Names) > 0 {
+			fmt.Printf("Method structure: %s\n", funcDecl.Recv.List[0].Names[0].Name)
+			fmt.Printf("Method name: %s\n", funcDecl.Name.Name)
+			if funcDecl.Recv.List[0].Names[0].Name == methodStructure {
+				if funcDecl.Name != nil && funcDecl.Name.Name == methodName {
+					if methodImplemented {
+						err := fmt.Sprintf("`%s` method redeclarated for struct `%s`", methodName, methodStructure)
+						log.Println(err)
+						return errors.New(err)
+					} else {
+						methodImplemented = true
+					}
+					if reimplement {
+						decls = decls[:1]
+					}
+				}
+			}
+		}
+	}
+
+	if reimplement || !methodImplemented {
+		file.Decls = append(decls, methodDecl)
+	}
+	
+	return nil
 }
 
 func CreateServiceFileIfNotExists(filePath string) error {
@@ -208,6 +307,7 @@ func CreateServiceFileIfNotExists(filePath string) error {
 func ImplementService(mainPkgPath string, modelName string, reimplement bool) error {
 	serviceRelativePath := fmt.Sprintf("services/%s.go", strings.ToLower(modelName))
 	filePath := filepath.Join(mainPkgPath, serviceRelativePath)
+	serviceName := modelName + "Service"
 
 	err := CreateServiceFileIfNotExists(filePath)
 	if err != nil {
@@ -225,19 +325,25 @@ func ImplementService(mainPkgPath string, modelName string, reimplement bool) er
 	if err != nil {
 		return err
 	}
+
 	ImplementModelAlias(modelName, serviceFile)
 	ImplementServiceStruct(modelName, serviceFile, reimplement)
+	err = ImplementCrudMethods(modelName, serviceName, serviceFile, reimplement)
+
+	if err != nil {
+		return err
+	}
 
 	file, err := os.Create(filePath)
 	if err != nil {
-		log.Fatalf("Error occured to open `%s` service file: %v", modelName, err)
-		return err
+		return errors.New(fmt.Sprintf("Error occured to open `%s` service file: %v", modelName, err))
 	}
 
 	err = printer.Fprint(file, fset, serviceFile)
 	if err != nil {
-		log.Fatalf("Error occurred to writing changes in `%s` service file: %v", modelName, err)
-		return err
+		return errors.New(
+			fmt.Sprintf("Error occurred to writing changes in `%s` service file: %v", modelName, err),
+		)
 	}
 
 	defer file.Close()