feat: generate schema from template

entities/field.go

@@ -9,7 +9,7 @@ import (
 type Field struct {
 	Name     string
 	Type     string
-	Medatada []Metadata
+	Metadata []Metadata
 }
 
 var PrimitiveTypes = map[string]string{
@@ -47,7 +47,7 @@ func (f *Field) GenerateType() string {
 		result += fmt.Sprintf(`    primitive: "%s",`, PrimitiveTypes[strings.ToLower(f.Type)])
 	} else {
 		var field = "[]"
-		for _, meta := range f.Medatada {
+		for _, meta := range f.Metadata {
 			if meta.Name == "field" {
 				if len(meta.Values) > 0 {
 					field = "['" + strings.Join(meta.Values, "', '") + "']"
@@ -65,7 +65,7 @@ func (f *Field) GenerateType() string {
 
 func (f *Field) Generate() string {
 	result := "{\n"
-	for _, meta := range f.Medatada {
+	for _, meta := range f.Metadata {
 		if meta.Name == "hidden" {
 			result += "  hidden: true,\n"
 		} else if meta.Name == "label" {

generation/scheme.go

@@ -1,87 +1,78 @@
 package generation
 
 import (
+	_ "embed"
 	"fmt"
 	"log"
 	"nto_cli/entities"
-	"nto_cli/utils"
 	"os"
 	"strings"
+	"text/template"
 )
 
+//go:embed templates/scheme.tmpl
+var SchemeTemplate string
+
+const GolangServicesPath = "../../bindings/app/internal/services"
+
+type Dependency struct {
+	ImportName  string
+	ServiceName string
+	LowerName   string
+	FieldName   string
+}
+
+type TemplateData struct {
+	StructName         string
+	LowerName          string
+	GolangServicesPath string
+	Fields             []entities.Field
+	Dependencies       []Dependency
+}
+
 func GenerateScheme(structName string, fields []entities.Field, mkPath string) {
-	schemeFile, err := os.Create(mkPath + "/" + strings.ToUpper(structName[:1]) + strings.ToLower(structName[1:]) + "Scheme.vue")
+	data := TemplateData{
-	defer schemeFile.Close()
+		StructName:         structName,
+		LowerName:          strings.ToLower(structName),
+		GolangServicesPath: GolangServicesPath,
+		Fields:             fields,
+		Dependencies:       processDependencies(fields),
+	}
+
+	fileName := strings.ToUpper(structName[:1]) + strings.ToLower(structName[1:]) + "Scheme.vue"
+	schemeFile, err := os.Create(mkPath + "/" + fileName)
 	if err != nil {
 		log.Fatalf("Failed to create file: %s", err)
 	}
+	defer schemeFile.Close()
 
-	_, err = schemeFile.WriteString(fmt.Sprintf(
+	tmpl, err := template.New("scheme").Parse(SchemeTemplate)
-		`<script setup lang="ts">
-import Table from '../table/Table.vue'
-import { onMounted, reactive } from 'vue'
-import { getDefaultValues } from '../utils/structs/defaults.util'
-import S from './%s.service.ts'
-import type { Scheme } from '../types/scheme.type'
-import { %s } from '%s'
-
-const service = new S
-
-%s
-
-const scheme: Scheme<%s> = reactive(%s)
-
-const getDefaults = ()  => getDefaultValues(scheme)
-
-</script>
-
-<template>
-	<main class="w-screen h-screen">
-		<Table :scheme :service :getDefaults></Table>
-	</main>
-</template>
-`, strings.ToLower(structName), structName, utils.GetServiceStructType(structName), LoadDependencies(fields), structName, GenerateFields(fields)))
 	if err != nil {
-		log.Fatalf("Failed to write to file: %s", err)
+		panic(fmt.Sprintf("Failed to parse template: %s", err))
+	}
+
+	err = tmpl.Execute(schemeFile, data)
+	if err != nil {
+		log.Fatalf("Failed to execute template: %s", err)
 	}
 }
 
-func GenerateFields(fields []entities.Field) string {
+func processDependencies(fields []entities.Field) []Dependency {
-	result := "{\n"
+	dependencies := []Dependency{}
-	for _, field := range fields {
-		result += field.Name + ":" + field.Generate() + ", \n"
-	}
-	return result + "\n}"
-}
 
-func LoadDependencies(fields []entities.Field) string {
-	type Dependency struct {
-		fieldName      string
-		dependencyName string
-	}
-
-	result := ""
-	var dependencies []Dependency
 	for _, field := range fields {
-		for _, meta := range field.Medatada {
+		for _, meta := range field.Metadata {
 			if meta.Name == "data" {
 				dependency := meta.Values[0]
 				dependencies = append(dependencies, Dependency{
-					fieldName:      field.Name,
+					ImportName:  strings.ToUpper(dependency[:1]) + strings.ToLower(dependency[1:]) + "Service",
-					dependencyName: dependency,
+					ServiceName: strings.ToLower(dependency) + "Service",
+					LowerName:   strings.ToLower(dependency),
+					FieldName:   field.Name,
 				})
-				result += fmt.Sprintf("import %sService from '../%s/%s.service.ts'\n", dependency, strings.ToLower(dependency), strings.ToLower(dependency))
-				result += fmt.Sprintf("const %sService = new %sService\n", strings.ToLower(dependency), strings.ToUpper(dependency[:1])+strings.ToLower(dependency[1:]))
 			}
 		}
 	}
-	insertIntoScheme := ""
-	for _, dep := range dependencies {
-		insertIntoScheme += fmt.Sprintf("(scheme as any).%s.type!.nested!.values = await %sService.readAll()\n", dep.fieldName, strings.ToLower(dep.dependencyName))
-	}
 
-	result += fmt.Sprintf(`onMounted(async () => {
+	return dependencies
-  	%s
-})`+"\n", insertIntoScheme)
-	return result
 }

generation/service.go

@@ -44,7 +44,7 @@ export default class %sService implements IService<%s> {
 		return await Count()
 	}
 }
-`, utils.GetServiceBindPath(structName), structName, utils.GetServiceStructType(structName), utils.GetServiceType(), structName, structName, structName, structName, structName, structName))
+`, 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)
 	}

generation/templates/scheme.tmpl

@@ -0,0 +1,35 @@
+<script setup lang="ts">
+import Table from '../table/Table.vue'
+import { onMounted, reactive } from 'vue'
+import { getDefaultValues } from '../utils/structs/defaults.util'
+import Service from './{{.LowerName}}.service.ts'
+import type { Scheme } from '../types/scheme.type'
+import { {{.StructName}} } from '{{.GolangServicesPath}}'
+{{range .Dependencies}}
+import {{.ImportName}} from '../{{.LowerName}}/{{.LowerName}}.service.ts'
+const {{.ServiceName}} = new {{.ImportName}}
+{{end}}
+
+const service = new Service
+
+onMounted(async () => {
+	{{range .Dependencies}}
+  (scheme as any).{{.FieldName}}.type!.nested!.values = await {{.ServiceName}}.readAll()
+	{{end}}
+})
+
+const scheme: Scheme<{{.StructName}}> = reactive({
+{{range .Fields}}
+  {{.Name}}: {{.Generate}},
+{{end}}
+})
+
+const getDefaults = () => getDefaultValues(scheme)
+
+</script>
+
+<template>
+	<main class="w-screen h-screen">
+		<Table :scheme :service :getDefaults></Table>
+	</main>
+</template>

generation/templates/service.tmpl

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

utils/imports.go

@@ -10,11 +10,6 @@ func GetServiceBindPath(structName string) string {
 	return path
 }
 
-func GetServiceStructType(structName string) string {
-	path := "../../bindings/app/internal/services/models.ts"
-	return path
-}
-
 func GetServiceType() string {
 	path := "../types/service.type.ts"
 	return path

utils/split_struct_field.go

@@ -53,7 +53,7 @@ func SplitStructField(field string) (*entities.Field, error) {
 	name := data[0]
 	dataType := data[1]
 	return &entities.Field{
-		Medatada: metadata,
+		Metadata: metadata,
 		Type:     dataType,
 		Name:     name,
 	}, nil