409 lines
11 KiB
Go
409 lines
11 KiB
Go
package template
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"text/template"
|
|
|
|
"source.gleipnir.technology/Gleipnir/jet/internal/utils/filesys"
|
|
|
|
"source.gleipnir.technology/Gleipnir/jet/generator/metadata"
|
|
"source.gleipnir.technology/Gleipnir/jet/internal/jet"
|
|
)
|
|
|
|
type Dialect = jet.Dialect
|
|
// ProcessSchema will process schema metadata and constructs go files using generator Template
|
|
func ProcessSchema(dirPath string, schemaMetaData metadata.Schema, generatorTemplate Template) error {
|
|
if schemaMetaData.IsEmpty() {
|
|
return nil
|
|
}
|
|
|
|
schemaTemplate := generatorTemplate.Schema(schemaMetaData)
|
|
schemaPath := filepath.Join(dirPath, schemaTemplate.Path)
|
|
|
|
fmt.Println("Destination directory:", schemaPath)
|
|
fmt.Println("Cleaning up destination directory...")
|
|
if err := os.RemoveAll(schemaPath); err != nil {
|
|
return errors.New("failed to cleanup generated files")
|
|
}
|
|
|
|
err := processModel(schemaPath, schemaMetaData, schemaTemplate)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate model types: %w", err)
|
|
}
|
|
|
|
err = processSQLBuilder(schemaPath, generatorTemplate.Dialect, schemaMetaData, schemaTemplate)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate sql builder types: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func processModel(dirPath string, schemaMetaData metadata.Schema, schemaTemplate Schema) error {
|
|
modelTemplate := schemaTemplate.Model
|
|
|
|
if modelTemplate.Skip {
|
|
fmt.Println("Skipping the generation of model types.")
|
|
return nil
|
|
}
|
|
|
|
modelDirPath := filepath.Join(dirPath, modelTemplate.Path)
|
|
|
|
err := filesys.EnsureDirPathExist(modelDirPath)
|
|
if err != nil {
|
|
return fmt.Errorf("destination dir path does not exist: %w", err)
|
|
}
|
|
|
|
err = processTableModels("table", modelDirPath, schemaMetaData.TablesMetaData, modelTemplate)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate table model types: %w", err)
|
|
}
|
|
|
|
err = processTableModels("view", modelDirPath, schemaMetaData.ViewsMetaData, modelTemplate)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate view model types: %w", err)
|
|
}
|
|
|
|
err = processEnumModels(modelDirPath, schemaMetaData.EnumsMetaData, modelTemplate)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to process enum types: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func processSQLBuilder(dirPath string, dialect jet.Dialect, schemaMetaData metadata.Schema, schemaTemplate Schema) error {
|
|
sqlBuilderTemplate := schemaTemplate.SQLBuilder
|
|
|
|
if sqlBuilderTemplate.Skip {
|
|
fmt.Println("Skipping the generation of SQL Builder types.")
|
|
return nil
|
|
}
|
|
|
|
sqlBuilderPath := filepath.Join(dirPath, sqlBuilderTemplate.Path)
|
|
|
|
err := processTableSQLBuilder("table", sqlBuilderPath, dialect, schemaMetaData, schemaMetaData.TablesMetaData, sqlBuilderTemplate)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to process table sql builder types: %w", err)
|
|
}
|
|
|
|
err = processTableSQLBuilder("view", sqlBuilderPath, dialect, schemaMetaData, schemaMetaData.ViewsMetaData, sqlBuilderTemplate)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to process view sql builder types: %w", err)
|
|
}
|
|
|
|
err = processEnumSQLBuilder(sqlBuilderPath, dialect, schemaMetaData.EnumsMetaData, sqlBuilderTemplate)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to process enum types: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func processEnumSQLBuilder(dirPath string, dialect jet.Dialect, enumsMetaData []metadata.Enum, sqlBuilder SQLBuilder) error {
|
|
if len(enumsMetaData) == 0 {
|
|
return nil
|
|
}
|
|
|
|
fmt.Printf("Generating enum sql builder files\n")
|
|
|
|
for _, enumMetaData := range enumsMetaData {
|
|
enumTemplate := sqlBuilder.Enum(enumMetaData)
|
|
|
|
if enumTemplate.Skip {
|
|
continue
|
|
}
|
|
|
|
enumSQLBuilderPath := filepath.Join(dirPath, enumTemplate.Path)
|
|
|
|
err := filesys.EnsureDirPathExist(enumSQLBuilderPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create enum sql builder directory - %s: %w", enumSQLBuilderPath, err)
|
|
}
|
|
|
|
text, err := generateTemplate(
|
|
autoGenWarningTemplate+enumSQLBuilderTemplate,
|
|
enumMetaData,
|
|
template.FuncMap{
|
|
"package": func() string {
|
|
return enumTemplate.PackageName()
|
|
},
|
|
"dialect": func() jet.Dialect {
|
|
return dialect
|
|
},
|
|
"enumTemplate": func() EnumSQLBuilder {
|
|
return enumTemplate
|
|
},
|
|
"enumValueName": func(enumValue string) string {
|
|
return enumTemplate.ValueName(enumValue)
|
|
},
|
|
"golangComment": formatGolangComment,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generete enum type %s: %w", enumTemplate.FileName, err)
|
|
}
|
|
|
|
err = filesys.FormatAndSaveGoFile(enumSQLBuilderPath, enumTemplate.FileName, text)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to format and save '%s' enum type : %w", enumTemplate.FileName, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func processTableSQLBuilder(fileTypes, dirPath string,
|
|
dialect jet.Dialect,
|
|
schemaMetaData metadata.Schema,
|
|
tablesMetaData []metadata.Table,
|
|
sqlBuilderTemplate SQLBuilder) error {
|
|
|
|
if len(tablesMetaData) == 0 {
|
|
return nil
|
|
}
|
|
|
|
fmt.Printf("Generating %s sql builder files\n", fileTypes)
|
|
|
|
var generatedBuilders []TableSQLBuilder
|
|
|
|
for _, tableMetaData := range tablesMetaData {
|
|
var tableSQLBuilder TableSQLBuilder
|
|
|
|
if fileTypes == "view" {
|
|
tableSQLBuilder = sqlBuilderTemplate.View(tableMetaData)
|
|
} else {
|
|
tableSQLBuilder = sqlBuilderTemplate.Table(tableMetaData)
|
|
}
|
|
|
|
if tableSQLBuilder.Skip {
|
|
continue
|
|
}
|
|
|
|
tableSQLBuilderPath := filepath.Join(dirPath, tableSQLBuilder.Path)
|
|
|
|
err := filesys.EnsureDirPathExist(tableSQLBuilderPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create table sql builder directory - %s: %w", tableSQLBuilderPath, err)
|
|
}
|
|
|
|
text, err := generateTemplate(
|
|
autoGenWarningTemplate+tableSQLBuilderTemplate,
|
|
tableMetaData,
|
|
template.FuncMap{
|
|
"columnField": func(columnMetaData metadata.Column) TableSQLBuilderColumn {
|
|
return tableSQLBuilder.Column(dialect, columnMetaData)
|
|
},
|
|
"columnList": func(columns []metadata.Column) string {
|
|
names := []string{}
|
|
for _, col := range columns {
|
|
bc := tableSQLBuilder.Column(dialect, col)
|
|
if bc.Skip {
|
|
continue
|
|
}
|
|
names = append(names, bc.Name+"Column")
|
|
}
|
|
return strings.Join(names, ", ")
|
|
},
|
|
"dialect": func() jet.Dialect {
|
|
return dialect
|
|
},
|
|
"golangComment": formatGolangComment,
|
|
"imports": func(columns []metadata.Column) []string {
|
|
imports := make(map[string]struct{}, 0)
|
|
for _, columnMetaData := range columns {
|
|
c := tableSQLBuilder.Column(dialect, columnMetaData)
|
|
imports[c.Import] = struct{}{}
|
|
}
|
|
results := make([]string, 0)
|
|
for k, _ := range imports {
|
|
results = append(results, k)
|
|
}
|
|
sort.Strings(results)
|
|
return results
|
|
},
|
|
"insertedRowAlias": func() string {
|
|
return insertedRowAlias(dialect)
|
|
},
|
|
"package": func() string {
|
|
return tableSQLBuilder.PackageName()
|
|
},
|
|
"schemaName": func() string {
|
|
return schemaMetaData.Name
|
|
},
|
|
"structImplName": func() string { // postgres only
|
|
structName := tableSQLBuilder.TypeName
|
|
return string(strings.ToLower(structName)[0]) + structName[1:]
|
|
},
|
|
"tableTemplate": func() TableSQLBuilder {
|
|
return tableSQLBuilder
|
|
},
|
|
"toUpper": strings.ToUpper,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate table sql builder type %s: %w", tableSQLBuilder.TypeName, err)
|
|
}
|
|
|
|
err = filesys.FormatAndSaveGoFile(tableSQLBuilderPath, tableSQLBuilder.FileName, text)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to format and save generated sql builder type '%s': %w", tableSQLBuilder.FileName, err)
|
|
}
|
|
|
|
generatedBuilders = append(generatedBuilders, tableSQLBuilder)
|
|
}
|
|
|
|
err := generateUseSchemaFunc(dirPath, fileTypes, generatedBuilders)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate UseSchema function")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func generateUseSchemaFunc(dirPath, fileTypes string, builders []TableSQLBuilder) error {
|
|
if len(builders) == 0 {
|
|
return nil
|
|
}
|
|
|
|
text, err := generateTemplate(
|
|
autoGenWarningTemplate+tableSqlBuilderSetSchemaTemplate,
|
|
builders,
|
|
template.FuncMap{
|
|
"package": func() string { return builders[0].PackageName() },
|
|
"type": func() string { return fileTypes },
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate use schema template: %w", err)
|
|
}
|
|
|
|
basePath := filepath.Join(dirPath, builders[0].Path)
|
|
fileName := fileTypes + "_use_schema"
|
|
|
|
err = filesys.FormatAndSaveGoFile(basePath, fileName, text)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to save %s file: %w", fileName, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func insertedRowAlias(dialect jet.Dialect) string {
|
|
if dialect.Name() == "MySQL" {
|
|
return "new"
|
|
}
|
|
|
|
return "excluded"
|
|
}
|
|
|
|
func processTableModels(fileTypes, modelDirPath string, tablesMetaData []metadata.Table, modelTemplate Model) error {
|
|
if len(tablesMetaData) == 0 {
|
|
return nil
|
|
}
|
|
fmt.Printf("Generating %s model files...\n", fileTypes)
|
|
|
|
for _, tableMetaData := range tablesMetaData {
|
|
var tableTemplate TableModel
|
|
|
|
if fileTypes == "table" {
|
|
tableTemplate = modelTemplate.Table(tableMetaData)
|
|
} else {
|
|
tableTemplate = modelTemplate.View(tableMetaData)
|
|
}
|
|
|
|
if tableTemplate.Skip {
|
|
continue
|
|
}
|
|
|
|
text, err := generateTemplate(
|
|
autoGenWarningTemplate+tableModelFileTemplate,
|
|
tableMetaData,
|
|
template.FuncMap{
|
|
"package": func() string {
|
|
return modelTemplate.PackageName()
|
|
},
|
|
"modelImports": func() []string {
|
|
return getTableModelImports(tableTemplate, tableMetaData)
|
|
},
|
|
"tableTemplate": func() TableModel {
|
|
return tableTemplate
|
|
},
|
|
"structField": func(columnMetaData metadata.Column) TableModelField {
|
|
return tableTemplate.Field(columnMetaData)
|
|
},
|
|
"golangComment": formatGolangComment,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate model type '%s': %w", tableMetaData.Name, err)
|
|
}
|
|
|
|
err = filesys.FormatAndSaveGoFile(modelDirPath, tableTemplate.FileName, text)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to save '%s' model type: %w", tableTemplate.FileName, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func processEnumModels(modelDir string, enumsMetaData []metadata.Enum, modelTemplate Model) error {
|
|
if len(enumsMetaData) == 0 {
|
|
return nil
|
|
}
|
|
fmt.Print("Generating enum model files...\n")
|
|
|
|
for _, enumMetaData := range enumsMetaData {
|
|
enumTemplate := modelTemplate.Enum(enumMetaData)
|
|
|
|
if enumTemplate.Skip {
|
|
continue
|
|
}
|
|
|
|
text, err := generateTemplate(
|
|
autoGenWarningTemplate+enumModelTemplate,
|
|
enumMetaData,
|
|
template.FuncMap{
|
|
"package": func() string {
|
|
return modelTemplate.PackageName()
|
|
},
|
|
"enumTemplate": func() EnumModel {
|
|
return enumTemplate
|
|
},
|
|
"valueName": func(value string) string {
|
|
return enumTemplate.ValueName(value)
|
|
},
|
|
"golangComment": formatGolangComment,
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to generate enum type '%s': %w", enumMetaData.Name, err)
|
|
}
|
|
|
|
err = filesys.FormatAndSaveGoFile(modelDir, enumTemplate.FileName, text)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to save '%s' enum type: %w", enumTemplate.FileName, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func generateTemplate(templateText string, templateData interface{}, funcMap template.FuncMap) ([]byte, error) {
|
|
t, err := template.New("sqlBuilderTableTemplate").Funcs(funcMap).Parse(templateText)
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to parse template: %w", err)
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
if err := t.Execute(&buf, templateData); err != nil {
|
|
return nil, fmt.Errorf("failed to generate template: %w", err)
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
}
|