forked from dizzyfool/genna
/
generator.go
130 lines (103 loc) · 3.02 KB
/
generator.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package model
import (
"github.com/dizzyfool/genna/generators/base"
"github.com/dizzyfool/genna/model"
"github.com/dizzyfool/genna/util"
"github.com/spf13/cobra"
"go.uber.org/zap"
)
const (
pkg = "pkg"
keepPK = "keep-pk"
noDiscard = "no-discard"
noAlias = "no-alias"
softDelete = "soft-delete"
json = "json"
)
// CreateCommand creates generator command
func CreateCommand(logger *zap.Logger) *cobra.Command {
return base.CreateCommand("model", "Basic go-pg model generator", New(logger))
}
// Basic represents basic generator
type Basic struct {
logger *zap.Logger
options Options
}
// New creates basic generator
func New(logger *zap.Logger) *Basic {
return &Basic{
logger: logger,
}
}
// Logger gets logger
func (g *Basic) Logger() *zap.Logger {
return g.logger
}
// Options gets options
func (g *Basic) Options() Options {
return g.options
}
// SetOptions sets options
func (g *Basic) SetOptions(options Options) {
g.options = options
}
// AddFlags adds flags to command
func (g *Basic) AddFlags(command *cobra.Command) {
base.AddFlags(command)
flags := command.Flags()
flags.SortFlags = false
flags.StringP(pkg, "p", util.DefaultPackage, "package for model files")
flags.BoolP(keepPK, "k", false, "keep primary key name as is (by default it should be converted to 'ID')")
flags.StringP(softDelete, "s", "", "field for soft_delete tag\n")
flags.BoolP(noAlias, "w", false, `do not set 'alias' tag to "t"`)
flags.BoolP(noDiscard, "d", false, "do not use 'discard_unknown_columns' tag\n")
flags.StringToStringP(json, "j", map[string]string{"*": "map[string]interface{}"}, "type for json columns\nuse format: table.column=type, separate by comma\nuse asterisk as wildcard in table name")
}
// ReadFlags read flags from command
func (g *Basic) ReadFlags(command *cobra.Command) error {
var err error
g.options.URL, g.options.Output, g.options.Tables, g.options.FollowFKs, err = base.ReadFlags(command)
if err != nil {
return err
}
flags := command.Flags()
if g.options.Package, err = flags.GetString(pkg); err != nil {
return err
}
if g.options.KeepPK, err = flags.GetBool(keepPK); err != nil {
return err
}
if g.options.SoftDelete, err = flags.GetString(softDelete); err != nil {
return err
}
if g.options.NoDiscard, err = flags.GetBool(noDiscard); err != nil {
return err
}
if g.options.NoAlias, err = flags.GetBool(noAlias); err != nil {
return err
}
if g.options.JSONTypes, err = flags.GetStringToString(json); err != nil {
return err
}
// setting defaults
g.options.Def()
return nil
}
// Generate runs whole generation process
func (g *Basic) Generate() error {
return base.NewGenerator(g.options.URL, g.logger).
Generate(
g.options.Tables,
g.options.FollowFKs,
g.options.UseSQLNulls,
g.options.Output,
Template,
g.Packer(),
)
}
// Packer returns packer function for compile entities into package
func (g *Basic) Packer() base.Packer {
return func(entities []model.Entity) (interface{}, error) {
return NewTemplatePackage(entities, g.options), nil
}
}