Merge pull request #76 from samueldasilvadev/update-fork

chore(multi-tenant): creating multi tenant stubs

Author: samueldasilvadev

cmd/cli/cli/cli.go

@@ -20,6 +20,7 @@ func NewCli(cmd *cobra.Command) *Cli {
 func (c *Cli) Start() {
 	generatorInstance := generator.NewGenerator()
 	generatorInstance.DeclareCommands(c.Cmd)
+	generatorInstance.DeclareDomainCreatorFromSchema(c.Cmd)
 	migratorInstance := migrator.NewMigrator()
 	migratorInstance.DeclareCommands(c.Cmd)
 }

cmd/cli/migrator/migrator.go

@@ -36,8 +36,8 @@ func (m *Migrator) DeclareCommands(cmd *cobra.Command) {
 		},
 		&cobra.Command{
 			Use:    "generate-schema-from-db",
-			Short:  "generate-schema-from-db <schema name>",
-			Long:   "generate HCL schema from database connected on env",
+			Short:  "generate-schema-from-db <schema name> <database name>",
+			Long:   "generate HCL schema from connection on env \ngenerate all databases if <database name> is not provided (all databases generations does`nt work with domain generation from schema)",
 			PreRun: m.BootMigrator,
 			Run:    m.Generate,
 		},
@@ -60,11 +60,15 @@ func (m *Migrator) Inspect(_ *cobra.Command, _ []string) {
 
 func (m *Migrator) Generate(_ *cobra.Command, args []string) {
 	schema := ""
+	if len(args) > 0 {
+		schema = args[0]
+	}
+	databaseName := ""
 	if len(args) > 1 {
-		schema = args[1]
+		databaseName = args[1]
 	}
 	migratorInstance := migrator.NewMigrator(m.dsn, m.dsnTest, m.database)
-	migratorInstance.Generate(schema)
+	migratorInstance.Generate(schema, databaseName)
 }
 
 func (m *Migrator) BootMigrator(_ *cobra.Command, _ []string) {

internal/application/services/dummy/GET/service.go

@@ -25,14 +25,14 @@ func (s *Service) Execute(request Request) {
 		s.BadRequest(err.Error())
 		return
 	}
-	s.produceResponseRule(request.Data, request.Client, request.Domain)
+	s.produceResponseRule(request.Data, request.Domain)
 }
 
 func (s *Service) GetResponse() (*Response, *services.Error) {
 	return s.response, s.Error
 }
 
-func (s *Service) produceResponseRule(data *Data, client string, domain *dummy.Dummy) {
+func (s *Service) produceResponseRule(data *Data, domain *dummy.Dummy) {
 	dummyData, err := s.repository.Get(*domain, "id", data.ID)
 
 	if err != nil {

schemas/schema.my.hcl

@@ -1,5 +1,5 @@
 table "dummy" {
-  schema = schema.skeleton
+  schema = schema.zord
   column "id" {
     null = false
     type = char(26)
@@ -16,15 +16,7 @@ table "dummy" {
     columns = [column.id]
   }
 }
-
-//{{newTable}}
-
-variable "database" {
-  type = string
-}
-
-schema "skeleton" {
-  name = var.database
+schema "zord" {
   charset = "utf8mb4"
   collate = "utf8mb4_0900_ai_ci"
 }

tools/generator/config.toml

@@ -39,13 +39,15 @@ table "{{domain}}" {
 $repeat$"""
 "{{domainType}}" = """type {{domainPascalCase}} struct {
   ID   string `db:"id"`
+  client    string
+  filters   *filters.Filters
 }"""
 "{{pkType}}" = "ID string `param:\"id\"`"
 "{{pkName}}" = "ID"
 "{{pkDbName}}" = "id"
 "{{dataType}}" = ""
-"{{createServiceData}}" = "ID:   s.idCreator.Create(),"
-"{{editServiceData}}" = "ID:        id,"
+"{{createServiceData}}" = ""
+"{{editServiceData}}" = ""
 "{{optionalImports}}" = ""
 "{{idVar}}" = ""
 
@@ -101,7 +103,7 @@ deleteLinePatterns = [
 ]
 
 [stubs.crud.migrator_schema]
-toPath = "tools/migrator/schema/schema.my.hcl"
+toPath = "schemas/schema.my.hcl"
 isGenerated = false
 deleteRegex = "(?s)table \"{{domain}}\" {\\s*.*?\\s*}\n*//tableEnd\n\n"
 

tools/generator/generateFromDb.go

@@ -27,7 +27,7 @@ func (cg *CodeGenerator) ReadFromSchema(schema string, table string) {
 }
 
 func (cg *CodeGenerator) getHclFile(schema string) (*hclwrite.File, error) {
-	filepath := fmt.Sprintf("tools/migrator/schema/%s.my.hcl", schema)
+	filepath := fmt.Sprintf("schemas/%s.my.hcl", schema)
 	content, err := os.ReadFile(filepath)
 	if err != nil {
 		fmt.Println("Error reading file:", err)
@@ -45,7 +45,7 @@ func (cg *CodeGenerator) handleHclBlock(block *hclwrite.Block) error {
 		return nil
 	}
 
-	tableName := block.Labels()[0]
+	tableName := CamelCase(block.Labels()[0])
 	replacers := cg.generateDomainFromHclBlock(block, tableName)
 	validateErr := cg.validateFiles(tableName)
 	if validateErr != nil {
@@ -65,21 +65,21 @@ func (cg *CodeGenerator) generateDomainFromHclBlock(block *hclwrite.Block, table
 	*cg.isIntId = false
 	domain := cg.generateDomainStruct(block.Body().Blocks(), tableName, cg.primaryKey, cg.pkType)
 	dataType := cg.generateStruct(block.Body().Blocks(), nil, nil, cg.generateDeclarationLine)
-	createAttrData := cg.generateStruct(block.Body().Blocks(), nil, nil, cg.generateCreateAttributionLine)
-	editAttrData := cg.generateStruct(block.Body().Blocks(), nil, nil, cg.generateEditAttributionLine)
+	createAttrData := cg.generateStruct(block.Body().Blocks(), nil, nil, cg.generateAttributionLine)
+	editAttrData := cg.generateStruct(block.Body().Blocks(), nil, nil, cg.generateAttributionLine)
 	replacers := GetReplacersConfig(cg.config, cg.domainType, []string{tableName})
 	replacers["{{domainType}}"] = domain
 	replacers["{{dataType}}"] = dataType
 	replacers["{{pkDbName}}"] = *cg.primaryKey
-	replacers["{{pkName}}"] = PascalCase(*cg.primaryKey)
+	replacers["{{pkName}}"] = *cg.primaryKey
 	replacers["{{pkType}}"] = *cg.pkType
 	replacers["{{createServiceData}}"] = createAttrData
 	replacers["{{editServiceData}}"] = editAttrData
 	if *cg.needImportTime {
 		replacers["{{optionalImports}}"] = "\"time\""
 	}
 	if !*cg.isIntId {
-		replacers["{{idVar}}"] = "id := s.idCreator.Create()"
+		replacers["{{idVar}}"] = "domain." + PascalCase(*cg.primaryKey) + " = s.idCreator.Create()"
 	}
 	return replacers
 }
@@ -88,12 +88,13 @@ func (cg *CodeGenerator) generateDomainStruct(blocks []*hclwrite.Block, tableNam
 	*pk = cg.findPkOnBlocks(blocks)
 	structString := "type " + PascalCase(tableName) + " struct {\n"
 	structString += cg.generateStruct(blocks, pk, pkType, cg.generateDeclarationLine)
+	structString += "\tclient string\n\tfilters *filters.Filters\n"
 	structString += "}"
 	return structString
 }
 
 func (cg *CodeGenerator) generateStruct(blocks []*hclwrite.Block, pk, pkType *string, strFormationFunc func(string, string, string, string) string) string {
-	declarationString := "\n"
+	declarationString := ""
 	for _, block := range blocks {
 		if block.Type() == "column" {
 			token, ok := block.Body().Attributes()["type"]
@@ -102,9 +103,14 @@ func (cg *CodeGenerator) generateStruct(blocks []*hclwrite.Block, pk, pkType *st
 			}
 			tokenStr := string(token.Expr().BuildTokens(nil).Bytes())
 			goType := cg.dbTypesToGoTypes(tokenStr)
+			nullable, nullOk := block.Body().Attributes()["null"]
+			isNullable := cg.verifyIsNullable(nullable, nullOk)
+			if isNullable {
+				goType = "*" + goType
+			}
 
 			if pk != nil && block.Labels()[0] == *pk {
-				*pkType = fmt.Sprintf("%s string `param:\"id\"`", PascalCase(*pk))
+				*pkType = fmt.Sprintf("%s string `param:\"id\"`\n", PascalCase(*pk))
 			}
 
 			declarationString = strFormationFunc(
@@ -137,39 +143,12 @@ func (cg *CodeGenerator) generateDeclarationLine(str, name, goType, dbTag string
 	)
 }
 
-func (cg *CodeGenerator) generateCreateAttributionLine(str, name, goType, _ string) string {
+func (cg *CodeGenerator) generateAttributionLine(str, name, _, _ string) string {
 	if name == PascalCase(*cg.primaryKey) {
-		if strings.Contains(goType, "int") {
-			*cg.isIntId = true
-			return str
-		}
-		return fmt.Sprintf(
-			"%s	%s: &id,\n",
-			str,
-			name,
-		)
+		return str
 	}
 	return fmt.Sprintf(
-		"%s	%s: data.%s,\n",
-		str,
-		name,
-		name,
-	)
-}
-
-func (cg *CodeGenerator) generateEditAttributionLine(str, name, goType, _ string) string {
-	if name == PascalCase(*cg.primaryKey) {
-		if strings.Contains(goType, "int") {
-			return str
-		}
-		return fmt.Sprintf(
-			"%s	%s: &id,\n",
-			str,
-			name,
-		)
-	}
-	return fmt.Sprintf(
-		"%s	%s: data.%s,\n",
+		"%s	domain.%s = data.%s\n",
 		str,
 		name,
 		name,
@@ -188,7 +167,7 @@ func (cg *CodeGenerator) findPkOnBlocks(blocks []*hclwrite.Block) string {
 			str = cg.getColumnFromAttrString(pkAttr)
 		}
 	}
-	return str
+	return PascalCase(str)
 }
 
 func (cg *CodeGenerator) getColumnFromAttrString(attrStr string) string {
@@ -200,52 +179,63 @@ func (cg *CodeGenerator) getColumnFromAttrString(attrStr string) string {
 
 func (cg *CodeGenerator) dbTypesToGoTypes(typo string) string {
 	dbTypesMap := map[string]string{
-		" bigint":     "*int64",
-		" bit":        "* ",
-		" char":       "*string",
-		" decimal":    "*float64",
-		" float":      "*float32",
-		" double":     "*float64",
-		" int":        "*int",
-		" longtext":   "*string",
-		" mediumint":  "*int",
-		" mediumtext": "*string",
-		" smallint":   "*int16",
-		" text":       "*string",
-		" time":       "*string",
-		" timestamp":  "*string",
-		" datetime":   "*time.Time",
-		" date":       "*string",
-		" tinyint":    "*int8",
-		" tinytext":   "*string",
-		" varbinary":  "*string",
-		" varchar":    "*string",
-		" json":       "*string",
+		" bigint":     "int64",
+		" bit":        " ",
+		" char":       "string",
+		" decimal":    "float64",
+		" float":      "float32",
+		" double":     "float64",
+		" int":        "int",
+		" longtext":   "string",
+		" mediumint":  "int",
+		" mediumtext": "string",
+		" smallint":   "int16",
+		" text":       "string",
+		" time":       "string",
+		" timestamp":  "string",
+		" datetime":   "time.Time",
+		" date":       "string",
+		" tinyint":    "int8",
+		" tinytext":   "string",
+		" varbinary":  "string",
+		" varchar":    "string",
+		" json":       "string",
 	}
 
 	GolangType, ok := dbTypesMap[typo]
 	if ok {
-		if GolangType == "*time.Time" {
+		if GolangType == "time.Time" {
 			*cg.needImportTime = true
 		}
 		return GolangType
 	}
 
 	if strings.Contains(typo, "char") {
-		return "*string"
+		return "string"
 	}
 
 	if strings.Contains(typo, "double") {
-		return "*float64"
+		return "float64"
 	}
 
 	if strings.Contains(typo, "year") {
-		return "*string"
+		return "string"
 	}
 
 	if strings.Contains(typo, "decimal") {
-		return "*float64"
+		return "float64"
 	}
 
 	return typo
 }
+
+func (cg *CodeGenerator) verifyIsNullable(token *hclwrite.Attribute, ok bool) bool {
+	if !ok {
+		return false
+	}
+	value := token.Expr().BuildTokens(nil).Bytes()
+	if string(value) == "true" {
+		return true
+	}
+	return false
+}

tools/generator/generator.go

@@ -89,7 +89,7 @@ func (cg *CodeGenerator) GenerateFilesFromStubs(stubs map[string]Stubs, replacer
 		if !stub.IsGenerated {
 			data, err := GetFileData(stub.ToPath)
 			if err != nil {
-				cg.Logger.Error(err)
+				cg.Logger.Info("File: " + stub.ToPath + " does not exist, generation in this file will be ignored")
 			}
 
 			replData := Replacer(data, replacers)

tools/generator/stubs/crud/domain/{{domain}}.go.stub

@@ -3,11 +3,27 @@ package {{domain}}
 import (
 	"go-skeleton/internal/application/providers/pagination"
 	"go-skeleton/internal/repositories/base_repository"
+	"go-skeleton/internal/application/providers/filters"
 	{{optionalImports}}
 )
 
 {{domainType}}
 
+func (d *{{domainPascalCase}}) SetClient(client string) {
+	d.client = client
+}
+
+func (d *{{domainPascalCase}}) SetFilters(filters *filters.Filters) {
+	d.filters = filters
+}
+
+func (d {{domainPascalCase}}) GetFilters() filters.Filters {
+	if d.filters != nil {
+		return *d.filters
+	}
+	return filters.Filters{}
+}
+
 func (d {{domainPascalCase}}) Schema() string {
 	return "{{domain}}"
 }