table.go

package exql

import (
	"bytes"
	"fmt"
	"strconv"
	"strings"
	"text/template"

	"github.com/iancoleman/strcase"
)

type Table struct {
	TableName string    `json:"table_name"`
	Columns   []*Column `json:"columns"`
}

func (t *Table) Fields() []string {
	var ret []string
	for _, c := range t.Columns {
		ret = append(ret, c.Field())
	}
	return ret
}
func (t *Table) HasNullField() bool {
	for _, c := range t.Columns {
		if c.Nullable {
			return true
		}
	}
	return false
}

func (t *Table) HasTimeField() bool {
	for _, c := range t.Columns {
		if c.GoFieldType == "time.Time" {
			return true
		}
	}
	return false
}

func (t *Table) HasJsonField() bool {
	for _, c := range t.Columns {
		if c.GoFieldType == "json.RawMessage" {
			return true
		}
	}
	return false
}

type generatedModelFile struct {
	// Name is the default generated file name.
	Name string
	// Source is the unformatted Go source. Format it before writing .go files.
	Source []byte
}

type modelTemplateData struct {
	Imports            string
	Model              string
	ModelLower         string
	M                  string
	Package            string
	Fields             string
	UpdaterFields      string
	ScannedFields      string
	TableNameGoLiteral string
}

// GenerateModelFile builds a model file name and source without touching the filesystem.
func (t *Table) GenerateModelFile(packageName string) (*generatedModelFile, error) {
	if t.TableName == "" {
		return nil, errTableNameEmpty
	}
	if packageName == "" {
		packageName = "model"
	}

	var imports []string
	if t.HasJsonField() {
		imports = append(imports, `import "encoding/json"`)
	}
	if t.HasTimeField() {
		imports = append(imports, `import "time"`)
	}
	if t.HasNullField() {
		imports = append(imports, `import "github.com/loilo-inc/exql/v3/null"`)
	}

	fields := strings.Builder{}
	updateFields := strings.Builder{}
	scannedFields := strings.Builder{}
	for i, col := range t.Columns {
		scannedFields.WriteString(fmt.Sprintf(
			"\t&%s.%s,", t.TableName[0:1], col.Field()),
		)
		fields.WriteString(fmt.Sprintf("\t%s", col.Field()))
		updateFields.WriteString(fmt.Sprintf("\t%s", col.UpdateField()))
		if i < len(t.Columns)-1 {
			scannedFields.WriteString("\n")
			fields.WriteString("\n")
			updateFields.WriteString("\n")
		}
	}

	data := &modelTemplateData{
		Imports:            strings.Join(imports, "\n"),
		Model:              strcase.ToCamel(t.TableName),
		ModelLower:         strcase.ToLowerCamel(t.TableName),
		M:                  t.TableName[0:1],
		UpdaterFields:      updateFields.String(),
		Package:            packageName,
		Fields:             fields.String(),
		TableNameGoLiteral: strconv.Quote(t.TableName),
		ScannedFields:      scannedFields.String(),
	}
	tmpl := template.Must(template.New("model").Parse(modelTemplate))
	buf := &bytes.Buffer{}
	if err := tmpl.Execute(buf, data); err != nil {
		return nil, err
	}

	return &generatedModelFile{
		Name:   fmt.Sprintf("%s.go", strcase.ToSnake(t.TableName)),
		Source: buf.Bytes(),
	}, nil
}

const modelTemplate = `// Code generated by exql. DO NOT EDIT.
package {{.Package}}

{{.Imports}}

type {{.Model}} struct {
{{.Fields}}
}

func ({{.M}} *{{.Model}}) TableName() string {
	return {{.Model}}TableName
}

type Update{{.Model}} struct {
{{.UpdaterFields}}
}

func ({{.M}} *Update{{.Model}}) UpdateTableName() string {
	return {{.Model}}TableName
}

const {{.Model}}TableName = {{.TableNameGoLiteral}}
`