Merge pull request #1 from opbnq-q/no_panic

Gracefull shutdown

.gitignore

@@ -3,3 +3,4 @@ main.exe
 frontend
 task.py
 example
+nto_cli

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/nto-cli.iml" filepath="$PROJECT_DIR$/.idea/nto-cli.iml" />
+    </modules>
+  </component>
+</project>

.idea/nto-cli.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

cmd/input.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"fmt"
+	"log"
 	"nto_cli/utils"
 	"os"
 
@@ -16,16 +17,20 @@ func Input() (string, string) {
 }
 
 func SelectionInput() ([]string, string) {
+	if len(os.Args) == 1 {
+		log.Fatalf("Please provide path to models.go")
+	}
+
 	path := os.Args[1]
 
 	structNames := utils.GetStructList(path)
 
-	result := []string{}
+	var result []string
 
 	app := tview.NewApplication()
 
 	form := tview.NewForm()
-	checkboxes := []*tview.Checkbox{}
+	var checkboxes []*tview.Checkbox
 
 	for _, name := range structNames {
 		cb := tview.NewCheckbox().SetLabel(name)

entities/field.go

@@ -9,44 +9,44 @@ import (
 type Field struct {
 	Name     string
 	Type     string
-	Medatada []Medatada
+	Medatada []Metadata
 }
 
-var PRIMITIVE_TYPES = map[string]string{
+var PrimitiveTypes = map[string]string{
-	"date": "date",
+	"date":     "date",
-	"number": "number",
+	"number":   "number",
-	"string": "string",
+	"string":   "string",
 	"multiple": "multiple",
-	"boolean": "boolean",
+	"boolean":  "boolean",
-	"bool": "boolean",
+	"bool":     "boolean",
-	"int": "number",
+	"int":      "number",
-	"uint": "number",
+	"uint":     "number",
-	"float32": "number",
+	"float32":  "number",
-	"float64": "number",
+	"float64":  "number",
-	"int32": "number",
+	"int32":    "number",
-	"int64": "number",
+	"int64":    "number",
-	"uint32": "number",
+	"uint32":   "number",
-	"uint64": "number",
+	"uint64":   "number",
-	"int8": "number",
+	"int8":     "number",
-	"int16": "number",
+	"int16":    "number",
-	"uint8": "number",
+	"uint8":    "number",
-	"uint16": "number",
+	"uint16":   "number",
-	"byte": "number",
+	"byte":     "number",
-	"rune": "number",
+	"rune":     "number",
 }
 
 func (f *Field) GenerateType() string {
 	result := "  type: {\n"
 
-	keys := make([]string, 0, len(PRIMITIVE_TYPES))
+	keys := make([]string, 0, len(PrimitiveTypes))
-	for k := range PRIMITIVE_TYPES {
+	for k := range PrimitiveTypes {
 		keys = append(keys, k)
 	}
 
 	if slices.Contains(keys, strings.ToLower(f.Type)) {
-		result += fmt.Sprintf(`    primitive: "%s",`, PRIMITIVE_TYPES[strings.ToLower(f.Type)])
+		result += fmt.Sprintf(`    primitive: "%s",`, PrimitiveTypes[strings.ToLower(f.Type)])
 	} else {
-		var field string = "[]"
+		var field = "[]"
 		for _, meta := range f.Medatada {
 			if meta.Name == "field" {
 				if len(meta.Values) > 0 {

entities/metadata.go

@@ -4,30 +4,30 @@ import (
 	"strings"
 )
 
-type Medatada struct {
+type Metadata struct {
 	Name   string
 	Values []string
 }
 
-func NewMetadata(tag string) *Medatada {
+func NewMetadata(tag string) *Metadata {
 	tag = strings.TrimSpace(tag)
 	tagName := ""
 	var values []string
 	if strings.Contains(tag, "=") {
 		tagName = tag[:strings.Index(tag, "=")]
-		if tag[strings.Index(tag, "=") + 1] == '[' {
+		if tag[strings.Index(tag, "=")+1] == '[' {
-			values = append(values, strings.Split(tag[strings.Index(tag, "=") + 2:len(tag)-1], ";")...)
+			values = append(values, strings.Split(tag[strings.Index(tag, "=")+2:len(tag)-1], ";")...)
 			for i := range values {
 				values[i] = strings.TrimSpace(values[i])
 			}
 		} else {
-			values = append(values, strings.TrimSpace(tag[strings.Index(tag, "=") + 1:]))
+			values = append(values, strings.TrimSpace(tag[strings.Index(tag, "=")+1:]))
 		}
 	} else {
 		tagName = tag
 	}
-	return &Medatada{
+	return &Metadata{
-		Name: strings.TrimSpace(strings.ToLower(tagName)),
+		Name:   strings.TrimSpace(strings.ToLower(tagName)),
 		Values: values,
 	}
 }

generation/gen.go

@@ -2,6 +2,7 @@ package generation
 
 import (
 	"fmt"
+	"log"
 	"nto_cli/entities"
 	"nto_cli/utils"
 	"os"
@@ -9,9 +10,9 @@ import (
 )
 
 func Generate(structName string, fields []entities.Field) {
-	mkPath := fmt.Sprintf("%s/frontend/src/%s", utils.FindFrontendPath() , strings.ToLower(structName))
+	mkPath := fmt.Sprintf("%s/frontend/src/%s", utils.FindFrontendPath(), strings.ToLower(structName))
 	if err := os.Mkdir(mkPath, 0755); err != nil {
-		panic(err)
+		log.Fatalf("Failed to mkdir for model: %s", err)
 	}
 	GenerateService(structName, mkPath)
 	GenerateScheme(structName, fields, mkPath)

generation/scheme.go

@@ -2,6 +2,7 @@ package generation
 
 import (
 	"fmt"
+	"log"
 	"nto_cli/entities"
 	"nto_cli/utils"
 	"os"
@@ -10,10 +11,11 @@ import (
 
 func GenerateScheme(structName string, fields []entities.Field, mkPath string) {
 	schemeFile, err := os.Create(mkPath + "/" + strings.ToUpper(structName[:1]) + strings.ToLower(structName[1:]) + "Scheme.vue")
-	if err != nil {
-		panic(err)
-	}
 	defer schemeFile.Close()
+	if err != nil {
+		log.Fatalf("Failed to create file: %s", err)
+	}
+
 	_, err = schemeFile.WriteString(fmt.Sprintf(
 		`<script setup lang="ts">
 import Table from '../table/Table.vue'
@@ -40,7 +42,7 @@ const getDefaults = ()  => getDefaultValues(scheme)
 </template>
 `, strings.ToLower(structName), structName, utils.GetServiceStructType(structName), LoadDependencies(fields), structName, GenerateFields(fields)))
 	if err != nil {
-		panic(err)
+		log.Fatalf("Failed to write to file: %s", err)
 	}
 }
 
@@ -53,23 +55,23 @@ func GenerateFields(fields []entities.Field) string {
 }
 
 func LoadDependencies(fields []entities.Field) string {
-	type Dependency struct{
+	type Dependency struct {
-		fieldName string
+		fieldName      string
 		dependencyName string
 	}
 
 	result := ""
-	dependencies := []Dependency{}
+	var dependencies []Dependency
 	for _, field := range fields {
 		for _, meta := range field.Medatada {
 			if meta.Name == "data" {
 				dependency := meta.Values[0]
 				dependencies = append(dependencies, Dependency{
-					fieldName: field.Name,
+					fieldName:      field.Name,
 					dependencyName: dependency,
 				})
 				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:]))
+				result += fmt.Sprintf("const %sService = new %sService\n", strings.ToLower(dependency), strings.ToUpper(dependency[:1])+strings.ToLower(dependency[1:]))
 			}
 		}
 	}
@@ -80,6 +82,6 @@ func LoadDependencies(fields []entities.Field) string {
 
 	result += fmt.Sprintf(`onMounted(async () => {
   	%s
-})` + "\n", insertIntoScheme)
+})`+"\n", insertIntoScheme)
 	return result
 }

generation/service.go

@@ -2,13 +2,12 @@ package generation
 
 import (
 	"fmt"
+	"log"
 	"nto_cli/utils"
 	"os"
 	"strings"
 )
 
-
-
 func GenerateService(structName, mkPath string) {
 	serviceFile, err := os.Create(mkPath + "/" + strings.ToLower(structName) + ".service.ts")
 	if err != nil {
@@ -22,11 +21,11 @@ import type { IService } from "%s"
 	
 export default class %sService implements IService<%s> {
 	async read(id: number) {
-		return await GetById(id)
+		return await GetById(id) as %s
 	}
 
 	async readAll() {
-		return await GetAll()
+		return await GetAll() as %s[]
 	}
 
 	async create(item: %s) {
@@ -36,15 +35,17 @@ export default class %sService implements IService<%s> {
 	async delete(id: number) {
 		return await Delete(id)
 	}
+
 	async update(item: %s) {
 		await Update(item)
 	}
+
 	async count() {
 		return await Count()
 	}
 }
-`, utils.GetServiceBindPath(structName), structName, utils.GetServiceStructType(structName), utils.GetServiceType(), structName, structName, structName, structName))
+`, utils.GetServiceBindPath(structName), structName, utils.GetServiceStructType(structName), utils.GetServiceType(), structName, structName, structName, structName, structName, structName))
 	if err != nil {
-		panic(err)
+		log.Fatalf("Failed to write to file: %s", err)
 	}
 }

go.mod

@@ -1,6 +1,6 @@
 module nto_cli
 
-go 1.23.6
+go 1.22.12
 
 require (
 	github.com/fatih/structtag v1.2.0 // indirect

main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"log"
 	"nto_cli/cmd"
 	"nto_cli/generation"
 	"nto_cli/utils"
@@ -8,13 +9,13 @@ import (
 )
 
 func main() {
+	log.SetFlags(0)
 	structNames, path := cmd.SelectionInput()
 
 	for _, structName := range structNames {
 		file, err := os.Open(path)
-		defer file.Close()
 		if err != nil {
-			panic(err)
+			log.Fatalf("Failed to open file: %s", err)
 		}
 		structFields := utils.GetStructFields(file, structName)
 		generation.Generate(structName, structFields)

utils/contains_many.go

@@ -2,14 +2,14 @@ package utils
 
 import "strings"
 
-func ContainsMany(str string, substrs... string) bool {
+func ContainsMany(str string, substrings ...string) bool {
-	count := 0
+	var matches int
-	for _, substr := range substrs {
+	for _, substr := range substrings {
 		if strings.Contains(str, substr) {
-			count++;
+			matches++
 		} else {
-			return false;
+			return false
 		}
 	}
-	return count == len(substrs)
+	return matches == len(substrings)
 }

utils/find_frontend_path.go

@@ -1,45 +1,45 @@
 package utils
 
 import (
-    "errors"
+	"log"
-    "os"
+	"os"
-    "path/filepath"
+	"path/filepath"
 )
 
 func FindFrontendPath() string {
-    currentPath, err := os.Getwd()
+	currentPath, err := os.Getwd()
-    if err != nil {
+	if err != nil {
-        panic(err)
+		log.Fatalf("Failed to find path for frontend: %s", err)
-    }
+	}
 
-    var dirs []string
+	var dirs []string
-    for currentPath != filepath.VolumeName(currentPath)+string(os.PathSeparator) {
+	for currentPath != filepath.VolumeName(currentPath)+string(os.PathSeparator) {
-        dir, file := filepath.Split(currentPath)
+		dir, file := filepath.Split(currentPath)
-        if file != "" {
+		if file != "" {
-            dirs = append([]string{file}, dirs...)
+			dirs = append([]string{file}, dirs...)
-        }
+		}
-        currentPath = filepath.Clean(dir)
+		currentPath = filepath.Clean(dir)
-    }
+	}
 
-    if len(dirs) < 2 || filepath.Join(dirs[len(dirs)-2], dirs[len(dirs)-1]) != filepath.Join("frontend", "src") {
+	if len(dirs) < 2 || filepath.Join(dirs[len(dirs)-2], dirs[len(dirs)-1]) != filepath.Join("frontend", "src") {
-        panic(errors.New("You're not in frontend/src"))
+		log.Fatalf("Run this program in frontend/ directory")
-    }
+	}
 
-    var path string
+	var path string
-    for i, dir := range dirs {
+	for i, dir := range dirs {
-        if dir == "frontend" {
+		if dir == "frontend" {
-            break
+			break
-        }
+		}
-        if i > 0 {
+		if i > 0 {
-            path = filepath.Join(path, dir)
+			path = filepath.Join(path, dir)
-        } else {
+		} else {
-            path = dir
+			path = dir
-        }
+		}
-    }
+	}
 
-    if filepath.VolumeName(path) == "" {
+	if filepath.VolumeName(path) == "" {
-        path = filepath.Join(string(os.PathSeparator), path)
+		path = filepath.Join(string(os.PathSeparator), path)
-    }
+	}
 
-    return path
+	return path
 }

utils/get_struct_fields.go

@@ -2,6 +2,7 @@ package utils
 
 import (
 	"bufio"
+	"log"
 	"nto_cli/entities"
 	"os"
 	"strings"
@@ -12,7 +13,7 @@ func GetStructFields(file *os.File, structName string) []entities.Field {
 
 	structFound := false
 
-	structFields := []entities.Field{}
+	var structFields []entities.Field
 
 	scanner := bufio.NewScanner(file)
 	for i := 1; scanner.Scan() && bracketsCount > 0; i++ {
@@ -35,7 +36,7 @@ func GetStructFields(file *os.File, structName string) []entities.Field {
 	}
 
 	if err := scanner.Err(); err != nil {
-		panic(err)
+		log.Fatalf("Failed to read file with scanner: %s", err)
 	}
 	return structFields
 }

utils/get_structs_list.go

@@ -1,32 +1,36 @@
 package utils
 
 import (
-    "bufio"
+	"bufio"
-    "os"
+	"log"
-    "strings"
+	"os"
+	"strings"
 )
 
-func GetStructList(filePath string) ([]string) {
+func GetStructList(filePath string) []string {
-    file, err := os.Open(filePath)
+	file, err := os.Open(filePath)
-    if err != nil {
+	defer file.Close()
-		panic(err)
+	if err != nil {
-    }
+		log.Fatalf("Failed to open a file: %s", err)
-    defer file.Close()
+	}
-    var structNames []string
+
-    s := bufio.NewScanner(file)
+	var structNames []string
-    for s.Scan() {
+	s := bufio.NewScanner(file)
-        line := s.Text()
+	for s.Scan() {
-        if strings.Contains(line, "type ") && strings.Contains(line, " struct") {
+		line := s.Text()
-            start := strings.Index(line, "type ") + 5
+		if strings.Contains(line, "type ") && strings.Contains(line, " struct") {
-            end := strings.Index(line, " struct")
+			start := strings.Index(line, "type ") + 5
-            name := strings.TrimSpace(line[start:end])
+			end := strings.Index(line, " struct")
-            if name != "" {
+			name := strings.TrimSpace(line[start:end])
-                structNames = append(structNames, name)
+			if name != "" {
-            }
+				structNames = append(structNames, name)
-        }
+			}
-    }
+		}
-    if err := s.Err(); err != nil {
+	}
-        panic(err)
+
-    }
+	if s.Err() != nil {
-    return structNames
+		log.Fatalf("Unexpected scanner error: %s", err)
+	}
+
+	return structNames
 }

utils/split_by_single_space.go

@@ -3,12 +3,12 @@ package utils
 import "strings"
 
 func SplitBySingleSpace(input string) []string {
-    parts := strings.Split(strings.TrimSpace(input), " ")
+	parts := strings.Split(strings.TrimSpace(input), " ")
-    var result []string
+	var result []string
-    for _, p := range parts {
+	for _, p := range parts {
-        if p != "" {
+		if p != "" {
-            result = append(result, p)
+			result = append(result, p)
-        }
+		}
-    }
+	}
-    return result
+	return result
 }

utils/split_struct_field.go

@@ -2,6 +2,7 @@ package utils
 
 import (
 	"errors"
+	"log"
 	"nto_cli/entities"
 	"strings"
 
@@ -13,19 +14,21 @@ func SplitStructField(field string) (*entities.Field, error) {
 		return nil, nil
 	}
 	if len(strings.TrimSpace(field)) < 2 {
-		return nil, errors.New("End")
+		return nil, errors.New("unexpected end of struct field")
 	}
-	startBacktip := strings.Index(field, "`")
+	startBacktick := strings.Index(field, "`")
-	endBacktip := -1
+	endBacktick := -1
-	var metadata []entities.Medatada
+
-	if startBacktip > -1 {
+	var metadata []entities.Metadata
-		endBacktip = strings.Index(field[startBacktip+1:], "`")
+
-		if endBacktip > -1 {
+	if startBacktick > -1 {
-			endBacktip += startBacktip + 1
+		endBacktick = strings.Index(field[startBacktick+1:], "`")
-			meta := field[startBacktip+1 : endBacktip]
+		if endBacktick > -1 {
+			endBacktick += startBacktick + 1
+			meta := field[startBacktick+1 : endBacktick]
 			tags, err := structtag.Parse(meta)
 			if err != nil {
-				panic(err)
+				log.Fatalf("failed to parse struct tag: %s", err)
 			}
 			uiTag, err := tags.Get("ui")
 
@@ -40,9 +43,10 @@ func SplitStructField(field string) (*entities.Field, error) {
 			}
 		}
 	} else {
-		startBacktip = len(field)
+		startBacktick = len(field)
 	}
-	field = strings.TrimSpace(field[:startBacktip])
+
+	field = strings.TrimSpace(field[:startBacktick])
 
 	data := SplitBySingleSpace(field)