feat: template for service

generation/scheme.go

@@ -44,7 +44,12 @@ func GenerateScheme(structName string, fields []entities.Field, mkPath string) {
 	if err != nil {
 		log.Fatalf("Failed to create file: %s", err)
 	}
-	defer schemeFile.Close()
+	defer func(schemeFile *os.File) {
+		err := schemeFile.Close()
+		if err != nil {
+			log.Fatalf("Failed to close file: %s", err)
+		}
+	}(schemeFile)
 
 	tmpl, err := template.New("scheme").Parse(SchemeTemplate)
 	if err != nil {
@@ -58,7 +63,7 @@ func GenerateScheme(structName string, fields []entities.Field, mkPath string) {
 }
 
 func processDependencies(fields []entities.Field) []Dependency {
-	dependencies := []Dependency{}
+	var dependencies []Dependency
 
 	for _, field := range fields {
 		for _, meta := range field.Metadata {

generation/service.go

@@ -1,51 +1,50 @@
 package generation
 
 import (
+	_ "embed"
 	"fmt"
 	"log"
-	"nto_cli/utils"
 	"os"
 	"strings"
+	"text/template"
 )
 
+//go:embed templates/service.tmpl
+var ServiceTemplate string
+
+type ServiceTemplateContext struct {
+	LowerModelName string
+	ModelName      string
+	ServicesPath   string
+}
+
 func GenerateService(structName, mkPath string) {
 	serviceFile, err := os.Create(mkPath + "/" + strings.ToLower(structName) + ".service.ts")
 	if err != nil {
-		panic(err)
+		log.Fatalf("Failed to create service file: %s", err)
-	}
-	defer serviceFile.Close()
-	_, err = serviceFile.WriteString(fmt.Sprintf(
-		`import { GetAll, Create, Delete, GetById, Update, Count } from "%s"
-import type { %s } from "%s"
-import type { IService } from "%s"
-
-export default class %sService implements IService<%s> {
-	async read(id: number) {
-		return await GetById(id) as %s
 	}
 
-	async readAll() {
+	defer func(serviceFile *os.File) {
-		return await GetAll() as %s[]
+		err := serviceFile.Close()
+		if err != nil {
+			log.Fatalf("Failed to close file: %s", err)
+		}
+	}(serviceFile)
+
+	context := ServiceTemplateContext{
+		LowerModelName: strings.ToLower(structName),
+		ModelName:      structName,
+		ServicesPath:   GolangServicesPath,
 	}
 
-	async create(item: %s) {
+	serviceTemplate, err := template.New("service").Parse(ServiceTemplate)
-		await Create(item)
-	}
 
-	async delete(id: number) {
-		return await Delete(id)
-	}
-
-	async update(item: %s) {
-		await Update(item)
-	}
-
-	async count() {
-		return await Count()
-	}
-}
-`, utils.GetServiceBindPath(structName), structName, GolangServicesPath, utils.GetServiceType(), structName, structName, structName, structName, structName, structName))
 	if err != nil {
-		log.Fatalf("Failed to write to file: %s", err)
+		panic(fmt.Sprintf("Failed to parse service template: %s", err))
+	}
+
+	err = serviceTemplate.Execute(serviceFile, context)
+	if err != nil {
+		log.Fatalf("Failed to execute template: %s", err)
 	}
 }

generation/templates/service.tmpl

@@ -1,27 +1,29 @@
-import { GetAll, Create, Delete, GetById, Update, Count } from "../../bindings/app/internal/services/authorservice.ts"
+import { GetAll, Create, Delete, GetById, Update, Count } from "../../bindings/app/internal/services/{{.LowerModelName}}service.ts"
-import type { Author } from "../../bindings/app/internal/services/models.ts"
+import type { {{.ModelName}} } from "{{.ServicesPath}}"
 import type { IService } from "../types/service.type.ts"
 
-export default class AuthorService implements IService<Author> {
+export default class {{.ModelName}}Service implements IService<{{.ModelName}}> {
 	async read(id: number) {
-		return await GetById(id)
+		return await GetById(id) as {{.ModelName}}
 	}
 
 	async readAll() {
-		return await GetAll() as Author[]
+		return await GetAll() as {{.ModelName}}[]
 	}
 
-	async create(item: Author) {
+	async create(item: {{.ModelName}}) {
 		await Create(item)
 	}
 
 	async delete(id: number) {
 		return await Delete(id)
 	}
-	async update(item: Author) {
+
+	async update(item: {{.ModelName}}) {
 		await Update(item)
 	}
+
 	async count() {
 		return await Count()
 	}
-}
+}

utils/imports.go

@@ -1,16 +0,0 @@
-package utils
-
-import (
-	"fmt"
-	"strings"
-)
-
-func GetServiceBindPath(structName string) string {
-	path := fmt.Sprintf("../../bindings/app/internal/services/%sservice.ts", strings.ToLower(structName))
-	return path
-}
-
-func GetServiceType() string {
-	path := "../types/service.type.ts"
-	return path
-}