repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/parser/error.go | tools/goctl/pkg/parser/api/parser/error.go | package parser
import (
"fmt"
"strings"
)
type errorManager struct {
errors []string
}
func newErrorManager() *errorManager {
return &errorManager{}
}
func (e *errorManager) add(err error) {
if err == nil {
return
}
e.errors = append(e.errors, err.Error())
}
func (e *errorManager) error() error {
if len(e.errors) == 0 {
return nil
}
return fmt.Errorf(strings.Join(e.errors, "\n"))
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/parser/filter.go | tools/goctl/pkg/parser/api/parser/filter.go | package parser
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/ast"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
)
type filterBuilder struct {
filename string
m map[string]token.Position
checkExprName string
errorManager *errorManager
}
func (b *filterBuilder) check(nodes ...*ast.TokenNode) {
for _, node := range nodes {
fileNodeText := fmt.Sprintf("%s/%s", b.filename, node.Token.Text)
if pos, ok := b.m[fileNodeText]; ok && pos != node.Token.Position {
b.errorManager.add(ast.DuplicateStmtError(node.Pos(), "duplicate "+b.checkExprName))
} else {
b.m[fileNodeText] = node.Token.Position
}
}
}
func (b *filterBuilder) checkNodeWithPrefix(prefix string, nodes ...*ast.TokenNode) {
for _, node := range nodes {
joinText := fmt.Sprintf("%s/%s", prefix, node.Token.Text)
if pos, ok := b.m[joinText]; ok && pos != node.Token.Position {
b.errorManager.add(ast.DuplicateStmtError(node.Pos(), "duplicate "+b.checkExprName))
} else {
b.m[joinText] = node.Token.Position
}
}
}
func (b *filterBuilder) error() error {
return b.errorManager.error()
}
type filter struct {
builders []*filterBuilder
}
func newFilter() *filter {
return &filter{}
}
func (f *filter) addCheckItem(filename, checkExprName string) *filterBuilder {
b := &filterBuilder{
filename: filename,
m: make(map[string]token.Position),
checkExprName: checkExprName,
errorManager: newErrorManager(),
}
f.builders = append(f.builders, b)
return b
}
func (f *filter) error() error {
if len(f.builders) == 0 {
return nil
}
var errorManager = newErrorManager()
for _, b := range f.builders {
errorManager.add(b.error())
}
return errorManager.error()
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/parser/parser_test.go | tools/goctl/pkg/parser/api/parser/parser_test.go | package parser
import (
_ "embed"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/assertx"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/ast"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
)
//go:embed testdata/comment_test.api
var testCommentInput string
func TestParser_init(t *testing.T) {
var testData = []string{
"`",
"@`",
"syntax/**/`",
}
for _, val := range testData {
p := New("test.api", val)
val := p.init()
assert.False(t, val)
}
}
//go:embed testdata/test.api
var testInput string
func TestParser_Parse(t *testing.T) {
t.Run("valid", func(t *testing.T) { // EXPERIMENTAL: just for testing output formatter.
p := New("test.api", testInput)
result := p.Parse()
assert.NotNil(t, result)
assert.True(t, p.hasNoErrors())
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
"foo bar",
"@",
}
for _, val := range testData {
p := New("test.api", val)
p.Parse()
assertx.ErrorOrigin(t, val, p.errors...)
}
})
}
func TestParser_Parse_Mode(t *testing.T) {
t.Run("All", func(t *testing.T) {
var testData = []string{
`// foo`,
`// bar`,
`/*foo*/`,
`/*bar*/`,
`//baz`,
}
p := New("foo.api", testCommentInput)
result := p.Parse()
for idx, v := range testData {
stmt := result.Stmts[idx]
c, ok := stmt.(*ast.CommentStmt)
assert.True(t, ok)
assert.True(t, p.hasNoErrors())
assert.Equal(t, v, c.Format(""))
}
})
}
func TestParser_Parse_syntaxStmt(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = []struct {
input string
expected string
}{
{
input: `syntax = "v1"`,
expected: `syntax = "v1"`,
},
{
input: `syntax = "foo"`,
expected: `syntax = "foo"`,
},
{
input: `syntax= "bar"`,
expected: `syntax = "bar"`,
},
{
input: ` syntax = "" `,
expected: `syntax = ""`,
},
}
for _, v := range testData {
p := New("foo.aoi", v.input)
result := p.Parse()
assert.True(t, p.hasNoErrors())
assert.Equal(t, v.expected, result.Stmts[0].Format(""))
}
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`syntax`,
`syntax = `,
`syntax = ''`,
`syntax = @`,
`syntax = "v1`,
`syntax == "v"`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.Parse()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
}
//go:embed testdata/info_test.api
var infoTestAPI string
func TestParser_Parse_infoStmt(t *testing.T) {
t.Run("valid", func(t *testing.T) {
expected := map[string]string{
"title": `"type title here"`,
"desc": `"type desc here"`,
"author": `"type author here"`,
"email": `"type email here"`,
"version": `"type version here"`,
"enable": `true`,
"disable": `false`,
}
p := New("foo.api", infoTestAPI)
result := p.Parse()
assert.True(t, p.hasNoErrors())
stmt := result.Stmts[0]
infoStmt, ok := stmt.(*ast.InfoStmt)
assert.True(t, ok)
for _, stmt := range infoStmt.Values {
actual := stmt.Value.Token.Text
expectedValue := expected[stmt.Key.Token.Text]
assert.Equal(t, expectedValue, actual)
}
})
t.Run("empty", func(t *testing.T) {
p := New("foo.api", "info ()")
result := p.Parse()
assert.True(t, p.hasNoErrors())
stmt := result.Stmts[0]
infoStmt, ok := stmt.(*ast.InfoStmt)
assert.True(t, ok)
assert.Equal(t, "info", infoStmt.Info.Token.Text)
assert.Equal(t, "(", infoStmt.LParen.Token.Text)
assert.Equal(t, ")", infoStmt.RParen.Token.Text)
assert.Equal(t, 0, len(infoStmt.Values))
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`info`,
`info(`,
`info{`,
`info(}`,
`info( foo`,
`info( foo:`,
`info( foo:""`,
`info( foo:"" bar`,
`info( foo:"" bar:`,
`info( foo:"" bar:""`,
`info( foo:"`,
`info foo:""`,
`info( foo,""`,
`info( foo-bar:"")`,
`info(123:"")`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.Parse()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
}
//go:embed testdata/import_literal_test.api
var testImportLiteral string
func TestParser_Parse_importLiteral(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = []string{
`""`,
`"foo"`,
`"bar"`,
}
p := New("foo.api", testImportLiteral)
result := p.Parse()
assert.True(t, p.hasNoErrors())
for idx, v := range testData {
stmt := result.Stmts[idx]
importLit, ok := stmt.(*ast.ImportLiteralStmt)
assert.True(t, ok)
assert.Equal(t, v, importLit.Value.Token.Text)
}
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`import`,
`import "`,
`import "foo`,
`import foo`,
`import @`,
`import $`,
`import 好`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.Parse()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
}
//go:embed testdata/import_group_test.api
var testImportGroup string
func TestParser_Parse_importGroup(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = []string{
`""`,
`"foo"`,
`"bar"`,
}
p := New("foo.api", testImportGroup)
result := p.Parse()
assert.True(t, p.hasNoErrors())
stmt := result.Stmts[0]
importGroup, ok := stmt.(*ast.ImportGroupStmt)
assert.Equal(t, token.IDENT, importGroup.Import.Token.Type)
assert.Equal(t, token.LPAREN, importGroup.LParen.Token.Type)
assert.Equal(t, token.RPAREN, importGroup.RParen.Token.Type)
for idx, v := range testData {
assert.True(t, ok)
assert.Equal(t, v, importGroup.Values[idx].Token.Text)
}
})
t.Run("empty", func(t *testing.T) {
p := New("foo.api", "import ()")
result := p.Parse()
assert.True(t, p.hasNoErrors())
stmt := result.Stmts[0]
importGroup, ok := stmt.(*ast.ImportGroupStmt)
assert.True(t, ok)
assert.Equal(t, token.IDENT, importGroup.Import.Token.Type)
assert.Equal(t, token.LPAREN, importGroup.LParen.Token.Type)
assert.Equal(t, token.RPAREN, importGroup.RParen.Token.Type)
assert.Equal(t, 0, len(importGroup.Values))
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`import`,
`import (`,
`import {`,
`import ( "`,
`import (} "`,
`import ( ")`,
`import ( ""`,
`import ( "" foo)`,
`import ( "" 好)`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.Parse()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
}
//go:embed testdata/atserver_test.api
var atServerTestAPI string
func TestParser_Parse_atServerStmt(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var expectedData = map[string]string{
"foo": `bar`,
"bar": `baz`,
"baz": `foo`,
"qux": `/v1`,
"quux": `/v1/v2`,
"middleware": `M1,M2`,
"timeout1": "1h",
"timeout2": "10m",
"timeout3": "10s",
"timeout4": "10ms",
"timeout5": "10µs",
"timeout6": "10ns",
"timeout7": "1h10m10s10ms10µs10ns",
"maxBytes": `1024`,
"prefix": "/v1",
"prefix1": "/v1/v2_test/v2-beta",
"prefix2": "v1/v2_test/v2-beta",
"prefix3": "v1/v2_",
"prefix4": "a-b-c",
"summary": `"test"`,
"key": `"bar"`,
}
p := New("foo.api", atServerTestAPI)
result := p.ParseForUintTest()
assert.True(t, p.hasNoErrors())
stmt := result.Stmts[0]
atServerStmt, ok := stmt.(*ast.AtServerStmt)
assert.True(t, ok)
for _, v := range atServerStmt.Values {
expectedValue := expectedData[v.Key.Token.Text]
assert.Equal(t, expectedValue, v.Value.Token.Text)
}
})
t.Run("empty", func(t *testing.T) {
p := New("foo.api", `@server()`)
result := p.ParseForUintTest()
assert.True(t, p.hasNoErrors())
stmt := result.Stmts[0]
atServerStmt, ok := stmt.(*ast.AtServerStmt)
assert.True(t, ok)
assert.Equal(t, token.AT_SERVER, atServerStmt.AtServer.Token.Type)
assert.Equal(t, token.LPAREN, atServerStmt.LParen.Token.Type)
assert.Equal(t, token.RPAREN, atServerStmt.RParen.Token.Type)
assert.Equal(t, 0, len(atServerStmt.Values))
})
t.Run("invalidInSkipCommentMode", func(t *testing.T) {
var testData = []string{
`@server`,
`@server{`,
`@server(`,
`@server(}`,
`@server( //foo`,
`@server( foo`,
`@server( foo:`,
`@server( foo:bar bar`,
`@server( foo:bar bar,`,
`@server( foo:bar bar: 123`,
`@server( foo:bar bar: ""`,
`@server( foo:bar bar: @`,
`@server("":foo)`,
`@server(foo:bar,baz)`,
`@server(foo:/`,
`@server(foo:/v`,
`@server(foo:/v1/`,
`@server(foo:/v1/v`,
`@server(foo:/v1/v2`,
`@server(foo: m1,`,
`@server(foo: m1,)`,
`@server(foo: v1/v2-)`,
`@server(foo:"test")`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.Parse()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
t.Run("invalidWithNoSkipCommentMode", func(t *testing.T) {
var testData = []string{
`@server`,
`@server //foo`,
`@server /*foo*/`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.Parse()
assertx.Error(t, p.errors...)
}
})
}
//go:embed testdata/athandler_test.api
var atHandlerTestAPI string
func TestParser_Parse_atHandler(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = []string{
`@handler foo`,
`@handler foo1`,
`@handler _bar`,
}
p := New("foo.api", atHandlerTestAPI)
result := p.ParseForUintTest()
assert.True(t, p.hasNoErrors())
for idx, v := range testData {
stmt := result.Stmts[idx]
atHandlerStmt, ok := stmt.(*ast.AtHandlerStmt)
assert.True(t, ok)
assert.Equal(t, v, atHandlerStmt.Format(""))
}
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`@handler`,
`@handler 1`,
`@handler ""`,
`@handler @`,
`@handler $`,
`@handler ()`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.ParseForUintTest()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
}
//go:embed testdata/atdoc_literal_test.api
var atDocLiteralTestAPI string
func TestParser_Parse_atDocLiteral(t *testing.T) {
t.Run("validLiteral", func(t *testing.T) {
var testData = []string{
`""`,
`"foo"`,
`"bar"`,
}
p := New("foo.api", atDocLiteralTestAPI)
result := p.ParseForUintTest()
assert.True(t, p.hasNoErrors())
for idx, v := range testData {
stmt := result.Stmts[idx]
atDocLitStmt, ok := stmt.(*ast.AtDocLiteralStmt)
assert.True(t, ok)
assert.Equal(t, v, atDocLitStmt.Value.Token.Text)
}
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`@doc`,
`@doc "`,
`@doc $`,
`@doc 好`,
`@doc |`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.ParseForUintTest()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
}
//go:embed testdata/atdoc_group_test.api
var atDocGroupTestAPI string
func TestParser_Parse_atDocGroup(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = `@doc (
foo: "foo"
bar: "bar"
baz: ""
)`
p := New("foo.api", atDocGroupTestAPI)
result := p.ParseForUintTest()
assert.True(t, p.hasNoErrors())
stmt := result.Stmts[0]
atDocGroupStmt, _ := stmt.(*ast.AtDocGroupStmt)
assert.Equal(t, testData, atDocGroupStmt.Format(""))
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`@doc{`,
`@doc(`,
`@doc(}`,
`@doc( foo`,
`@doc( foo:`,
`@doc( foo: 123`,
`@doc( foo: )`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.ParseForUintTest()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
}
//go:embed testdata/service_test.api
var serviceTestAPI string
func TestParser_Parse_service(t *testing.T) {
assertEqual := func(t *testing.T, expected, actual *ast.ServiceStmt) {
if expected.AtServerStmt == nil {
assert.Nil(t, actual.AtServerStmt)
}
assert.Equal(t, expected.Service.Token.Type, actual.Service.Token.Type)
assert.Equal(t, expected.Service.Token.Text, actual.Service.Token.Text)
assert.Equal(t, expected.Name.Format(""), actual.Name.Format(""))
assert.Equal(t, expected.LBrace.Token.Type, actual.LBrace.Token.Type)
assert.Equal(t, expected.RBrace.Token.Text, actual.RBrace.Token.Text)
assert.Equal(t, len(expected.Routes), len(actual.Routes))
for idx, v := range expected.Routes {
actualItem := actual.Routes[idx]
if v.AtDoc == nil {
assert.Nil(t, actualItem.AtDoc)
} else {
assert.Equal(t, v.AtDoc.Format(""), actualItem.AtDoc.Format(""))
}
assert.Equal(t, v.AtHandler.Format(""), actualItem.AtHandler.Format(""))
assert.Equal(t, v.Route.Format(""), actualItem.Route.Format(""))
}
}
t.Run("valid", func(t *testing.T) {
var testData = []*ast.ServiceStmt{
{
Service: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "service"}),
Name: &ast.ServiceNameExpr{
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "foo"}),
},
LBrace: ast.NewTokenNode(token.Token{Type: token.LBRACE, Text: "{"}),
RBrace: ast.NewTokenNode(token.Token{Type: token.RBRACE, Text: "}"}),
Routes: []*ast.ServiceItemStmt{
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "root"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/",
})},
},
},
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "bar"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/ping",
})},
},
},
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "bar"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/ping",
})},
},
},
},
},
{
Service: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "service"}),
Name: &ast.ServiceNameExpr{
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "bar"}),
},
LBrace: ast.NewTokenNode(token.Token{Type: token.LBRACE, Text: "{"}),
RBrace: ast.NewTokenNode(token.Token{Type: token.RBRACE, Text: "}"}),
Routes: []*ast.ServiceItemStmt{
{
AtDoc: &ast.AtDocLiteralStmt{
AtDoc: ast.NewTokenNode(token.Token{Type: token.AT_DOC, Text: "@doc"}),
Value: ast.NewTokenNode(token.Token{Type: token.STRING, Text: `"bar"`}),
},
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "root"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtDoc: &ast.AtDocLiteralStmt{
AtDoc: ast.NewTokenNode(token.Token{Type: token.AT_DOC, Text: "@doc"}),
Value: ast.NewTokenNode(token.Token{Type: token.STRING, Text: `"bar"`}),
},
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "root2"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/",
}),
},
Returns: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "returns"}),
Response: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtDoc: &ast.AtDocLiteralStmt{
AtDoc: ast.NewTokenNode(token.Token{Type: token.AT_DOC, Text: "@doc"}),
Value: ast.NewTokenNode(token.Token{Type: token.STRING, Text: `"bar"`}),
},
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "root3"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
Returns: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "returns"}),
Response: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Bar"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtDoc: &ast.AtDocLiteralStmt{
AtDoc: ast.NewTokenNode(token.Token{Type: token.AT_DOC, Text: "@doc"}),
Value: ast.NewTokenNode(token.Token{Type: token.STRING, Text: `"bar"`}),
},
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "foo"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/foo/:bar",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtDoc: &ast.AtDocLiteralStmt{
AtDoc: ast.NewTokenNode(token.Token{Type: token.AT_DOC, Text: "@doc"}),
Value: ast.NewTokenNode(token.Token{Type: token.STRING, Text: `"bar"`}),
},
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "foo"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/foo/:bar",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
Returns: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "returns"}),
Response: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "foo"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/foo/:bar",
}),
},
Returns: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "returns"}),
Response: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "foo"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "get"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/foo/:bar",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
},
},
{
Service: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "service"}),
Name: &ast.ServiceNameExpr{
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "baz-api"}),
},
LBrace: ast.NewTokenNode(token.Token{Type: token.LBRACE, Text: "{"}),
RBrace: ast.NewTokenNode(token.Token{Type: token.RBRACE, Text: "}"}),
Routes: []*ast.ServiceItemStmt{
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "foo"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "post"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/foo/:bar/foo-bar-baz",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
Returns: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "returns"}),
Response: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Star: ast.NewTokenNode(token.Token{Type: token.MUL, Text: "*"}),
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Bar"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "foo"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "post"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/foo/:bar/foo-bar-baz",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
Returns: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "returns"}),
Response: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
Star: ast.NewTokenNode(token.Token{Type: token.MUL, Text: "*"}),
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Bar"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "bar"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "post"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/foo",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
LBrack: ast.NewTokenNode(token.Token{Type: token.LBRACK, Text: "["}),
RBrack: ast.NewTokenNode(token.Token{Type: token.RBRACK, Text: "]"}),
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
Returns: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "returns"}),
Response: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
LBrack: ast.NewTokenNode(token.Token{Type: token.LBRACK, Text: "["}),
RBrack: ast.NewTokenNode(token.Token{Type: token.RBRACK, Text: "]"}),
Star: ast.NewTokenNode(token.Token{Type: token.MUL, Text: "*"}),
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Bar"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
{
AtHandler: &ast.AtHandlerStmt{
AtHandler: ast.NewTokenNode(token.Token{Type: token.AT_HANDLER, Text: "@handler"}),
Name: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "bar"}),
},
Route: &ast.RouteStmt{
Method: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "post"}),
Path: &ast.PathExpr{
Value: ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: "/foo",
}),
},
Request: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
LBrack: ast.NewTokenNode(token.Token{Type: token.LBRACK, Text: "["}),
RBrack: ast.NewTokenNode(token.Token{Type: token.RBRACK, Text: "]"}),
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Foo"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
Returns: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "returns"}),
Response: &ast.BodyStmt{
LParen: ast.NewTokenNode(token.Token{Type: token.LPAREN, Text: "("}),
Body: &ast.BodyExpr{
LBrack: ast.NewTokenNode(token.Token{Type: token.LBRACK, Text: "["}),
RBrack: ast.NewTokenNode(token.Token{Type: token.RBRACK, Text: "]"}),
Star: ast.NewTokenNode(token.Token{Type: token.MUL, Text: "*"}),
Value: ast.NewTokenNode(token.Token{Type: token.IDENT, Text: "Bar"}),
},
RParen: ast.NewTokenNode(token.Token{Type: token.RPAREN, Text: ")"}),
},
},
},
},
},
}
p := New("foo.api", serviceTestAPI)
result := p.Parse()
assert.True(t, p.hasNoErrors())
for idx, v := range testData {
stmt := result.Stmts[idx]
serviceStmt, ok := stmt.(*ast.ServiceStmt)
assert.True(t, ok)
assertEqual(t, v, serviceStmt)
}
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`service`,
`service foo`,
`service -`,
`service foo-`,
`service foo-api`,
`service foo(`,
`service foo$`,
`service foo好`,
`service foo{`,
`service foo{ @doc`,
`service foo{ @doc $`,
`service foo{ @doc ""`,
`service foo{ @handler`,
`service foo{ @handler foo`,
`service foo{ @handler foo bar`,
`service foo{ @handler foo get`,
`service foo{ @handler foo get /`,
`service foo{ @handler foo get \`,
`service foo{ @handler foo get /:`,
`service foo{ @handler foo get /::`,
`service foo{ @handler foo get /:foo-`,
`service foo{ @handler foo get /:foo--`,
`service foo{ @handler foo get /:foo-bar/-`,
`service foo{ @handler foo get /:foo-bar/baz`,
`service foo{ @handler foo get /:foo-bar/baz (`,
`service foo{ @handler foo get /:foo-bar/baz foo`,
`service foo{ @handler foo get /:foo-bar/baz (foo`,
`service foo{ @handler foo get /:foo-bar/baz (foo)`,
`service foo{ @handler foo get /:foo-bar/baz (foo) return`,
`service foo{ @handler foo get /:foo-bar/baz (foo) returns `,
`service foo{ @handler foo get /:foo-bar/baz (foo) returns (`,
`service foo{ @handler foo get /:foo-bar/baz (foo) returns {`,
`service foo{ @handler foo get /:foo-bar/baz (foo) returns (bar`,
`service foo{ @handler foo get /:foo-bar/baz (foo) returns (bar}`,
`service foo{ @handler foo get /:foo-bar/baz (foo) returns (bar)`,
`service foo{ @handler foo get /:foo-bar/baz ([`,
`service foo{ @handler foo get /:foo-bar/baz ([@`,
`service foo{ @handler foo get /:foo-bar/baz ([]`,
`service foo{ @handler foo get /:foo-bar/baz ([]*`,
`service foo{ @handler foo get /:foo-bar/baz ([]*Foo`,
`service foo{ @handler foo get /:foo-bar/baz (*`,
`service foo{ @handler foo get /:foo-bar/baz (*Foo`,
`service foo{ @handler foo get /:foo-bar/baz returns`,
`service foo{ @handler foo get /:foo-bar/baz returns (`,
`service foo{ @handler foo get /:foo-bar/baz returns ([`,
`service foo{ @handler foo get /:foo-bar/baz returns ([]`,
`service foo{ @handler foo get /:foo-bar/baz returns ([]*`,
`service foo{ @handler foo get /:foo-bar/baz returns ([]*Foo`,
`service foo{ @handler foo get /:foo-bar/baz returns (*`,
`service foo{ @handler foo get /:foo-bar/baz returns (*Foo`,
`service foo{ @handler foo get /ping (Foo) returns (Bar)]`,
}
for _, v := range testData {
p := New("foo.api", v)
_ = p.Parse()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
t.Run("invalidBeginWithAtServer", func(t *testing.T) {
var testData = []string{
`@server(`,
`@server() service`,
`@server() foo`,
`@server() service fo`,
}
for _, v := range testData {
p := New("foo.api", v)
p.init()
_ = p.parseService()
assertx.ErrorOrigin(t, v, p.errors...)
}
})
}
func TestParser_Parse_pathItem(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = []struct {
input string
expected string
}{
{input: "foo", expected: "foo"},
{input: "foo2", expected: "foo2"},
{input: "foo-bar", expected: "foo-bar"},
{input: "foo-bar2", expected: "foo-bar2"},
{input: "foo-bar-baz", expected: "foo-bar-baz"},
{input: "_foo-bar-baz", expected: "_foo-bar-baz"},
{input: "_foo_bar-baz", expected: "_foo_bar-baz"},
{input: "_foo_bar_baz", expected: "_foo_bar_baz"},
{input: "_foo_bar_baz", expected: "_foo_bar_baz"},
{input: "foo/", expected: "foo"},
{input: "foo(", expected: "foo"},
{input: "foo returns", expected: "foo"},
{input: "foo @doc", expected: "foo"},
{input: "foo @handler", expected: "foo"},
{input: "foo }", expected: "foo"},
{input: "1", expected: "1"},
{input: "11", expected: "11"},
}
for _, v := range testData {
p := New("foo.api", v.input)
ok := p.nextToken()
assert.True(t, ok)
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | true |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/parser/analyzer_test.go | tools/goctl/pkg/parser/api/parser/analyzer_test.go | package parser
import (
"bytes"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/assertx"
)
func Test_Parse(t *testing.T) {
t.Run(
"valid", func(t *testing.T) {
apiSpec, err := Parse("./testdata/example.api", nil)
assert.Nil(t, err)
ast := assert.New(t)
ast.Equal(
spec.Info{
Title: "type title here",
Desc: "type desc here",
Version: "type version here",
Author: "type author here",
Email: "type email here",
Properties: map[string]string{
"title": "type title here",
"desc": "type desc here",
"version": "type version here",
"author": "type author here",
"email": "type email here",
},
}, apiSpec.Info,
)
ast.True(
func() bool {
for _, group := range apiSpec.Service.Groups {
value, ok := group.Annotation.Properties["summary"]
if ok {
return value == "test"
}
}
return false
}(),
)
},
)
t.Run(
"invalid", func(t *testing.T) {
data, err := os.ReadFile("./testdata/invalid.api")
assert.NoError(t, err)
splits := bytes.Split(data, []byte("-----"))
var testFile []string
for idx, split := range splits {
replacer := strings.NewReplacer(" ", "", "\t", "", "\n", "", "\r", "", "\f", "")
r := replacer.Replace(string(split))
if len(r) == 0 {
continue
}
filename := filepath.Join(t.TempDir(), fmt.Sprintf("invalid%d.api", idx))
err := os.WriteFile(filename, split, 0666)
assert.NoError(t, err)
testFile = append(testFile, filename)
}
for _, v := range testFile {
_, err := Parse(v, nil)
assertx.Error(t, err)
}
},
)
t.Run(
"circleImport", func(t *testing.T) {
_, err := Parse("./testdata/base.api", nil)
assertx.Error(t, err)
},
)
t.Run(
"link_import", func(t *testing.T) {
_, err := Parse("./testdata/link_import.api", nil)
assert.Nil(t, err)
},
)
t.Run(
"duplicate_types", func(t *testing.T) {
_, err := Parse("./testdata/duplicate_type.api", nil)
assertx.Error(t, err)
},
)
t.Run(
"duplicate_path_expression", func(t *testing.T) {
_, err := Parse("./testdata/duplicate_path_expression.api", nil)
assertx.Error(t, err)
},
)
t.Run(
"duplicate_path_expression_different_prefix", func(t *testing.T) {
_, err := Parse("./testdata/duplicate_path_expression_different_prefix.api", nil)
assert.Nil(t, err)
},
)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/parser/analyzer.go | tools/goctl/pkg/parser/api/parser/analyzer.go | package parser
import (
"fmt"
"sort"
"strings"
"github.com/zeromicro/go-zero/core/lang"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/ast"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/importstack"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/placeholder"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
)
// Analyzer analyzes the ast and converts it to spec.
type Analyzer struct {
api *API
spec *spec.ApiSpec
}
func (a *Analyzer) astTypeToSpec(in ast.DataType) (spec.Type, error) {
isLiteralType := func(dt ast.DataType) bool {
if _, ok := dt.(*ast.BaseDataType); ok {
return true
}
_, ok := dt.(*ast.AnyDataType)
return ok
}
switch v := (in).(type) {
case *ast.BaseDataType:
raw := v.RawText()
if IsBaseType(raw) {
return spec.PrimitiveType{
RawName: raw,
}, nil
}
return spec.DefineStruct{RawName: raw}, nil
case *ast.AnyDataType:
return nil, ast.SyntaxError(v.Pos(), "unsupported any type")
case *ast.StructDataType:
var members []spec.Member
for _, item := range v.Elements {
m, err := a.fieldToMember(item)
if err != nil {
return nil, err
}
members = append(members, m)
}
if v.RawText() == "{}" {
return nil, ast.SyntaxError(v.Pos(), "unsupported empty struct")
}
return spec.NestedStruct{
RawName: v.RawText(),
Members: members,
}, nil
case *ast.InterfaceDataType:
return spec.InterfaceType{RawName: v.RawText()}, nil
case *ast.MapDataType:
if !isLiteralType(v.Key) {
return nil, ast.SyntaxError(v.Pos(), "expected literal type, got <%T>", v.Key)
}
if !v.Key.CanEqual() {
return nil, ast.SyntaxError(v.Pos(), "map key <%T> must be equal data type", v.Key)
}
if v.Value.ContainsStruct() {
return nil, ast.SyntaxError(v.Pos(), "map value unsupported nested struct")
}
value, err := a.astTypeToSpec(v.Value)
if err != nil {
return nil, err
}
return spec.MapType{
RawName: v.RawText(),
Key: v.Key.RawText(),
Value: value,
}, nil
case *ast.PointerDataType:
raw := v.DataType.RawText()
if IsBaseType(raw) {
return spec.PointerType{RawName: v.RawText(), Type: spec.PrimitiveType{RawName: raw}}, nil
}
value, err := a.astTypeToSpec(v.DataType)
if err != nil {
return nil, err
}
return spec.PointerType{
RawName: v.RawText(),
Type: value,
}, nil
case *ast.ArrayDataType:
if v.Length.Token.Type == token.ELLIPSIS {
return nil, ast.SyntaxError(v.Pos(), "array length unsupported dynamic length")
}
if v.ContainsStruct() {
return nil, ast.SyntaxError(v.Pos(), "array elements unsupported nested struct")
}
value, err := a.astTypeToSpec(v.DataType)
if err != nil {
return nil, err
}
return spec.ArrayType{
RawName: v.RawText(),
Value: value,
}, nil
case *ast.SliceDataType:
if v.ContainsStruct() {
return nil, ast.SyntaxError(v.Pos(), "slice elements unsupported nested struct")
}
value, err := a.astTypeToSpec(v.DataType)
if err != nil {
return nil, err
}
return spec.ArrayType{
RawName: v.RawText(),
Value: value,
}, nil
}
return nil, ast.SyntaxError(in.Pos(), "unsupported type <%T>", in)
}
func (a *Analyzer) convert2Spec() error {
a.fillInfo()
if err := a.fillTypes(); err != nil {
return err
}
if err := a.fillService(); err != nil {
return err
}
sort.SliceStable(a.spec.Types, func(i, j int) bool {
return a.spec.Types[i].Name() < a.spec.Types[j].Name()
})
groups := make([]spec.Group, 0, len(a.spec.Service.Groups))
for _, v := range a.spec.Service.Groups {
sort.SliceStable(v.Routes, func(i, j int) bool {
return v.Routes[i].Path < v.Routes[j].Path
})
groups = append(groups, v)
}
sort.SliceStable(groups, func(i, j int) bool {
return groups[i].Annotation.Properties[groupKeyText] < groups[j].Annotation.Properties[groupKeyText]
})
a.spec.Service.Groups = groups
return nil
}
func (a *Analyzer) convertAtDoc(atDoc ast.AtDocStmt) spec.AtDoc {
var ret spec.AtDoc
switch val := atDoc.(type) {
case *ast.AtDocLiteralStmt:
ret.Text = val.Value.Token.Text
case *ast.AtDocGroupStmt:
ret.Properties = a.convertKV(val.Values)
}
return ret
}
func (a *Analyzer) convertKV(kv []*ast.KVExpr) map[string]string {
var ret = map[string]string{}
for _, v := range kv {
key := strings.TrimSuffix(v.Key.Token.Text, ":")
ret[key] = v.Value.RawText()
}
return ret
}
func (a *Analyzer) fieldToMember(field *ast.ElemExpr) (spec.Member, error) {
var name []string
for _, v := range field.Name {
name = append(name, v.Token.Text)
}
tp, err := a.astTypeToSpec(field.DataType)
if err != nil {
return spec.Member{}, err
}
head, leading := field.CommentGroup()
m := spec.Member{
Name: strings.Join(name, ", "),
Type: tp,
Docs: head.List(),
Comment: leading.String(),
IsInline: field.IsAnonymous(),
}
if field.Tag != nil {
m.Tag = field.Tag.Token.Text
}
return m, nil
}
func (a *Analyzer) fillRouteType(route *spec.Route) error {
if route.RequestType != nil {
switch route.RequestType.(type) {
case spec.DefineStruct:
tp, err := a.findDefinedType(route.RequestType.Name())
if err != nil {
return err
}
route.RequestType = tp
}
}
if route.ResponseType != nil {
switch route.ResponseType.(type) {
case spec.DefineStruct:
tp, err := a.findDefinedType(route.ResponseType.Name())
if err != nil {
return err
}
route.ResponseType = tp
}
}
return nil
}
func (a *Analyzer) fillService() error {
var groups []spec.Group
for _, item := range a.api.ServiceStmts {
var group spec.Group
if item.AtServerStmt != nil {
group.Annotation.Properties = a.convertKV(item.AtServerStmt.Values)
}
sse := group.GetAnnotation("sse") == "true"
for _, astRoute := range item.Routes {
head, leading := astRoute.CommentGroup()
route := spec.Route{
Method: astRoute.Route.Method.Token.Text,
Path: astRoute.Route.Path.Format(""),
Doc: head.List(),
Comment: leading.List(),
}
if astRoute.AtDoc != nil {
route.AtDoc = a.convertAtDoc(astRoute.AtDoc)
}
if astRoute.AtHandler != nil {
route.AtDoc = a.convertAtDoc(astRoute.AtDoc)
route.Handler = astRoute.AtHandler.Name.Token.Text
head, leading := astRoute.AtHandler.CommentGroup()
route.HandlerDoc = head.List()
route.HandlerComment = leading.List()
}
if astRoute.Route.Request != nil && astRoute.Route.Request.Body != nil {
requestType, err := a.getType(astRoute.Route.Request, true)
if err != nil {
return err
}
route.RequestType = requestType
}
if astRoute.Route.Response != nil && astRoute.Route.Response.Body != nil {
responseType, err := a.getType(astRoute.Route.Response, false)
if err != nil {
return err
}
route.ResponseType = responseType
}
if route.ResponseType == nil && sse {
if route.RequestType != nil {
return ast.SyntaxError(astRoute.Route.Request.Pos(), "missing response type")
} else {
return ast.SyntaxError(astRoute.Route.Path.Pos(), "missing response type")
}
}
if err := a.fillRouteType(&route); err != nil {
return err
}
group.Routes = append(group.Routes, route)
name := item.Name.Format("")
if len(a.spec.Service.Name) > 0 && a.spec.Service.Name != name {
return ast.SyntaxError(item.Name.Pos(), "multiple service names defined <%s> and <%s>", name, a.spec.Service.Name)
}
a.spec.Service.Name = name
}
groups = append(groups, group)
}
a.spec.Service.Groups = groups
return nil
}
func (a *Analyzer) fillInfo() {
properties := make(map[string]string)
if a.api.info != nil {
for _, kv := range a.api.info.Values {
key := kv.Key.Token.Text
properties[strings.TrimSuffix(key, ":")] = kv.Value.RawText()
}
}
a.spec.Info.Properties = properties
infoKeyValue := make(map[string]string)
for key, value := range properties {
titleKey := strings.Title(strings.TrimSuffix(key, ":"))
infoKeyValue[titleKey] = value
}
a.spec.Info.Title = infoKeyValue[infoTitleKey]
a.spec.Info.Desc = infoKeyValue[infoDescKey]
a.spec.Info.Version = infoKeyValue[infoVersionKey]
a.spec.Info.Author = infoKeyValue[infoAuthorKey]
a.spec.Info.Email = infoKeyValue[infoEmailKey]
}
func (a *Analyzer) fillTypes() error {
for _, item := range a.api.TypeStmt {
switch v := (item).(type) {
case *ast.TypeLiteralStmt:
if err := a.fillTypeExpr(v.Expr); err != nil {
return err
}
case *ast.TypeGroupStmt:
for _, expr := range v.ExprList {
err := a.fillTypeExpr(expr)
if err != nil {
return err
}
}
}
}
var types []spec.Type
for _, item := range a.spec.Types {
switch v := (item).(type) {
case spec.DefineStruct:
var members []spec.Member
for _, member := range v.Members {
switch v := member.Type.(type) {
case spec.DefineStruct:
tp, err := a.findDefinedType(v.RawName)
if err != nil {
return err
}
member.Type = tp
}
members = append(members, member)
}
v.Members = members
types = append(types, v)
default:
return fmt.Errorf("unknown type %+v", v)
}
}
a.spec.Types = types
return nil
}
func (a *Analyzer) fillTypeExpr(expr *ast.TypeExpr) error {
head, _ := expr.CommentGroup()
switch val := expr.DataType.(type) {
case *ast.StructDataType:
var members []spec.Member
for _, item := range val.Elements {
m, err := a.fieldToMember(item)
if err != nil {
return err
}
members = append(members, m)
}
a.spec.Types = append(a.spec.Types, spec.DefineStruct{
RawName: expr.Name.Token.Text,
Members: members,
Docs: head.List(),
})
return nil
default:
return ast.SyntaxError(expr.Pos(), "expected <struct> expr, got <%T>", expr.DataType)
}
}
func (a *Analyzer) findDefinedType(name string) (spec.Type, error) {
for _, item := range a.spec.Types {
if _, ok := item.(spec.DefineStruct); ok {
if item.Name() == name {
return item, nil
}
}
}
return nil, fmt.Errorf("type %s not defined", name)
}
func (a *Analyzer) getType(expr *ast.BodyStmt, req bool) (spec.Type, error) {
body := expr.Body
if req && body.IsArrayType() {
return nil, ast.SyntaxError(body.Pos(), "request body must be struct")
}
var tp spec.Type
var err error
var rawText = body.Format("")
if IsBaseType(body.Value.Token.Text) {
tp = spec.PrimitiveType{RawName: body.Value.Token.Text}
} else {
tp, err = a.findDefinedType(body.Value.Token.Text)
if err != nil {
return nil, err
}
}
if body.LBrack != nil {
if body.Star != nil {
return spec.ArrayType{
RawName: rawText,
Value: spec.PointerType{
RawName: rawText,
Type: tp,
},
}, nil
}
return spec.ArrayType{
RawName: rawText,
Value: tp,
}, nil
}
if body.Star != nil {
return spec.PointerType{
RawName: rawText,
Type: tp,
}, nil
}
return tp, nil
}
// Parse parses the given file and returns the parsed spec.
func Parse(filename string, src interface{}) (*spec.ApiSpec, error) {
p := New(filename, src)
ast := p.Parse()
if err := p.CheckErrors(); err != nil {
return nil, err
}
is := importstack.New()
err := is.Push(ast.Filename)
if err != nil {
return nil, err
}
importSet := map[string]lang.PlaceholderType{}
api, err := convert2API(ast, importSet, is)
if err != nil {
return nil, err
}
if err := api.SelfCheck(); err != nil {
return nil, err
}
var result = new(spec.ApiSpec)
analyzer := Analyzer{
api: api,
spec: result,
}
err = analyzer.convert2Spec()
if err != nil {
return nil, err
}
return result, nil
}
var kind = map[string]placeholder.Type{
"bool": placeholder.PlaceHolder,
"int": placeholder.PlaceHolder,
"int8": placeholder.PlaceHolder,
"int16": placeholder.PlaceHolder,
"int32": placeholder.PlaceHolder,
"int64": placeholder.PlaceHolder,
"uint": placeholder.PlaceHolder,
"uint8": placeholder.PlaceHolder,
"uint16": placeholder.PlaceHolder,
"uint32": placeholder.PlaceHolder,
"uint64": placeholder.PlaceHolder,
"uintptr": placeholder.PlaceHolder,
"float32": placeholder.PlaceHolder,
"float64": placeholder.PlaceHolder,
"complex64": placeholder.PlaceHolder,
"complex128": placeholder.PlaceHolder,
"string": placeholder.PlaceHolder,
"byte": placeholder.PlaceHolder,
"rune": placeholder.PlaceHolder,
"any": placeholder.PlaceHolder,
}
// IsBaseType returns true if the given type is a base type.
func IsBaseType(text string) bool {
_, ok := kind[text]
return ok
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/git.go | tools/goctl/util/git.go | package util
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util/env"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func CloneIntoGitHome(url, branch string) (dir string, err error) {
gitHome, err := pathx.GetGitHome()
if err != nil {
return "", err
}
os.RemoveAll(gitHome)
ext := filepath.Ext(url)
repo := strings.TrimSuffix(filepath.Base(url), ext)
dir = filepath.Join(gitHome, repo)
if pathx.FileExists(dir) {
os.RemoveAll(dir)
}
path, err := env.LookPath("git")
if err != nil {
return "", err
}
if !env.CanExec() {
return "", fmt.Errorf("os %q can not call 'exec' command", runtime.GOOS)
}
args := []string{"clone"}
if len(branch) > 0 {
args = append(args, "-b", branch)
}
args = append(args, url, dir)
cmd := exec.Command(path, args...)
cmd.Env = os.Environ()
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err = cmd.Run()
return
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/head.go | tools/goctl/util/head.go | package util
import "github.com/zeromicro/go-zero/tools/goctl/internal/version"
const (
// DoNotEditHead added to the beginning of a file to prompt the user not to edit
DoNotEditHead = "// Code generated by goctl. DO NOT EDIT."
headTemplate = DoNotEditHead + `
// goctl {{.version}}
// Source: {{.source}}`
)
// GetHead returns a code head string with source filename
func GetHead(source string) string {
buffer, _ := With("head").Parse(headTemplate).Execute(map[string]any{
"source": source,
"version": version.BuildVersion,
})
return buffer.String()
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/templatex.go | tools/goctl/util/templatex.go | package util
import (
"bytes"
goformat "go/format"
"os"
"regexp"
"text/template"
"github.com/zeromicro/go-zero/tools/goctl/internal/errorx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const regularPerm = 0o666
// DefaultTemplate is a tool to provides the text/template operations
type DefaultTemplate struct {
name string
text string
goFmt bool
}
// With returns an instance of DefaultTemplate
func With(name string) *DefaultTemplate {
return &DefaultTemplate{
name: name,
}
}
// Parse accepts a source template and returns DefaultTemplate
func (t *DefaultTemplate) Parse(text string) *DefaultTemplate {
t.text = text
return t
}
// GoFmt sets the value to goFmt and marks the generated codes will be formatted or not
func (t *DefaultTemplate) GoFmt(format bool) *DefaultTemplate {
t.goFmt = format
return t
}
// SaveTo writes the codes to the target path
func (t *DefaultTemplate) SaveTo(data any, path string, forceUpdate bool) error {
if pathx.FileExists(path) && !forceUpdate {
return nil
}
output, err := t.Execute(data)
if err != nil {
return err
}
return os.WriteFile(path, output.Bytes(), regularPerm)
}
// Execute returns the codes after the template executed
func (t *DefaultTemplate) Execute(data any) (*bytes.Buffer, error) {
tem, err := template.New(t.name).Parse(t.text)
if err != nil {
return nil, errorx.Wrap(err, "template parse error:", t.text)
}
buf := new(bytes.Buffer)
if err = tem.Execute(buf, data); err != nil {
return nil, errorx.Wrap(err, "template execute error:", t.text)
}
if !t.goFmt {
return buf, nil
}
formatOutput, err := goformat.Source(buf.Bytes())
if err != nil {
return nil, errorx.Wrap(err, "go format error:", buf.String())
}
buf.Reset()
buf.Write(formatOutput)
return buf, nil
}
// IsTemplateVariable returns true if the text is a template variable.
// The text must start with a dot and be a valid template.
func IsTemplateVariable(text string) bool {
match, _ := regexp.MatchString(`(?m)^{{(\.\w+)+}}$`, text)
return match
}
// TemplateVariable returns the variable name of the template.
func TemplateVariable(text string) string {
if IsTemplateVariable(text) {
return text[3 : len(text)-2]
}
return ""
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/templatex_test.go | tools/goctl/util/templatex_test.go | package util
import (
"testing"
"github.com/zeromicro/go-zero/tools/goctl/test"
)
func TestIsTemplate(t *testing.T) {
executor := test.NewExecutor[string, bool]()
executor.Add([]test.Data[string, bool]{
{
Name: "empty",
Want: false,
},
{
Name: "invalid",
Input: "{foo}",
Want: false,
},
{
Name: "invalid",
Input: "{.foo}",
Want: false,
},
{
Name: "invalid",
Input: "$foo",
Want: false,
},
{
Name: "invalid",
Input: "{{foo}}",
Want: false,
},
{
Name: "invalid",
Input: "{{.}}",
Want: false,
},
{
Name: "valid",
Input: "{{.foo}}",
Want: true,
},
{
Name: "valid",
Input: "{{.foo.bar}}",
Want: true,
},
}...)
executor.Run(t, IsTemplateVariable)
}
func TestTemplateVariable(t *testing.T) {
executor := test.NewExecutor[string, string]()
executor.Add([]test.Data[string, string]{
{
Name: "empty",
},
{
Name: "invalid",
Input: "{foo}",
},
{
Name: "invalid",
Input: "{.foo}",
},
{
Name: "invalid",
Input: "$foo",
},
{
Name: "invalid",
Input: "{{foo}}",
},
{
Name: "invalid",
Input: "{{.}}",
},
{
Name: "valid",
Input: "{{.foo}}",
Want: "foo",
},
{
Name: "valid",
Input: "{{.foo.bar}}",
Want: "foo.bar",
},
}...)
executor.Run(t, TemplateVariable)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/string.go | tools/goctl/util/string.go | package util
import (
"slices"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
)
var goKeyword = map[string]string{
"var": "variable",
"const": "constant",
"package": "pkg",
"func": "function",
"return": "rtn",
"defer": "dfr",
"go": "goo",
"select": "slt",
"struct": "structure",
"interface": "itf",
"chan": "channel",
"type": "tp",
"map": "mp",
"range": "rg",
"break": "brk",
"case": "caz",
"continue": "ctn",
"for": "fr",
"fallthrough": "fth",
"else": "es",
"if": "ef",
"switch": "swt",
"goto": "gt",
"default": "dft",
}
// Title returns a string value with s[0] which has been convert into upper case that
// there are not empty input text
func Title(s string) string {
if len(s) == 0 {
return s
}
return strings.ToUpper(s[:1]) + s[1:]
}
// Untitle returns a string value with s[0] which has been convert into lower case that
// there are not empty input text
func Untitle(s string) string {
if len(s) == 0 {
return s
}
return strings.ToLower(s[:1]) + s[1:]
}
// Index returns the index where the item equal,it will return -1 if mismatched
// Deprecated: use slices.Index instead
func Index(slice []string, item string) int {
return slices.Index(slice, item)
}
// SafeString converts the input string into a safe naming style in golang
func SafeString(in string) string {
if len(in) == 0 {
return in
}
data := strings.Map(func(r rune) rune {
if isSafeRune(r) {
return r
}
return '_'
}, in)
headRune := rune(data[0])
if isNumber(headRune) {
return "_" + data
}
return data
}
func isSafeRune(r rune) bool {
return isLetter(r) || isNumber(r) || r == '_'
}
func isLetter(r rune) bool {
return 'A' <= r && r <= 'z'
}
func isNumber(r rune) bool {
return '0' <= r && r <= '9'
}
// EscapeGolangKeyword escapes the golang keywords.
func EscapeGolangKeyword(s string) string {
if !isGolangKeyword(s) {
return s
}
r := goKeyword[s]
console.Info("[EscapeGolangKeyword]: go keyword is forbidden %q, converted into %q", s, r)
return r
}
func isGolangKeyword(s string) bool {
_, ok := goKeyword[s]
return ok
}
func TrimWhiteSpace(s string) string {
r := strings.NewReplacer(" ", "", "\t", "", "\n", "", "\f", "", "\r", "")
return r.Replace(s)
}
func IsEmptyStringOrWhiteSpace(s string) bool {
v := TrimWhiteSpace(s)
return len(v) == 0
}
func FieldsAndTrimSpace(s string, f func(r rune) bool) []string {
fields := strings.FieldsFunc(s, f)
var resp []string
for _, v := range fields {
val := TrimWhiteSpace(v)
if len(val) > 0 {
resp = append(resp, v)
}
}
return resp
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/string_test.go | tools/goctl/util/string_test.go | package util
import (
"strings"
"testing"
"unicode"
"github.com/stretchr/testify/assert"
)
type data struct {
input string
expected string
}
func TestTitle(t *testing.T) {
list := []*data{
{input: "_", expected: "_"},
{input: "abc", expected: "Abc"},
{input: "ABC", expected: "ABC"},
{input: "", expected: ""},
{input: " abc", expected: " abc"},
}
for _, e := range list {
assert.Equal(t, e.expected, Title(e.input))
}
}
func TestUntitle(t *testing.T) {
list := []*data{
{input: "_", expected: "_"},
{input: "Abc", expected: "abc"},
{input: "ABC", expected: "aBC"},
{input: "", expected: ""},
{input: " abc", expected: " abc"},
}
for _, e := range list {
assert.Equal(t, e.expected, Untitle(e.input))
}
}
func TestIndex(t *testing.T) {
list := []string{"a", "b", "c"}
assert.Equal(t, 1, Index(list, "b"))
assert.Equal(t, -1, Index(list, "d"))
}
func TestSafeString(t *testing.T) {
list := []*data{
{input: "_", expected: "_"},
{input: "a-b-c", expected: "a_b_c"},
{input: "123abc", expected: "_123abc"},
{input: "汉abc", expected: "_abc"},
{input: "汉a字", expected: "_a_"},
{input: "キャラクターabc", expected: "______abc"},
{input: "-a_B-C", expected: "_a_B_C"},
{input: "a_B C", expected: "a_B_C"},
{input: "A#B#C", expected: "A_B_C"},
{input: "_123", expected: "_123"},
{input: "", expected: ""},
{input: "\t", expected: "_"},
{input: "\n", expected: "_"},
}
for _, e := range list {
assert.Equal(t, e.expected, SafeString(e.input))
}
}
func TestEscapeGoKeyword(t *testing.T) {
for k := range goKeyword {
assert.Equal(t, goKeyword[k], EscapeGolangKeyword(k))
assert.False(t, isGolangKeyword(strings.Title(k)))
}
}
func TestFieldsAndTrimSpace(t *testing.T) {
testCases := []struct {
name string
input string
delimiter func(r rune) bool
expected []string
}{
{
name: "Comma-separated values",
input: "a, b, c",
delimiter: func(r rune) bool { return r == ',' },
expected: []string{"a", " b", " c"},
},
{
name: "Space-separated values",
input: "a b c",
delimiter: unicode.IsSpace,
expected: []string{"a", "b", "c"},
},
{
name: "Mixed whitespace",
input: "a\tb\nc",
delimiter: unicode.IsSpace,
expected: []string{"a", "b", "c"},
},
{
name: "Empty input",
input: "",
delimiter: unicode.IsSpace,
expected: []string(nil),
},
{
name: "Trailing and leading spaces",
input: " a , b , c ",
delimiter: func(r rune) bool { return r == ',' },
expected: []string{" a ", " b ", " c "},
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
result := FieldsAndTrimSpace(tc.input, tc.delimiter)
assert.Equal(t, tc.expected, result)
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/env/env_test.go | tools/goctl/util/env/env_test.go | package env
import (
"bytes"
"fmt"
"os/exec"
"runtime"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
func TestLookUpGo(t *testing.T) {
xGo, err := LookUpGo()
if err != nil {
return
}
assert.True(t, pathx.FileExists(xGo))
output, errOutput, err := execCommand(xGo, "version")
if err != nil {
return
}
if len(errOutput) > 0 {
return
}
assert.Equal(t, wrapVersion(), output)
}
func TestLookUpProtoc(t *testing.T) {
xProtoc, err := LookUpProtoc()
if err != nil {
return
}
assert.True(t, pathx.FileExists(xProtoc))
output, errOutput, err := execCommand(xProtoc, "--version")
if err != nil {
return
}
if len(errOutput) > 0 {
return
}
assert.True(t, len(output) > 0)
}
func TestLookUpProtocGenGo(t *testing.T) {
xProtocGenGo, err := LookUpProtocGenGo()
if err != nil {
return
}
assert.True(t, pathx.FileExists(xProtocGenGo))
}
func TestLookPath(t *testing.T) {
xGo, err := LookPath("go")
if err != nil {
return
}
assert.True(t, pathx.FileExists(xGo))
}
func TestCanExec(t *testing.T) {
canExec := runtime.GOOS != vars.OsJs && runtime.GOOS != vars.OsIOS
assert.Equal(t, canExec, CanExec())
}
func execCommand(cmd string, arg ...string) (stdout, stderr string, err error) {
output := bytes.NewBuffer(nil)
errOutput := bytes.NewBuffer(nil)
c := exec.Command(cmd, arg...)
c.Stdout = output
c.Stderr = errOutput
err = c.Run()
if err != nil {
return
}
if errOutput.Len() > 0 {
stderr = errOutput.String()
return
}
stdout = strings.TrimSpace(output.String())
return
}
func wrapVersion() string {
version := runtime.Version()
os := runtime.GOOS
arch := runtime.GOARCH
return fmt.Sprintf("go version %s %s/%s", version, os, arch)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/env/env.go | tools/goctl/util/env/env.go | package env
import (
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"time"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
const (
bin = "bin"
binGo = "go"
binProtoc = "protoc"
binProtocGenGo = "protoc-gen-go"
binProtocGenGrpcGo = "protoc-gen-go-grpc"
cstOffset = 60 * 60 * 8 // 8 hours offset for Chinese Standard Time
)
// InChina returns whether the current time is in China Standard Time.
func InChina() bool {
_, offset := time.Now().Zone()
return offset == cstOffset
}
// LookUpGo searches an executable go in the directories
// named by the GOROOT/bin or PATH environment variable.
func LookUpGo() (string, error) {
goRoot := runtime.GOROOT()
suffix := getExeSuffix()
xGo := binGo + suffix
path := filepath.Join(goRoot, bin, xGo)
if _, err := os.Stat(path); err == nil {
return path, nil
}
return LookPath(xGo)
}
// LookUpProtoc searches an executable protoc in the directories
// named by the PATH environment variable.
func LookUpProtoc() (string, error) {
suffix := getExeSuffix()
xProtoc := binProtoc + suffix
return LookPath(xProtoc)
}
// LookUpProtocGenGo searches an executable protoc-gen-go in the directories
// named by the PATH environment variable.
func LookUpProtocGenGo() (string, error) {
suffix := getExeSuffix()
xProtocGenGo := binProtocGenGo + suffix
return LookPath(xProtocGenGo)
}
// LookUpProtocGenGoGrpc searches an executable protoc-gen-go-grpc in the directories
// named by the PATH environment variable.
func LookUpProtocGenGoGrpc() (string, error) {
suffix := getExeSuffix()
xProtocGenGoGrpc := binProtocGenGrpcGo + suffix
return LookPath(xProtocGenGoGrpc)
}
// LookPath searches for an executable named file in the
// directories named by the PATH environment variable,
// for the os windows, the named file will be spliced with the
// .exe suffix.
func LookPath(xBin string) (string, error) {
suffix := getExeSuffix()
if len(suffix) > 0 && !strings.HasSuffix(xBin, suffix) {
xBin = xBin + suffix
}
bin, err := exec.LookPath(xBin)
if err != nil {
return "", err
}
return bin, nil
}
// CanExec reports whether the current system can start new processes
// using os.StartProcess or (more commonly) exec.Command.
func CanExec() bool {
switch runtime.GOOS {
case vars.OsJs, vars.OsIOS:
return false
default:
return true
}
}
func getExeSuffix() string {
if runtime.GOOS == vars.OsWindows {
return ".exe"
}
return ""
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/stringx/string.go | tools/goctl/util/stringx/string.go | package stringx
import (
"bytes"
"strings"
"unicode"
"golang.org/x/text/cases"
"golang.org/x/text/language"
)
var WhiteSpace = []rune{'\n', '\t', '\f', '\v', ' '}
// String provides for converting the source text into other spell case,like lower,snake,camel
type String struct {
source string
}
// From converts the input text to String and returns it
func From(data string) String {
return String{source: data}
}
// IsEmptyOrSpace returns true if the length of the string value is 0 after call strings.TrimSpace, or else returns false
func (s String) IsEmptyOrSpace() bool {
if len(s.source) == 0 {
return true
}
if strings.TrimSpace(s.source) == "" {
return true
}
return false
}
// Lower calls the strings.ToLower
func (s String) Lower() string {
return strings.ToLower(s.source)
}
// Upper calls the strings.ToUpper
func (s String) Upper() string {
return strings.ToUpper(s.source)
}
// ReplaceAll calls the strings.ReplaceAll
func (s String) ReplaceAll(old, new string) string {
return strings.Replace(s.source, old, new, -1)
}
// Source returns the source string value
func (s String) Source() string {
return s.source
}
// Title calls the cases.Title
func (s String) Title() string {
if s.IsEmptyOrSpace() {
return s.source
}
return cases.Title(language.English, cases.NoLower).String(s.source)
}
// ToCamel converts the input text into camel case
func (s String) ToCamel() string {
list := s.splitBy(func(r rune) bool {
return r == '_'
}, true)
var target []string
for _, item := range list {
target = append(target, From(item).Title())
}
return strings.Join(target, "")
}
// ToSnake converts the input text into snake case
func (s String) ToSnake() string {
list := s.splitBy(unicode.IsUpper, false)
var target []string
for _, item := range list {
target = append(target, From(item).Lower())
}
return strings.Join(target, "_")
}
// Untitle return the original string if rune is not letter at index 0
func (s String) Untitle() string {
if s.IsEmptyOrSpace() {
return s.source
}
r := rune(s.source[0])
if !unicode.IsUpper(r) && !unicode.IsLower(r) {
return s.source
}
return string(unicode.ToLower(r)) + s.source[1:]
}
// it will not ignore spaces
func (s String) splitBy(fn func(r rune) bool, remove bool) []string {
if s.IsEmptyOrSpace() {
return nil
}
var list []string
buffer := new(bytes.Buffer)
for _, r := range s.source {
if fn(r) {
if buffer.Len() != 0 {
list = append(list, buffer.String())
buffer.Reset()
}
if !remove {
buffer.WriteRune(r)
}
continue
}
buffer.WriteRune(r)
}
if buffer.Len() != 0 {
list = append(list, buffer.String())
}
return list
}
func ContainsAny(s string, runes ...rune) bool {
if len(runes) == 0 {
return true
}
tmp := make(map[rune]struct{}, len(runes))
for _, r := range runes {
tmp[r] = struct{}{}
}
for _, r := range s {
if _, ok := tmp[r]; ok {
return true
}
}
return false
}
func ContainsWhiteSpace(s string) bool {
return ContainsAny(s, WhiteSpace...)
}
func IsWhiteSpace(text string) bool {
if len(text) == 0 {
return true
}
for _, r := range text {
if !unicode.IsSpace(r) {
return false
}
}
return true
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/stringx/string_test.go | tools/goctl/util/stringx/string_test.go | package stringx
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestString_IsEmptyOrSpace(t *testing.T) {
cases := []struct {
input string
want bool
}{
{
want: true,
},
{
input: " ",
want: true,
},
{
input: "\t",
want: true,
},
{
input: "\n",
want: true,
},
{
input: "\f",
want: true,
},
{
input: " ",
want: true,
},
}
for _, v := range cases {
s := From(v.input)
assert.Equal(t, v.want, s.IsEmptyOrSpace())
}
}
func TestString_Snake2Camel(t *testing.T) {
cases := []struct {
input string
want string
}{
{
input: "__",
want: "",
},
{
input: "go_zero",
want: "GoZero",
},
{
input: "の_go_zero",
want: "のGoZero",
},
{
input: "goZero",
want: "GoZero",
},
{
input: "goZero",
want: "GoZero",
},
{
input: "goZero_",
want: "GoZero",
},
{
input: "go_Zero_",
want: "GoZero",
},
{
input: "_go_Zero_",
want: "GoZero",
},
}
for _, c := range cases {
ret := From(c.input).ToCamel()
assert.Equal(t, c.want, ret)
}
}
func TestString_Camel2Snake(t *testing.T) {
cases := []struct {
input string
want string
}{
{
input: "goZero",
want: "go_zero",
},
{
input: "Gozero",
want: "gozero",
},
{
input: "GoZero",
want: "go_zero",
},
{
input: "Go_Zero",
want: "go__zero",
},
}
for _, c := range cases {
ret := From(c.input).ToSnake()
assert.Equal(t, c.want, ret)
}
}
func TestTitle(t *testing.T) {
cases := []struct {
input string
want string
}{
{
input: "go zero",
want: "Go Zero",
},
{
input: "goZero",
want: "GoZero",
},
{
input: "GoZero",
want: "GoZero",
},
{
input: "の go zero",
want: "の Go Zero",
},
{
input: "Gozero",
want: "Gozero",
},
{
input: "Go_zero",
want: "Go_zero",
},
{
input: "go_zero",
want: "Go_zero",
},
{
input: "Go_Zero",
want: "Go_Zero",
},
}
for _, c := range cases {
ret := From(c.input).Title()
assert.Equal(t, c.want, ret)
}
}
func TestUntitle(t *testing.T) {
cases := []struct {
input string
want string
}{
{
input: "go zero",
want: "go zero",
},
{
input: "GoZero",
want: "goZero",
},
{
input: "Gozero",
want: "gozero",
},
{
input: "Go_zero",
want: "go_zero",
},
{
input: "go_zero",
want: "go_zero",
},
{
input: "Go_Zero",
want: "go_Zero",
},
}
for _, c := range cases {
ret := From(c.input).Untitle()
assert.Equal(t, c.want, ret)
}
}
func TestContainsAny(t *testing.T) {
type args struct {
s string
runes []rune
}
tests := []struct {
name string
args args
want bool
}{
{
name: "runes is empty",
args: args{
s: "test",
runes: []rune{},
},
want: true,
},
{
name: "s is empty and runes is not empty",
args: args{
s: "",
runes: []rune{'a', 'b', 'c'},
},
want: false,
},
{
name: "s contains runes",
args: args{
s: "hello",
runes: []rune{'e', 'f'},
},
want: true,
},
{
name: "s does not contain runes",
args: args{
s: "hello",
runes: []rune{'x', 'y'},
},
want: false,
},
{
name: "s and runes both have one matching character",
args: args{
s: "a",
runes: []rune{'a'},
},
want: true,
},
{
name: "s and runes both have one non-matching character",
args: args{
s: "a",
runes: []rune{'b'},
},
want: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assert.Equalf(t, tt.want, ContainsAny(tt.args.s, tt.args.runes...), "ContainsAny(%v, %v)", tt.args.s, tt.args.runes)
})
}
}
func TestContainsWhiteSpace(t *testing.T) {
type args struct {
s string
}
tests := []struct {
name string
args args
want bool
}{
{
name: "contains space",
args: args{s: "hello world"},
want: true,
},
{
name: "contains newline",
args: args{s: "hello\nworld"},
want: true,
},
{
name: "contains tab",
args: args{s: "hello\tworld"},
want: true,
},
{
name: "contains form feed",
args: args{s: "hello\fworld"},
want: true,
},
{
name: "contains vertical tab",
args: args{s: "hello\vworld"},
want: true,
},
{
name: "no whitespace",
args: args{s: "helloworld"},
want: false,
},
{
name: "empty string",
args: args{s: ""},
want: false,
},
{
name: "only whitespace",
args: args{s: " \t\n\f\v"},
want: true,
},
{
name: "contains non-standard whitespace",
args: args{s: "hello\u00A0world"},
want: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assert.Equalf(t, tt.want, ContainsWhiteSpace(tt.args.s), "ContainsWhiteSpace(%v)", tt.args.s)
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/console/console.go | tools/goctl/util/console/console.go | package console
import (
"fmt"
"os"
"github.com/gookit/color"
)
type (
// Console wraps from the fmt.Sprintf,
// by default, it implemented the colorConsole to provide the colorful output to the console
// and the ideaConsole to output with prefix for the plugin of intellij
Console interface {
Success(format string, a ...any)
Info(format string, a ...any)
Debug(format string, a ...any)
Warning(format string, a ...any)
Error(format string, a ...any)
Fatalln(format string, a ...any)
MarkDone()
Must(err error)
}
colorConsole struct {
enable bool
}
// for idea log
ideaConsole struct{}
)
// NewConsole returns an instance of Console
func NewConsole(idea bool) Console {
if idea {
return NewIdeaConsole()
}
return NewColorConsole()
}
// NewColorConsole returns an instance of colorConsole
func NewColorConsole(enable ...bool) Console {
logEnable := true
for _, e := range enable {
logEnable = e
}
return &colorConsole{
enable: logEnable,
}
}
func (c *colorConsole) Info(format string, a ...any) {
if !c.enable {
return
}
msg := fmt.Sprintf(format, a...)
fmt.Println(msg)
}
func (c *colorConsole) Debug(format string, a ...any) {
if !c.enable {
return
}
println(color.LightCyan.Sprintf(format, a...))
}
func (c *colorConsole) Success(format string, a ...any) {
if !c.enable {
return
}
println(color.LightGreen.Sprintf(format, a...))
}
func (c *colorConsole) Warning(format string, a ...any) {
if !c.enable {
return
}
println(color.LightYellow.Sprintf(format, a...))
}
func (c *colorConsole) Error(format string, a ...any) {
if !c.enable {
return
}
println(color.LightRed.Sprintf(format, a...))
}
func (c *colorConsole) Fatalln(format string, a ...any) {
if !c.enable {
return
}
c.Error(format, a...)
os.Exit(1)
}
func (c *colorConsole) MarkDone() {
if !c.enable {
return
}
c.Success("Done.")
}
func (c *colorConsole) Must(err error) {
if !c.enable {
return
}
if err != nil {
c.Fatalln("%+v", err)
}
}
// NewIdeaConsole returns an instance of ideaConsole
func NewIdeaConsole() Console {
return &ideaConsole{}
}
func (i *ideaConsole) Info(format string, a ...any) {
msg := fmt.Sprintf(format, a...)
fmt.Println(msg)
}
func (i *ideaConsole) Debug(format string, a ...any) {
fmt.Println(color.LightCyan.Sprintf(format, a...))
}
func (i *ideaConsole) Success(format string, a ...any) {
msg := fmt.Sprintf(format, a...)
fmt.Println("[SUCCESS]: ", msg)
}
func (i *ideaConsole) Warning(format string, a ...any) {
msg := fmt.Sprintf(format, a...)
fmt.Println("[WARNING]: ", msg)
}
func (i *ideaConsole) Error(format string, a ...any) {
msg := fmt.Sprintf(format, a...)
fmt.Println("[ERROR]: ", msg)
}
func (i *ideaConsole) Fatalln(format string, a ...any) {
i.Error(format, a...)
os.Exit(1)
}
func (i *ideaConsole) MarkDone() {
i.Success("Done.")
}
func (i *ideaConsole) Must(err error) {
if err != nil {
i.Fatalln("%+v", err)
}
}
func println(msg any) {
fmt.Println(msg)
}
var defaultConsole = &colorConsole{enable: true}
func Success(format string, a ...any) {
defaultConsole.Success(format, a...)
}
func Info(format string, a ...any) {
defaultConsole.Info(format, a...)
}
func Debug(format string, a ...any) {
defaultConsole.Debug(format, a...)
}
func Warning(format string, a ...any) {
defaultConsole.Warning(format, a...)
}
func Error(format string, a ...any) {
defaultConsole.Error(format, a...)
}
func Fatalln(format string, a ...any) {
defaultConsole.Fatalln(format, a...)
}
func MarkDone() {
defaultConsole.MarkDone()
}
func Must(err error) {
defaultConsole.Must(err)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/gowork_test.go | tools/goctl/util/ctx/gowork_test.go | package ctx
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func Test_isGoWork(t *testing.T) {
dir := filepath.Join("/tmp", stringx.Rand())
err := pathx.MkdirIfNotExist(dir)
assert.Nil(t, err)
defer os.RemoveAll(dir)
gowork, err := isGoWork(dir)
assert.False(t, gowork)
assert.Nil(t, err)
_, err = execx.Run("go work init", dir)
assert.Nil(t, err)
gowork, err = isGoWork(dir)
assert.True(t, gowork)
assert.Nil(t, err)
subDir := filepath.Join(dir, stringx.Rand())
err = pathx.MkdirIfNotExist(subDir)
assert.Nil(t, err)
gowork, err = isGoWork(subDir)
assert.True(t, gowork)
assert.Nil(t, err)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/modcheck_test.go | tools/goctl/util/ctx/modcheck_test.go | package ctx
import (
"go/build"
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func TestIsGoMod(t *testing.T) {
// create mod project
dft := build.Default
gp := dft.GOPATH
if len(gp) == 0 {
return
}
projectName := stringx.Rand()
dir := filepath.Join(gp, "src", projectName)
err := pathx.MkdirIfNotExist(dir)
if err != nil {
return
}
_, err = execx.Run("go mod init "+projectName, dir)
assert.Nil(t, err)
defer func() {
_ = os.RemoveAll(dir)
}()
isGoMod, err := IsGoMod(dir)
assert.Nil(t, err)
assert.Equal(t, true, isGoMod)
}
func TestIsGoModNot(t *testing.T) {
dft := build.Default
gp := dft.GOPATH
if len(gp) == 0 {
return
}
projectName := stringx.Rand()
dir := filepath.Join(gp, "src", projectName)
err := pathx.MkdirIfNotExist(dir)
if err != nil {
return
}
defer func() {
_ = os.RemoveAll(dir)
}()
isGoMod, err := IsGoMod(dir)
assert.Nil(t, err)
assert.Equal(t, false, isGoMod)
}
func TestIsGoModWorkDirIsNil(t *testing.T) {
_, err := IsGoMod("")
assert.Equal(t, err.Error(), func() string {
return "the work directory is not found"
}())
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/context_test.go | tools/goctl/util/ctx/context_test.go | package ctx
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestBackground(t *testing.T) {
workDir := "."
ctx, err := Prepare(workDir)
assert.Nil(t, err)
assert.True(t, true, func() bool {
return len(ctx.Dir) != 0 && len(ctx.Path) != 0
}())
}
func TestBackgroundNilWorkDir(t *testing.T) {
workDir := ""
_, err := Prepare(workDir)
assert.NotNil(t, err)
}
func TestPrepareWithModule(t *testing.T) {
tests := []struct {
name string
moduleName string
expectMod string
}{
{
name: "custom module name",
moduleName: "github.com/example/testmodule",
expectMod: "github.com/example/testmodule",
},
{
name: "simple module name",
moduleName: "simplemodule",
expectMod: "simplemodule",
},
{
name: "empty module name uses directory",
moduleName: "",
expectMod: "", // Will be set to directory name
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create a temporary directory for testing
tempDir, err := os.MkdirTemp("", "goctl-ctx-test-*")
require.NoError(t, err)
defer os.RemoveAll(tempDir)
testDir := filepath.Join(tempDir, "testproject")
err = os.MkdirAll(testDir, 0755)
require.NoError(t, err)
ctx, err := PrepareWithModule(testDir, tt.moduleName)
assert.NoError(t, err)
assert.NotNil(t, ctx)
// Check that the context has expected values
assert.NotEmpty(t, ctx.WorkDir)
assert.NotEmpty(t, ctx.Name)
assert.NotEmpty(t, ctx.Path)
assert.NotEmpty(t, ctx.Dir)
// Check that go.mod was created
goModPath := filepath.Join(testDir, "go.mod")
assert.FileExists(t, goModPath)
// Verify module name in go.mod
content, err := os.ReadFile(goModPath)
require.NoError(t, err)
expectedModule := tt.expectMod
if expectedModule == "" {
expectedModule = "testproject" // directory name fallback
}
assert.Contains(t, string(content), "module "+expectedModule)
assert.Equal(t, expectedModule, ctx.Path)
})
}
}
func TestPrepareWithModule_ExistingGoMod(t *testing.T) {
// Create a temporary directory with existing go.mod
tempDir, err := os.MkdirTemp("", "goctl-ctx-test-*")
require.NoError(t, err)
defer os.RemoveAll(tempDir)
testDir := filepath.Join(tempDir, "existingproject")
err = os.MkdirAll(testDir, 0755)
require.NoError(t, err)
// Create existing go.mod file
existingGoMod := `module existing.com/project
go 1.21
`
goModPath := filepath.Join(testDir, "go.mod")
err = os.WriteFile(goModPath, []byte(existingGoMod), 0644)
require.NoError(t, err)
// PrepareWithModule should use existing go.mod, not create new one
ctx, err := PrepareWithModule(testDir, "github.com/new/module")
assert.NoError(t, err)
assert.NotNil(t, ctx)
// Should use existing module name, not the provided one
assert.Equal(t, "existing.com/project", ctx.Path)
// Verify go.mod still contains original content
content, err := os.ReadFile(goModPath)
require.NoError(t, err)
assert.Contains(t, string(content), "module existing.com/project")
assert.NotContains(t, string(content), "module github.com/new/module")
}
func TestPrepareWithModule_InvalidWorkDir(t *testing.T) {
_, err := PrepareWithModule("/non/existent/path", "github.com/example/test")
assert.Error(t, err)
}
func TestPrepare_CallsPrepareWithModule(t *testing.T) {
// Create a temporary directory for testing
tempDir, err := os.MkdirTemp("", "goctl-ctx-test-*")
require.NoError(t, err)
defer os.RemoveAll(tempDir)
testDir := filepath.Join(tempDir, "testproject")
err = os.MkdirAll(testDir, 0755)
require.NoError(t, err)
// Test that Prepare calls PrepareWithModule with empty string
ctx1, err1 := Prepare(testDir)
require.NoError(t, err1)
// Clean up go.mod to test again
os.Remove(filepath.Join(testDir, "go.mod"))
ctx2, err2 := PrepareWithModule(testDir, "")
require.NoError(t, err2)
// Should produce identical results
assert.Equal(t, ctx1.Path, ctx2.Path)
assert.Equal(t, ctx1.Name, ctx2.Name)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/gopath_test.go | tools/goctl/util/ctx/gopath_test.go | package ctx
import (
"go/build"
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func TestProjectFromGoPath(t *testing.T) {
dft := build.Default
gp := dft.GOPATH
if len(gp) == 0 {
return
}
projectName := stringx.Rand()
dir := filepath.Join(gp, "src", projectName)
err := pathx.MkdirIfNotExist(dir)
if err != nil {
return
}
defer func() {
_ = os.RemoveAll(dir)
}()
ctx, err := projectFromGoPath(dir)
assert.Nil(t, err)
assert.Equal(t, dir, ctx.Dir)
assert.Equal(t, projectName, ctx.Path)
}
func TestProjectFromGoPathNotInGoSrc(t *testing.T) {
dft := build.Default
gp := dft.GOPATH
if len(gp) == 0 {
return
}
projectName := stringx.Rand()
dir := filepath.Join(gp, "src", projectName)
err := pathx.MkdirIfNotExist(dir)
if err != nil {
return
}
defer func() {
_ = os.RemoveAll(dir)
}()
_, err = projectFromGoPath("testPath")
assert.NotNil(t, err)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/gomod_test.go | tools/goctl/util/ctx/gomod_test.go | package ctx
import (
"bytes"
"go/build"
"io"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func TestProjectFromGoMod(t *testing.T) {
dft := build.Default
gp := dft.GOPATH
if len(gp) == 0 {
return
}
projectName := stringx.Rand()
dir := filepath.Join(gp, "src", projectName)
err := pathx.MkdirIfNotExist(dir)
if err != nil {
return
}
_, err = execx.Run("go mod init "+projectName, dir)
assert.Nil(t, err)
defer func() {
_ = os.RemoveAll(dir)
}()
ctx, err := projectFromGoMod(dir)
assert.Nil(t, err)
assert.Equal(t, projectName, ctx.Path)
assert.Equal(t, dir, ctx.Dir)
}
func Test_getRealModule(t *testing.T) {
type args struct {
workDir string
execRun execx.RunFunc
}
tests := []struct {
name string
args args
want *Module
wantErr bool
}{
{
name: "single module",
args: args{
workDir: "/home/foo",
execRun: func(arg, dir string, in ...*bytes.Buffer) (string, error) {
return `{
"Path":"foo",
"Dir":"/home/foo",
"GoMod":"/home/foo/go.mod",
"GoVersion":"go1.16"}`, nil
},
},
want: &Module{
Path: "foo",
Dir: "/home/foo",
GoMod: "/home/foo/go.mod",
GoVersion: "go1.16",
},
},
{
name: "go work multiple modules",
args: args{
workDir: "/home/bar",
execRun: func(arg, dir string, in ...*bytes.Buffer) (string, error) {
return `
{
"Path":"foo",
"Dir":"/home/foo",
"GoMod":"/home/foo/go.mod",
"GoVersion":"go1.20"
}
{
"Path":"bar",
"Dir":"/home/bar",
"GoMod":"/home/bar/go.mod",
"GoVersion":"go1.20"
}`, nil
},
},
want: &Module{
Path: "bar",
Dir: "/home/bar",
GoMod: "/home/bar/go.mod",
GoVersion: "go1.20",
},
},
{
name: "go work duplicate prefix",
args: args{
workDir: "/code/company/core-ee/service",
execRun: func(arg, dir string, in ...*bytes.Buffer) (string, error) {
return `
{
"Path": "gitee.com/unitedrhino/core",
"Dir": "/code/company/core",
"GoMod": "/code/company/core/go.mod",
"GoVersion": "1.21.4"
}
{
"Path": "gitee.com/unitedrhino/core-ee",
"Dir": "/code/company/core-ee",
"GoMod": "/code/company/core-ee/go.mod",
"GoVersion": "1.21.4"
}`, nil
},
},
want: &Module{
Path: "gitee.com/unitedrhino/core-ee",
Dir: "/code/company/core-ee",
GoMod: "/code/company/core-ee/go.mod",
GoVersion: "1.21.4",
},
},
{
name: "go work duplicate prefix2",
args: args{
workDir: "/code/company/core-ee",
execRun: func(arg, dir string, in ...*bytes.Buffer) (string, error) {
return `
{
"Path": "gitee.com/unitedrhino/core",
"Dir": "/code/company/core",
"GoMod": "/code/company/core/go.mod",
"GoVersion": "1.21.4"
}
{
"Path": "gitee.com/unitedrhino/core-ee",
"Dir": "/code/company/core-ee",
"GoMod": "/code/company/core-ee/go.mod",
"GoVersion": "1.21.4"
}`, nil
},
},
want: &Module{
Path: "gitee.com/unitedrhino/core-ee",
Dir: "/code/company/core-ee",
GoMod: "/code/company/core-ee/go.mod",
GoVersion: "1.21.4",
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := getRealModule(tt.args.workDir, tt.args.execRun)
if (err != nil) != tt.wantErr {
t.Errorf("getRealModule() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("getRealModule() = %v, want %v", got, tt.want)
}
})
}
}
func TestDecodePackages(t *testing.T) {
tests := []struct {
name string
data io.Reader
want []Module
wantErr bool
}{
{
name: "single module",
data: strings.NewReader(`{
"Path":"foo",
"Dir":"/home/foo",
"GoMod":"/home/foo/go.mod",
"GoVersion":"go1.16"}`),
want: []Module{
{
Path: "foo",
Dir: "/home/foo",
GoMod: "/home/foo/go.mod",
GoVersion: "go1.16",
},
},
},
{
name: "go work multiple modules",
data: strings.NewReader(`
{
"Path":"foo",
"Dir":"/home/foo",
"GoMod":"/home/foo/go.mod",
"GoVersion":"go1.20"
}
{
"Path":"bar",
"Dir":"/home/bar",
"GoMod":"/home/bar/go.mod",
"GoVersion":"go1.20"
}`),
want: []Module{
{
Path: "foo",
Dir: "/home/foo",
GoMod: "/home/foo/go.mod",
GoVersion: "go1.20",
},
{
Path: "bar",
Dir: "/home/bar",
GoMod: "/home/bar/go.mod",
GoVersion: "go1.20",
},
},
},
{
name: "There are extra characters at the beginning",
data: strings.NewReader(`Active code page: 65001
{
"Path":"foo",
"Dir":"/home/foo",
"GoMod":"/home/foo/go.mod",
"GoVersion":"go1.20"
}`),
want: []Module{
{
Path: "foo",
Dir: "/home/foo",
GoMod: "/home/foo/go.mod",
GoVersion: "go1.20",
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := decodePackages(tt.data)
if err != nil {
t.Errorf("decodePackages() error %v,wantErr = %v", err, tt.wantErr)
}
if !reflect.DeepEqual(result, tt.want) {
t.Errorf("decodePackages() = %v,want %v", result, tt.want)
}
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/gomod.go | tools/goctl/util/ctx/gomod.go | package ctx
import (
"bufio"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const goModuleWithoutGoFiles = "command-line-arguments"
var errInvalidGoMod = errors.New("invalid go module")
// Module contains the relative data of go module,
// which is the result of the command go list
type Module struct {
Path string
Main bool
Dir string
GoMod string
GoVersion string
}
func (m *Module) validate() error {
if m.Path == goModuleWithoutGoFiles || m.Dir == "" {
return errInvalidGoMod
}
return nil
}
// projectFromGoMod is used to find the go module and project file path
// the workDir flag specifies which folder we need to detect based on
// only valid for go mod project
func projectFromGoMod(workDir string) (*ProjectContext, error) {
if len(workDir) == 0 {
return nil, errors.New("the work directory is not found")
}
if _, err := os.Stat(workDir); err != nil {
return nil, err
}
workDir, err := pathx.ReadLink(workDir)
if err != nil {
return nil, err
}
if err := UpdateGoWorkIfExist(workDir); err != nil {
return nil, err
}
m, err := getRealModule(workDir, execx.Run)
if err != nil {
return nil, err
}
if err := m.validate(); err != nil {
return nil, err
}
var ret ProjectContext
ret.WorkDir = workDir
ret.Name = filepath.Base(m.Dir)
dir, err := pathx.ReadLink(m.Dir)
if err != nil {
return nil, err
}
ret.Dir = dir
ret.Path = m.Path
return &ret, nil
}
func getRealModule(workDir string, execRun execx.RunFunc) (*Module, error) {
data, err := execRun("go list -json -m", workDir)
if err != nil {
return nil, err
}
modules, err := decodePackages(strings.NewReader(data))
if err != nil {
return nil, err
}
if workDir[len(workDir)-1] != os.PathSeparator {
workDir = workDir + string(os.PathSeparator)
}
for _, m := range modules {
realDir, err := pathx.ReadLink(m.Dir)
if err != nil {
return nil, fmt.Errorf("failed to read go.mod, dir: %s, error: %w", m.Dir, err)
}
realDir += string(os.PathSeparator)
if strings.HasPrefix(workDir, realDir) {
return &m, nil
}
}
return nil, errors.New("no matched module")
}
func decodePackages(reader io.Reader) ([]Module, error) {
br := bufio.NewReader(reader)
if _, err := br.ReadSlice('{'); err != nil {
return nil, err
}
if err := br.UnreadByte(); err != nil {
return nil, err
}
var modules []Module
decoder := json.NewDecoder(br)
for decoder.More() {
var m Module
if err := decoder.Decode(&m); err != nil {
return nil, fmt.Errorf("invalid module: %v", err)
}
modules = append(modules, m)
}
return modules, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/gowork.go | tools/goctl/util/ctx/gowork.go | package ctx
import (
"errors"
"os"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
)
// UpdateGoWorkIfExist updates go work if workDir is in a go workspace
func UpdateGoWorkIfExist(workDir string) error {
if isGoWork, err := isGoWork(workDir); !isGoWork || err != nil {
return err
}
_, err := execx.Run("go work use .", workDir)
return err
}
// isGoWork detect if the workDir is in a go workspace
func isGoWork(workDir string) (bool, error) {
if len(workDir) == 0 {
return false, errors.New("the work directory is not found")
}
if _, err := os.Stat(workDir); err != nil {
return false, err
}
goWorkPath, err := execx.Run("go env GOWORK", workDir)
if err != nil {
return false, err
}
return len(goWorkPath) > 0, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/context.go | tools/goctl/util/ctx/context.go | package ctx
import (
"errors"
"path/filepath"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
)
var errModuleCheck = errors.New("the work directory must be found in the go mod or the $GOPATH")
// ProjectContext is a structure for the project,
// which contains WorkDir, Name, Path and Dir
type ProjectContext struct {
WorkDir string
// Name is the root name of the project
// eg: go-zero、greet
Name string
// Path identifies which module a project belongs to, which is module value if it's a go mod project,
// or else it is the root name of the project, eg: github.com/zeromicro/go-zero、greet
Path string
// Dir is the path of the project, eg: /Users/keson/goland/go/go-zero、/Users/keson/go/src/greet
Dir string
}
// Prepare checks the project which module belongs to,and returns the path and module.
// workDir parameter is the directory of the source of generating code,
// where can be found the project path and the project module,
func Prepare(workDir string) (*ProjectContext, error) {
return PrepareWithModule(workDir, "")
}
// PrepareWithModule checks the project which module belongs to,and returns the path and module.
// workDir parameter is the directory of the source of generating code,
// where can be found the project path and the project module,
// moduleName parameter is the custom module name to use if creating a new go.mod
func PrepareWithModule(workDir string, moduleName string) (*ProjectContext, error) {
ctx, err := background(workDir)
if err == nil {
return ctx, nil
}
var name string
if len(moduleName) > 0 {
name = moduleName
} else {
name = filepath.Base(workDir)
}
_, err = execx.Run("go mod init "+name, workDir)
if err != nil {
return nil, err
}
return background(workDir)
}
func background(workDir string) (*ProjectContext, error) {
isGoMod, err := IsGoMod(workDir)
if err != nil {
return nil, err
}
if isGoMod {
return projectFromGoMod(workDir)
}
return projectFromGoPath(workDir)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/modcheck.go | tools/goctl/util/ctx/modcheck.go | package ctx
import (
"errors"
"os"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
)
// IsGoMod is used to determine whether workDir is a go module project through command `go env GOMOD`
func IsGoMod(workDir string) (bool, error) {
if len(workDir) == 0 {
return false, errors.New("the work directory is not found")
}
if _, err := os.Stat(workDir); err != nil {
return false, err
}
data, err := execx.Run("go env GOMOD", workDir)
if err != nil || data == "/dev/null" {
return false, nil
}
return true, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/ctx/gopath.go | tools/goctl/util/ctx/gopath.go | package ctx
import (
"errors"
"go/build"
"os"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
// projectFromGoPath is used to find the main module and project file path
// the workDir flag specifies which folder we need to detect based on
// only valid for go mod project
func projectFromGoPath(workDir string) (*ProjectContext, error) {
if len(workDir) == 0 {
return nil, errors.New("the work directory is not found")
}
if _, err := os.Stat(workDir); err != nil {
return nil, err
}
workDir, err := pathx.ReadLink(workDir)
if err != nil {
return nil, err
}
buildContext := build.Default
goPath := buildContext.GOPATH
goPath, err = pathx.ReadLink(goPath)
if err != nil {
return nil, err
}
goSrc := filepath.Join(goPath, "src")
if !pathx.FileExists(goSrc) {
return nil, errModuleCheck
}
wd, err := filepath.Abs(workDir)
if err != nil {
return nil, err
}
if !strings.HasPrefix(wd, goSrc) {
return nil, errModuleCheck
}
projectName := strings.TrimPrefix(wd, goSrc+string(filepath.Separator))
return &ProjectContext{
WorkDir: workDir,
Name: projectName,
Path: projectName,
Dir: filepath.Join(goSrc, projectName),
}, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/zipx/zipx.go | tools/goctl/util/zipx/zipx.go | package zipx
import (
"archive/zip"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func Unpacking(name, destPath string, mapper func(f *zip.File) bool) error {
r, err := zip.OpenReader(name)
if err != nil {
return err
}
defer r.Close()
destAbsPath, err := filepath.Abs(destPath)
if err != nil {
return err
}
for _, file := range r.File {
ok := mapper(file)
if ok {
err = fileCopy(file, destAbsPath)
if err != nil {
return err
}
}
}
return nil
}
func fileCopy(file *zip.File, destPath string) error {
rc, err := file.Open()
if err != nil {
return err
}
defer rc.Close()
// Ensure the file path does not contain directory traversal elements
if strings.Contains(file.Name, "..") {
return fmt.Errorf("invalid file path: %s", file.Name)
}
abs, err := filepath.Abs(file.Name)
if err != nil {
return err
}
filename := filepath.Join(destPath, filepath.Base(abs))
dir := filepath.Dir(filename)
err = pathx.MkdirIfNotExist(dir)
if err != nil {
return err
}
w, err := os.Create(filename)
if err != nil {
return err
}
defer w.Close()
_, err = io.Copy(w, rc)
return err
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/format/format.go | tools/goctl/util/format/format.go | package format
import (
"bytes"
"errors"
"fmt"
"io"
"strings"
)
const (
flagGo = "GO"
flagZero = "ZERO"
unknown style = iota
title
lower
upper
)
// ErrNamingFormat defines an error for unknown format
var ErrNamingFormat = errors.New("unsupported format")
type (
styleFormat struct {
before string
through string
after string
goStyle style
zeroStyle style
}
style int
)
// FileNamingFormat is used to format the file name. You can define the format style
// through the go and zero formatting characters. For example, you can define the snake
// format as go_zero, and the camel case format as goZero. You can even specify the split
// character, such as go#Zero, theoretically any combination can be used, but the prerequisite
// must meet the naming conventions of each operating system file name.
// Note: Formatting is based on snake or camel string
func FileNamingFormat(format, content string) (string, error) {
upperFormat := strings.ToUpper(format)
indexGo := strings.Index(upperFormat, flagGo)
indexZero := strings.Index(upperFormat, flagZero)
if indexGo < 0 || indexZero < 0 || indexGo > indexZero {
return "", ErrNamingFormat
}
var (
before, through, after string
flagGo, flagZero string
goStyle, zeroStyle style
err error
)
before = format[:indexGo]
flagGo = format[indexGo : indexGo+2]
through = format[indexGo+2 : indexZero]
flagZero = format[indexZero : indexZero+4]
after = format[indexZero+4:]
goStyle, err = getStyle(flagGo)
if err != nil {
return "", err
}
zeroStyle, err = getStyle(flagZero)
if err != nil {
return "", err
}
var formatStyle styleFormat
formatStyle.goStyle = goStyle
formatStyle.zeroStyle = zeroStyle
formatStyle.before = before
formatStyle.through = through
formatStyle.after = after
return doFormat(formatStyle, content)
}
func doFormat(f styleFormat, content string) (string, error) {
splits, err := split(content)
if err != nil {
return "", err
}
var join []string
for index, split := range splits {
if index == 0 {
join = append(join, transferTo(split, f.goStyle))
continue
}
join = append(join, transferTo(split, f.zeroStyle))
}
joined := strings.Join(join, f.through)
return f.before + joined + f.after, nil
}
func transferTo(in string, style style) string {
switch style {
case upper:
return strings.ToUpper(in)
case lower:
return strings.ToLower(in)
case title:
return strings.Title(in)
default:
return in
}
}
func split(content string) ([]string, error) {
var (
list []string
reader = strings.NewReader(content)
buffer = bytes.NewBuffer(nil)
)
for {
r, _, err := reader.ReadRune()
if err != nil {
if errors.Is(err, io.EOF) {
if buffer.Len() > 0 {
list = append(list, buffer.String())
}
return list, nil
}
return nil, err
}
if r == '_' {
if buffer.Len() > 0 {
list = append(list, buffer.String())
}
buffer.Reset()
continue
}
if r >= 'A' && r <= 'Z' {
if buffer.Len() > 0 {
list = append(list, buffer.String())
}
buffer.Reset()
}
buffer.WriteRune(r)
}
}
func getStyle(flag string) (style, error) {
compare := strings.ToLower(flag)
switch flag {
case strings.ToLower(compare):
return lower, nil
case strings.ToUpper(compare):
return upper, nil
case strings.Title(compare):
return title, nil
default:
return unknown, fmt.Errorf("unexpected format: %s", flag)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/format/format_test.go | tools/goctl/util/format/format_test.go | package format
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestSplit(t *testing.T) {
list, err := split("A")
assert.Nil(t, err)
assert.Equal(t, []string{"A"}, list)
list, err = split("goZero")
assert.Nil(t, err)
assert.Equal(t, []string{"go", "Zero"}, list)
list, err = split("Gozero")
assert.Nil(t, err)
assert.Equal(t, []string{"Gozero"}, list)
list, err = split("go_zero")
assert.Nil(t, err)
assert.Equal(t, []string{"go", "zero"}, list)
list, err = split("talGo_zero")
assert.Nil(t, err)
assert.Equal(t, []string{"tal", "Go", "zero"}, list)
list, err = split("GOZERO")
assert.Nil(t, err)
assert.Equal(t, []string{"G", "O", "Z", "E", "R", "O"}, list)
list, err = split("gozero")
assert.Nil(t, err)
assert.Equal(t, []string{"gozero"}, list)
list, err = split("")
assert.Nil(t, err)
assert.Equal(t, 0, len(list))
list, err = split("a_b_CD_EF")
assert.Nil(t, err)
assert.Equal(t, []string{"a", "b", "C", "D", "E", "F"}, list)
list, err = split("_")
assert.Nil(t, err)
assert.Equal(t, 0, len(list))
list, err = split("__")
assert.Nil(t, err)
assert.Equal(t, 0, len(list))
list, err = split("_A")
assert.Nil(t, err)
assert.Equal(t, []string{"A"}, list)
list, err = split("_A_")
assert.Nil(t, err)
assert.Equal(t, []string{"A"}, list)
list, err = split("A_")
assert.Nil(t, err)
assert.Equal(t, []string{"A"}, list)
list, err = split("welcome_to_go_zero")
assert.Nil(t, err)
assert.Equal(t, []string{"welcome", "to", "go", "zero"}, list)
}
func TestFileNamingFormat(t *testing.T) {
testFileNamingFormat(t, "gozero", "welcome_to_go_zero", "welcometogozero")
testFileNamingFormat(t, "_go#zero_", "welcome_to_go_zero", "_welcome#to#go#zero_")
testFileNamingFormat(t, "Go#zero", "welcome_to_go_zero", "Welcome#to#go#zero")
testFileNamingFormat(t, "Go#Zero", "welcome_to_go_zero", "Welcome#To#Go#Zero")
testFileNamingFormat(t, "Go_Zero", "welcome_to_go_zero", "Welcome_To_Go_Zero")
testFileNamingFormat(t, "go_Zero", "welcome_to_go_zero", "welcome_To_Go_Zero")
testFileNamingFormat(t, "goZero", "welcome_to_go_zero", "welcomeToGoZero")
testFileNamingFormat(t, "GoZero", "welcome_to_go_zero", "WelcomeToGoZero")
testFileNamingFormat(t, "GOZero", "welcome_to_go_zero", "WELCOMEToGoZero")
testFileNamingFormat(t, "GoZERO", "welcome_to_go_zero", "WelcomeTOGOZERO")
testFileNamingFormat(t, "GOZERO", "welcome_to_go_zero", "WELCOMETOGOZERO")
testFileNamingFormat(t, "GO*ZERO", "welcome_to_go_zero", "WELCOME*TO*GO*ZERO")
testFileNamingFormat(t, "[GO#ZERO]", "welcome_to_go_zero", "[WELCOME#TO#GO#ZERO]")
testFileNamingFormat(t, "{go###zero}", "welcome_to_go_zero", "{welcome###to###go###zero}")
testFileNamingFormat(t, "{go###zerogo_zero}", "welcome_to_go_zero", "{welcome###to###go###zerogo_zero}")
testFileNamingFormat(t, "GogoZerozero", "welcome_to_go_zero", "WelcomegoTogoGogoZerozero")
testFileNamingFormat(t, "前缀GoZero后缀", "welcome_to_go_zero", "前缀WelcomeToGoZero后缀")
testFileNamingFormat(t, "GoZero", "welcometogozero", "Welcometogozero")
testFileNamingFormat(t, "GoZero", "WelcomeToGoZero", "WelcomeToGoZero")
testFileNamingFormat(t, "gozero", "WelcomeToGoZero", "welcometogozero")
testFileNamingFormat(t, "go_zero", "WelcomeToGoZero", "welcome_to_go_zero")
testFileNamingFormat(t, "Go_Zero", "WelcomeToGoZero", "Welcome_To_Go_Zero")
testFileNamingFormat(t, "Go_Zero", "", "")
testFileNamingFormatErr(t, "go", "")
testFileNamingFormatErr(t, "gOZero", "")
testFileNamingFormatErr(t, "zero", "")
testFileNamingFormatErr(t, "goZEro", "welcome_to_go_zero")
testFileNamingFormatErr(t, "goZERo", "welcome_to_go_zero")
testFileNamingFormatErr(t, "zerogo", "welcome_to_go_zero")
}
func testFileNamingFormat(t *testing.T, format, in, expected string) {
format, err := FileNamingFormat(format, in)
assert.Nil(t, err)
assert.Equal(t, expected, format)
}
func testFileNamingFormatErr(t *testing.T, format, in string) {
_, err := FileNamingFormat(format, in)
assert.Error(t, err)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/name/naming.go | tools/goctl/util/name/naming.go | // Package name provides methods to verify naming style and format naming style
// See the method IsNamingValid, FormatFilename
package name
import (
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
// NamingStyle the type of string
type NamingStyle = string
const (
// NamingLower defines the lower spell case
NamingLower NamingStyle = "lower"
// NamingCamel defines the camel spell case
NamingCamel NamingStyle = "camel"
// NamingSnake defines the snake spell case
NamingSnake NamingStyle = "snake"
)
// IsNamingValid validates whether the namingStyle is valid or not,return
// namingStyle and true if it is valid, or else return empty string
// and false, and it is a valid value even namingStyle is empty string
func IsNamingValid(namingStyle string) (NamingStyle, bool) {
if len(namingStyle) == 0 {
namingStyle = NamingLower
}
switch namingStyle {
case NamingLower, NamingCamel, NamingSnake:
return namingStyle, true
default:
return "", false
}
}
// FormatFilename converts the filename string to the target
// naming style by calling method of stringx
func FormatFilename(filename string, style NamingStyle) string {
switch style {
case NamingCamel:
return stringx.From(filename).ToCamel()
case NamingSnake:
return stringx.From(filename).ToSnake()
default:
return strings.ToLower(stringx.From(filename).ToCamel())
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/name/naming_test.go | tools/goctl/util/name/naming_test.go | package name
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestIsNamingValid(t *testing.T) {
style, valid := IsNamingValid("")
assert.True(t, valid)
assert.Equal(t, NamingLower, style)
_, valid = IsNamingValid("lower1")
assert.False(t, valid)
_, valid = IsNamingValid("lower")
assert.True(t, valid)
_, valid = IsNamingValid("snake")
assert.True(t, valid)
_, valid = IsNamingValid("camel")
assert.True(t, valid)
}
func TestFormatFilename(t *testing.T) {
assert.Equal(t, "abc", FormatFilename("a_b_c", NamingLower))
assert.Equal(t, "ABC", FormatFilename("a_b_c", NamingCamel))
assert.Equal(t, "a_b_c", FormatFilename("a_b_c", NamingSnake))
assert.Equal(t, "a", FormatFilename("a", NamingSnake))
assert.Equal(t, "A", FormatFilename("a", NamingCamel))
// no flag to convert to snake
assert.Equal(t, "abc", FormatFilename("abc", NamingSnake))
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/pathx/file.go | tools/goctl/util/pathx/file.go | package pathx
import (
"bufio"
"crypto/md5"
"encoding/hex"
"fmt"
"io"
"io/fs"
"log"
"os"
"path/filepath"
"strings"
"github.com/gookit/color"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
)
// NL defines a new line.
const (
NL = "\n"
goctlDir = ".goctl"
gitDir = ".git"
autoCompleteDir = ".auto_complete"
cacheDir = "cache"
)
var goctlHome string
// RegisterGoctlHome register goctl home path.
func RegisterGoctlHome(home string) {
goctlHome = home
}
// CreateIfNotExist creates a file if it is not exists.
func CreateIfNotExist(file string) (*os.File, error) {
_, err := os.Stat(file)
if !os.IsNotExist(err) {
return nil, fmt.Errorf("%s already exist", file)
}
return os.Create(file)
}
// RemoveIfExist deletes the specified file if it is exists.
func RemoveIfExist(filename string) error {
if !FileExists(filename) {
return nil
}
return os.Remove(filename)
}
// RemoveOrQuit deletes the specified file if read a permit command from stdin.
func RemoveOrQuit(filename string) error {
if !FileExists(filename) {
return nil
}
fmt.Printf("%s exists, overwrite it?\nEnter to overwrite or Ctrl-C to cancel...",
color.New(color.BgRed, color.Bold).Render(filename))
bufio.NewReader(os.Stdin).ReadBytes('\n')
return os.Remove(filename)
}
// FileExists returns true if the specified file is exists.
func FileExists(file string) bool {
_, err := os.Stat(file)
return err == nil
}
// FileNameWithoutExt returns a file name without suffix.
func FileNameWithoutExt(file string) string {
return strings.TrimSuffix(file, filepath.Ext(file))
}
// GetGoctlHome returns the path value of the goctl, the default path is ~/.goctl, if the path has
// been set by calling the RegisterGoctlHome method, the user-defined path refers to.
func GetGoctlHome() (home string, err error) {
defer func() {
if err != nil {
return
}
info, err := os.Stat(home)
if err == nil && !info.IsDir() {
os.Rename(home, home+".old")
MkdirIfNotExist(home)
}
}()
if len(goctlHome) != 0 {
home = goctlHome
return
}
home, err = GetDefaultGoctlHome()
return
}
// GetDefaultGoctlHome returns the path value of the goctl home where Join $HOME with .goctl.
func GetDefaultGoctlHome() (string, error) {
var goctlHomeDir = goctlDir
home, err := os.UserHomeDir()
if err == nil {
goctlHomeDir = filepath.Join(home, goctlDir)
}
_ = MkdirIfNotExist(goctlHomeDir)
return goctlHomeDir, nil
}
// GetGitHome returns the git home of goctl.
func GetGitHome() (string, error) {
goctlH, err := GetGoctlHome()
if err != nil {
return "", err
}
return filepath.Join(goctlH, gitDir), nil
}
// GetAutoCompleteHome returns the auto_complete home of goctl.
func GetAutoCompleteHome() (string, error) {
goctlH, err := GetGoctlHome()
if err != nil {
return "", err
}
return filepath.Join(goctlH, autoCompleteDir), nil
}
// GetCacheDir returns the cache dit of goctl.
func GetCacheDir() (string, error) {
goctlH, err := GetGoctlHome()
if err != nil {
return "", err
}
return filepath.Join(goctlH, cacheDir), nil
}
// GetTemplateDir returns the category path value in GoctlHome where could get it by GetGoctlHome.
func GetTemplateDir(category string) (string, error) {
home, err := GetGoctlHome()
if err != nil {
return "", err
}
if home == goctlHome {
// backward compatible, it will be removed in the feature
// backward compatible start.
beforeTemplateDir := filepath.Join(home, version.GetGoctlVersion(), category)
entries, _ := os.ReadDir(beforeTemplateDir)
infos := make([]fs.FileInfo, 0, len(entries))
for _, entry := range entries {
info, err := entry.Info()
if err != nil {
continue
}
infos = append(infos, info)
}
var hasContent bool
for _, e := range infos {
if e.Size() > 0 {
hasContent = true
}
}
if hasContent {
return beforeTemplateDir, nil
}
// backward compatible end.
return filepath.Join(home, category), nil
}
return filepath.Join(home, version.GetGoctlVersion(), category), nil
}
// InitTemplates creates template files GoctlHome where could get it by GetGoctlHome.
func InitTemplates(category string, templates map[string]string) error {
dir, err := GetTemplateDir(category)
if err != nil {
return err
}
if err := MkdirIfNotExist(dir); err != nil {
return err
}
for k, v := range templates {
if err := createTemplate(filepath.Join(dir, k), v, false); err != nil {
return err
}
}
return nil
}
// CreateTemplate writes template into file even it is exists.
func CreateTemplate(category, name, content string) error {
dir, err := GetTemplateDir(category)
if err != nil {
return err
}
return createTemplate(filepath.Join(dir, name), content, true)
}
// Clean deletes all templates and removes the parent directory.
func Clean(category string) error {
dir, err := GetTemplateDir(category)
if err != nil {
return err
}
return os.RemoveAll(dir)
}
// LoadTemplate gets template content by the specified file.
func LoadTemplate(category, file, builtin string) (string, error) {
dir, err := GetTemplateDir(category)
if err != nil {
return "", err
}
file = filepath.Join(dir, file)
if !FileExists(file) {
return builtin, nil
}
content, err := os.ReadFile(file)
if err != nil {
return "", err
}
return string(content), nil
}
// SameFile compares the between path if the same path,
// it maybe the same path in case case-ignore, such as:
// /Users/go_zero and /Users/Go_zero, as far as we know,
// this case maybe appear on macOS and Windows.
func SameFile(path1, path2 string) (bool, error) {
stat1, err := os.Stat(path1)
if err != nil {
return false, err
}
stat2, err := os.Stat(path2)
if err != nil {
return false, err
}
return os.SameFile(stat1, stat2), nil
}
func createTemplate(file, content string, force bool) error {
if FileExists(file) && !force {
return nil
}
f, err := os.Create(file)
if err != nil {
return err
}
defer f.Close()
_, err = f.WriteString(content)
return err
}
// MustTempDir creates a temporary directory.
func MustTempDir() string {
dir, err := os.MkdirTemp("", "")
if err != nil {
log.Fatalln(err)
}
return dir
}
func Copy(src, dest string) error {
f, err := os.Open(src)
if err != nil {
return err
}
defer f.Close()
dir := filepath.Dir(dest)
err = MkdirIfNotExist(dir)
if err != nil {
return err
}
w, err := os.Create(dest)
if err != nil {
return err
}
w.Chmod(os.ModePerm)
defer w.Close()
_, err = io.Copy(w, f)
return err
}
func Hash(file string) (string, error) {
f, err := os.Open(file)
if err != nil {
return "", err
}
defer func() {
_ = f.Close()
}()
hash := md5.New()
_, err = io.Copy(hash, f)
if err != nil {
return "", err
}
return hex.EncodeToString(hash.Sum(nil)), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/pathx/path.go | tools/goctl/util/pathx/path.go | package pathx
import (
"fmt"
"os"
"path"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
const (
pkgSep = "/"
goModeIdentifier = "go.mod"
)
// JoinPackages calls strings.Join and returns
func JoinPackages(pkgs ...string) string {
return strings.Join(pkgs, pkgSep)
}
// MkdirIfNotExist makes directories if the input path is not exists
func MkdirIfNotExist(dir string) error {
if len(dir) == 0 {
return nil
}
if _, err := os.Stat(dir); os.IsNotExist(err) {
return os.MkdirAll(dir, os.ModePerm)
}
return nil
}
// PathFromGoSrc returns the path without slash where has been trim the prefix $GOPATH
func PathFromGoSrc() (string, error) {
dir, err := os.Getwd()
if err != nil {
return "", err
}
gopath := os.Getenv("GOPATH")
parent := path.Join(gopath, "src", vars.ProjectName)
pos := strings.Index(dir, parent)
if pos < 0 {
return "", fmt.Errorf("%s is not in GOPATH", dir)
}
// skip slash
return dir[len(parent)+1:], nil
}
// FindGoModPath returns the path in project where has file go.mod,
// it returns empty string if there is no go.mod file in project.
func FindGoModPath(dir string) (string, bool) {
absDir, err := filepath.Abs(dir)
if err != nil {
return "", false
}
absDir = strings.ReplaceAll(absDir, `\`, `/`)
var rootPath string
tempPath := absDir
hasGoMod := false
for {
if FileExists(filepath.Join(tempPath, goModeIdentifier)) {
rootPath = strings.TrimPrefix(absDir[len(tempPath):], "/")
hasGoMod = true
break
}
if tempPath == filepath.Dir(tempPath) {
break
}
tempPath = filepath.Dir(tempPath)
if tempPath == string(filepath.Separator) {
break
}
}
if hasGoMod {
return rootPath, true
}
return "", false
}
// FindProjectPath returns the parent directory where has file go.mod in project
func FindProjectPath(loc string) (string, bool) {
var dir string
if strings.IndexByte(loc, '/') == 0 {
dir = loc
} else {
wd, err := os.Getwd()
if err != nil {
return "", false
}
dir = filepath.Join(wd, loc)
}
for {
if FileExists(filepath.Join(dir, goModeIdentifier)) {
return dir, true
}
dir = filepath.Dir(dir)
if dir == "/" {
break
}
}
return "", false
}
func isLink(name string) (bool, error) {
fi, err := os.Lstat(name)
if err != nil {
return false, err
}
return fi.Mode()&os.ModeSymlink != 0, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/pathx/readlink.go | tools/goctl/util/pathx/readlink.go | //go:build linux || darwin || freebsd
package pathx
import (
"os"
"path/filepath"
)
// ReadLink returns the destination of the named symbolic link recursively.
func ReadLink(name string) (string, error) {
name, err := filepath.Abs(name)
if err != nil {
return "", err
}
if _, err := os.Lstat(name); err != nil {
return name, nil
}
// uncheck condition: ignore file path /var, maybe be temporary file path
if name == "/" || name == "/var" {
return name, nil
}
isLink, err := isLink(name)
if err != nil {
return "", err
}
if !isLink {
dir, base := filepath.Split(name)
dir = filepath.Clean(dir)
dir, err := ReadLink(dir)
if err != nil {
return "", err
}
return filepath.Join(dir, base), nil
}
link, err := os.Readlink(name)
if err != nil {
return "", err
}
dir, base := filepath.Split(link)
dir = filepath.Dir(dir)
dir, err = ReadLink(dir)
if err != nil {
return "", err
}
return filepath.Join(dir, base), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/pathx/file_test.go | tools/goctl/util/pathx/file_test.go | package pathx
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
)
func TestGetTemplateDir(t *testing.T) {
category := "foo"
t.Run("before_have_templates", func(t *testing.T) {
home := t.TempDir()
RegisterGoctlHome("")
RegisterGoctlHome(home)
v := version.GetGoctlVersion()
dir := filepath.Join(home, v, category)
err := MkdirIfNotExist(dir)
if err != nil {
return
}
tempFile := filepath.Join(dir, "bar.txt")
err = os.WriteFile(tempFile, []byte("foo"), os.ModePerm)
if err != nil {
return
}
templateDir, err := GetTemplateDir(category)
if err != nil {
return
}
assert.Equal(t, dir, templateDir)
RegisterGoctlHome("")
})
t.Run("before_has_no_template", func(t *testing.T) {
home := t.TempDir()
RegisterGoctlHome("")
RegisterGoctlHome(home)
dir := filepath.Join(home, category)
err := MkdirIfNotExist(dir)
if err != nil {
return
}
templateDir, err := GetTemplateDir(category)
if err != nil {
return
}
assert.Equal(t, dir, templateDir)
})
t.Run("default", func(t *testing.T) {
RegisterGoctlHome("")
dir, err := GetTemplateDir(category)
if err != nil {
return
}
assert.Contains(t, dir, version.BuildVersion)
})
}
func TestGetGitHome(t *testing.T) {
homeDir, err := os.UserHomeDir()
if err != nil {
return
}
actual, err := GetGitHome()
if err != nil {
return
}
expected := filepath.Join(homeDir, goctlDir, gitDir)
assert.Equal(t, expected, actual)
}
func TestGetGoctlHome(t *testing.T) {
t.Run("goctl_is_file", func(t *testing.T) {
tmpFile := filepath.Join(t.TempDir(), "a.tmp")
backupTempFile := tmpFile + ".old"
err := os.WriteFile(tmpFile, nil, 0o666)
if err != nil {
return
}
RegisterGoctlHome(tmpFile)
home, err := GetGoctlHome()
if err != nil {
return
}
info, err := os.Stat(home)
assert.Nil(t, err)
assert.True(t, info.IsDir())
_, err = os.Stat(backupTempFile)
assert.Nil(t, err)
})
t.Run("goctl_is_dir", func(t *testing.T) {
RegisterGoctlHome("")
dir := t.TempDir()
RegisterGoctlHome(dir)
home, err := GetGoctlHome()
assert.Nil(t, err)
assert.Equal(t, dir, home)
})
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/pathx/path_test.go | tools/goctl/util/pathx/path_test.go | package pathx
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
)
func TestReadLink(t *testing.T) {
dir, err := os.MkdirTemp("", "go-zero")
assert.Nil(t, err)
symLink := filepath.Join(dir, "test")
pwd, err := os.Getwd()
assertError(err, t)
err = os.Symlink(pwd, symLink)
assertError(err, t)
t.Run("linked", func(t *testing.T) {
ret, err := ReadLink(symLink)
assert.Nil(t, err)
assert.Equal(t, pwd, ret)
})
t.Run("unlink", func(t *testing.T) {
ret, err := ReadLink(pwd)
assert.Nil(t, err)
assert.Equal(t, pwd, ret)
})
}
func assertError(err error, t *testing.T) {
if err != nil {
t.Fatal(err)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/util/pathx/readlink+polyfill.go | tools/goctl/util/pathx/readlink+polyfill.go | //go:build windows
package pathx
func ReadLink(name string) (string, error) {
return name, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/cmd/root.go | tools/goctl/cmd/root.go | package cmd
import (
_ "embed"
"fmt"
"os"
"runtime"
"strings"
"text/template"
"github.com/gookit/color"
"github.com/spf13/cobra"
"github.com/withfig/autocomplete-tools/integrations/cobra"
"github.com/zeromicro/go-zero/tools/goctl/api"
"github.com/zeromicro/go-zero/tools/goctl/bug"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/docker"
"github.com/zeromicro/go-zero/tools/goctl/env"
"github.com/zeromicro/go-zero/tools/goctl/gateway"
"github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
"github.com/zeromicro/go-zero/tools/goctl/kube"
"github.com/zeromicro/go-zero/tools/goctl/migrate"
"github.com/zeromicro/go-zero/tools/goctl/model"
"github.com/zeromicro/go-zero/tools/goctl/quickstart"
"github.com/zeromicro/go-zero/tools/goctl/rpc"
"github.com/zeromicro/go-zero/tools/goctl/tpl"
"github.com/zeromicro/go-zero/tools/goctl/upgrade"
)
const (
codeFailure = 1
dash = "-"
doubleDash = "--"
assign = "="
)
var (
//go:embed usage.tpl
usageTpl string
rootCmd = cobrax.NewCommand("goctl")
)
// Execute executes the given command
func Execute() {
os.Args = supportGoStdFlag(os.Args)
if err := rootCmd.Execute(); err != nil {
fmt.Println(color.Red.Render(err.Error()))
os.Exit(codeFailure)
}
}
func supportGoStdFlag(args []string) []string {
copyArgs := append([]string(nil), args...)
parentCmd, _, err := rootCmd.Traverse(args[:1])
if err != nil { // ignore it to let cobra handle the error.
return copyArgs
}
for idx, arg := range copyArgs[0:] {
parentCmd, _, err = parentCmd.Traverse([]string{arg})
if err != nil { // ignore it to let cobra handle the error.
break
}
if !strings.HasPrefix(arg, dash) {
continue
}
flagExpr := strings.TrimPrefix(arg, doubleDash)
flagExpr = strings.TrimPrefix(flagExpr, dash)
flagName, flagValue := flagExpr, ""
assignIndex := strings.Index(flagExpr, assign)
if assignIndex > 0 {
flagName = flagExpr[:assignIndex]
flagValue = flagExpr[assignIndex:]
}
if !isBuiltin(flagName) {
// The method Flag can only match the user custom flags.
f := parentCmd.Flag(flagName)
if f == nil {
continue
}
if f.Shorthand == flagName {
continue
}
}
goStyleFlag := doubleDash + flagName
if assignIndex > 0 {
goStyleFlag += flagValue
}
copyArgs[idx] = goStyleFlag
}
return copyArgs
}
func isBuiltin(name string) bool {
return name == "version" || name == "help"
}
func init() {
cobra.AddTemplateFuncs(template.FuncMap{
"blue": blue,
"green": green,
"rpadx": rpadx,
"rainbow": rainbow,
})
rootCmd.Version = fmt.Sprintf(
"%s %s/%s", version.BuildVersion,
runtime.GOOS, runtime.GOARCH)
rootCmd.SetUsageTemplate(usageTpl)
rootCmd.AddCommand(api.Cmd, bug.Cmd, docker.Cmd, kube.Cmd, env.Cmd, gateway.Cmd, model.Cmd)
rootCmd.AddCommand(migrate.Cmd, quickstart.Cmd, rpc.Cmd, tpl.Cmd, upgrade.Cmd, config.Cmd)
rootCmd.Command.AddCommand(cobracompletefig.CreateCompletionSpecCommand())
rootCmd.MustInit()
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/cmd/usage.go | tools/goctl/cmd/usage.go | package cmd
import (
"fmt"
"github.com/gookit/color"
)
var colorRender = []func(v any) string{
func(v any) string {
return color.LightRed.Render(v)
},
func(v any) string {
return color.LightGreen.Render(v)
},
func(v any) string {
return color.LightYellow.Render(v)
},
func(v any) string {
return color.LightBlue.Render(v)
},
func(v any) string {
return color.LightMagenta.Render(v)
},
func(v any) string {
return color.LightCyan.Render(v)
},
}
func blue(s string) string {
return color.LightBlue.Render(s)
}
func green(s string) string {
return color.LightGreen.Render(s)
}
func rainbow(s string) string {
s0 := s[0]
return colorRender[int(s0)%(len(colorRender)-1)](s)
}
// rpadx adds padding to the right of a string.
func rpadx(s string, padding int) string {
template := fmt.Sprintf("%%-%ds", padding)
return rainbow(fmt.Sprintf(template, s))
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/plugin/plugin_test.go | tools/goctl/plugin/plugin_test.go | package plugin
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestGetPluginAndArgs(t *testing.T) {
bin, args := getPluginAndArgs("android")
assert.Equal(t, "android", bin)
assert.Equal(t, "", args)
bin, args = getPluginAndArgs("android=")
assert.Equal(t, "android", bin)
assert.Equal(t, "", args)
bin, args = getPluginAndArgs("android=-javaPackage com.tal")
assert.Equal(t, "android", bin)
assert.Equal(t, "-javaPackage com.tal", args)
bin, args = getPluginAndArgs("android=-javaPackage com.tal --lambda")
assert.Equal(t, "android", bin)
assert.Equal(t, "-javaPackage com.tal --lambda", args)
bin, args = getPluginAndArgs(`https://test-xjy-file.obs.cn-east-2.myhuaweicloud.com/202012/8a7ab6e1-e639-49d1-89cf-2ae6127a1e90n=-v 1`)
assert.Equal(t, "https://test-xjy-file.obs.cn-east-2.myhuaweicloud.com/202012/8a7ab6e1-e639-49d1-89cf-2ae6127a1e90n", bin)
assert.Equal(t, "-v 1", args)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/plugin/plugin.go | tools/goctl/plugin/plugin.go | package plugin
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/api/parser"
"github.com/zeromicro/go-zero/tools/goctl/api/spec"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const pluginArg = "_plugin"
// Plugin defines an api plugin
type Plugin struct {
Api *spec.ApiSpec
ApiFilePath string
Style string
Dir string
}
var (
// VarStringPlugin describes a plugin.
VarStringPlugin string
// VarStringDir describes a directory.
VarStringDir string
// VarStringAPI describes an API file.
VarStringAPI string
// VarStringStyle describes a style.
VarStringStyle string
)
// PluginCommand is the entry of goctl api plugin
func PluginCommand(_ *cobra.Command, _ []string) error {
ex, err := os.Executable()
if err != nil {
panic(err)
}
plugin := VarStringPlugin
if len(plugin) == 0 {
return errors.New("missing plugin")
}
transferData, err := prepareArgs()
if err != nil {
return err
}
bin, args := getPluginAndArgs(plugin)
bin, download, err := getCommand(bin)
if err != nil {
return err
}
if download {
defer func() {
_ = os.Remove(bin)
}()
}
content, err := execx.Run(bin+" "+args, filepath.Dir(ex), bytes.NewBuffer(transferData))
if err != nil {
return err
}
fmt.Println(content)
return nil
}
func prepareArgs() ([]byte, error) {
apiPath := VarStringAPI
var transferData Plugin
if len(apiPath) > 0 && pathx.FileExists(apiPath) {
api, err := parser.Parse(apiPath)
if err != nil {
return nil, err
}
transferData.Api = api
}
absApiFilePath, err := filepath.Abs(apiPath)
if err != nil {
return nil, err
}
transferData.ApiFilePath = absApiFilePath
dirAbs, err := filepath.Abs(VarStringDir)
if err != nil {
return nil, err
}
transferData.Dir = dirAbs
transferData.Style = VarStringStyle
data, err := json.Marshal(transferData)
if err != nil {
return nil, err
}
return data, nil
}
func getCommand(arg string) (string, bool, error) {
p, err := exec.LookPath(arg)
if err == nil {
abs, err := filepath.Abs(p)
if err != nil {
return "", false, err
}
return abs, false, nil
}
defaultErr := errors.New("invalid plugin value " + arg)
if strings.HasPrefix(arg, "http") {
items := strings.Split(arg, "/")
if len(items) == 0 {
return "", false, defaultErr
}
filename, err := filepath.Abs(pluginArg + items[len(items)-1])
if err != nil {
return "", false, err
}
err = downloadFile(filename, arg)
if err != nil {
return "", false, err
}
os.Chmod(filename, os.ModePerm)
return filename, true, nil
}
return arg, false, nil
}
func downloadFile(filepath, url string) error {
resp, err := http.Get(url)
if err != nil {
return err
}
defer func() {
_ = resp.Body.Close()
}()
out, err := os.Create(filepath)
if err != nil {
return err
}
defer func() {
_ = out.Close()
}()
_, err = io.Copy(out, resp.Body)
return err
}
// NewPlugin returns contextual resources when written in other languages
func NewPlugin() (*Plugin, error) {
var plugin Plugin
content, err := io.ReadAll(os.Stdin)
if err != nil {
return nil, err
}
var info struct {
ApiFilePath string
Style string
Dir string
}
err = json.Unmarshal(content, &info)
if err != nil {
return nil, err
}
plugin.ApiFilePath = info.ApiFilePath
plugin.Style = info.Style
plugin.Dir = info.Dir
api, err := parser.Parse(info.ApiFilePath)
if err != nil {
return nil, err
}
plugin.Api = api
return &plugin, nil
}
func getPluginAndArgs(arg string) (string, string) {
i := strings.Index(arg, "=")
if i <= 0 {
return arg, ""
}
return trimQuote(arg[:i]), trimQuote(arg[i+1:])
}
func trimQuote(in string) string {
in = strings.Trim(in, `"`)
in = strings.Trim(in, `'`)
in = strings.Trim(in, "`")
return in
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/plugin/demo/goctlplugin.go | tools/goctl/plugin/demo/goctlplugin.go | package main
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/plugin"
)
func main() {
plugin, err := plugin.NewPlugin()
if err != nil {
panic(err)
}
if plugin.Api != nil {
fmt.Printf("api: %+v \n", plugin.Api)
}
fmt.Println("Enjoy anything you want.")
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/upgrade/cmd.go | tools/goctl/upgrade/cmd.go | package upgrade
import "github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
// Cmd describes an upgrade command.
var Cmd = cobrax.NewCommand("upgrade", cobrax.WithRunE(upgrade))
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/upgrade/upgrade.go | tools/goctl/upgrade/upgrade.go | package upgrade
import (
"fmt"
"runtime"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
)
// upgrade gets the latest goctl by
// go install github.com/zeromicro/go-zero/tools/goctl@latest
func upgrade(_ *cobra.Command, _ []string) error {
cmd := `go install github.com/zeromicro/go-zero/tools/goctl@latest`
if runtime.GOOS == "windows" {
cmd = `go install github.com/zeromicro/go-zero/tools/goctl@latest`
}
info, err := execx.Run(cmd, "")
if err != nil {
return err
}
fmt.Print(info)
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/env/install.go | tools/goctl/env/install.go | package env
import "github.com/spf13/cobra"
func install(_ *cobra.Command, _ []string) error {
return Prepare(true, boolVarForce, boolVarVerbose)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/env/check.go | tools/goctl/env/check.go | package env
import (
"fmt"
"strings"
"time"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/pkg/env"
"github.com/zeromicro/go-zero/tools/goctl/pkg/protoc"
"github.com/zeromicro/go-zero/tools/goctl/pkg/protocgengo"
"github.com/zeromicro/go-zero/tools/goctl/pkg/protocgengogrpc"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
)
type bin struct {
name string
exists bool
get func(cacheDir string) (string, error)
}
var bins = []bin{
{
name: "protoc",
exists: protoc.Exists(),
get: protoc.Install,
},
{
name: "protoc-gen-go",
exists: protocgengo.Exists(),
get: protocgengo.Install,
},
{
name: "protoc-gen-go-grpc",
exists: protocgengogrpc.Exists(),
get: protocgengogrpc.Install,
},
}
func check(_ *cobra.Command, _ []string) error {
return Prepare(boolVarInstall, boolVarForce, boolVarVerbose)
}
func Prepare(install, force, verbose bool) error {
log := console.NewColorConsole(verbose)
pending := true
log.Info("[goctl-env]: preparing to check env")
defer func() {
if p := recover(); p != nil {
log.Error("%+v", p)
return
}
if pending {
log.Success("\n[goctl-env]: congratulations! your goctl environment is ready!")
} else {
log.Error(`
[goctl-env]: check env finish, some dependencies is not found in PATH, you can execute
command 'goctl env check --install' to install it, for details, please execute command
'goctl env check --help'`)
}
}()
for _, e := range bins {
time.Sleep(200 * time.Millisecond)
log.Info("")
log.Info("[goctl-env]: looking up %q", e.name)
if e.exists {
log.Success("[goctl-env]: %q is installed", e.name)
continue
}
log.Warning("[goctl-env]: %q is not found in PATH", e.name)
if install {
install := func() {
log.Info("[goctl-env]: preparing to install %q", e.name)
path, err := e.get(env.Get(env.GoctlCache))
if err != nil {
log.Error("[goctl-env]: an error interrupted the installation: %+v", err)
pending = false
} else {
log.Success("[goctl-env]: %q is already installed in %q", e.name, path)
}
}
if force {
install()
continue
}
console.Info("[goctl-env]: do you want to install %q [y: YES, n: No]", e.name)
for {
var in string
fmt.Scanln(&in)
var brk bool
switch {
case strings.EqualFold(in, "y"):
install()
brk = true
case strings.EqualFold(in, "n"):
pending = false
console.Info("[goctl-env]: %q installation is ignored", e.name)
brk = true
default:
console.Error("[goctl-env]: invalid input, input 'y' for yes, 'n' for no")
}
if brk {
break
}
}
} else {
pending = false
}
}
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/env/cmd.go | tools/goctl/env/cmd.go | package env
import "github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
var (
sliceVarWriteValue []string
boolVarForce bool
boolVarVerbose bool
boolVarInstall bool
// Cmd describes an env command.
Cmd = cobrax.NewCommand("env", cobrax.WithRunE(write))
installCmd = cobrax.NewCommand("install", cobrax.WithRunE(install))
checkCmd = cobrax.NewCommand("check", cobrax.WithRunE(check))
)
func init() {
// The root command flags
Cmd.Flags().StringSliceVarP(&sliceVarWriteValue, "write", "w")
Cmd.PersistentFlags().BoolVarP(&boolVarForce, "force", "f")
Cmd.PersistentFlags().BoolVarP(&boolVarVerbose, "verbose", "v")
// The sub-command flags
checkCmd.Flags().BoolVarP(&boolVarInstall, "install", "i")
// Add sub-command
Cmd.AddCommand(checkCmd, installCmd)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/env/env.go | tools/goctl/env/env.go | package env
import (
"fmt"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/pkg/env"
)
func write(_ *cobra.Command, args []string) error {
if len(sliceVarWriteValue) > 0 {
return env.WriteEnv(sliceVarWriteValue)
}
fmt.Println(env.Print(args...))
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/docker/docker.go | tools/goctl/docker/docker.go | package docker
import (
"errors"
"fmt"
"os"
"path"
"path/filepath"
"strings"
"text/template"
"github.com/gookit/color"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/env"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const (
dockerfileName = "Dockerfile"
etcDir = "etc"
yamlEtx = ".yaml"
)
// Docker describes a dockerfile
type Docker struct {
Chinese bool
GoMainFrom string
GoRelPath string
GoFile string
ExeFile string
BaseImage string
HasPort bool
Port int
Argument string
Version string
HasTimezone bool
Timezone string
}
// dockerCommand provides the entry for goctl docker
func dockerCommand(_ *cobra.Command, _ []string) (err error) {
defer func() {
if err == nil {
fmt.Println(color.Green.Render("Done."))
}
}()
goFile := varStringGo
home := varStringHome
version := varStringVersion
remote := varStringRemote
branch := varStringBranch
timezone := varStringTZ
if len(remote) > 0 {
repo, _ := util.CloneIntoGitHome(remote, branch)
if len(repo) > 0 {
home = repo
}
}
if len(version) > 0 {
version = version + "-"
}
if len(home) > 0 {
pathx.RegisterGoctlHome(home)
}
if len(goFile) > 0 && !pathx.FileExists(goFile) {
return fmt.Errorf("file %q not found", goFile)
}
base := varStringBase
port := varIntPort
etcDir := filepath.Join(filepath.Dir(goFile), etcDir)
if _, err := os.Stat(etcDir); os.IsNotExist(err) {
return generateDockerfile(goFile, base, port, version, timezone)
}
cfg, err := findConfig(goFile, etcDir)
if err != nil {
return err
}
if err := generateDockerfile(goFile, base, port, version, timezone, "-f", "etc/"+cfg); err != nil {
return err
}
projDir, ok := pathx.FindProjectPath(goFile)
if ok {
fmt.Printf("Hint: run \"docker build ...\" command in dir:\n %s\n", projDir)
}
return nil
}
func findConfig(file, dir string) (string, error) {
var files []string
err := filepath.Walk(dir, func(path string, f os.FileInfo, _ error) error {
if !f.IsDir() {
if filepath.Ext(f.Name()) == yamlEtx {
files = append(files, f.Name())
}
}
return nil
})
if err != nil {
return "", err
}
if len(files) == 0 {
return "", errors.New("no yaml file")
}
name := strings.TrimSuffix(filepath.Base(file), ".go")
for _, f := range files {
if strings.Index(f, name) == 0 {
return f, nil
}
}
return files[0], nil
}
func generateDockerfile(goFile, base string, port int, version, timezone string, args ...string) error {
var projPath string
var err error
if len(goFile) > 0 {
projPath, err = getFilePath(filepath.Dir(goFile))
if err != nil {
return err
}
}
if len(projPath) == 0 {
projPath = "."
}
out, err := pathx.CreateIfNotExist(dockerfileName)
if err != nil {
return err
}
defer out.Close()
text, err := pathx.LoadTemplate(category, dockerTemplateFile, dockerTemplate)
if err != nil {
return err
}
var builder strings.Builder
for _, arg := range args {
builder.WriteString(`, "` + arg + `"`)
}
var exeName string
if len(varExeName) > 0 {
exeName = varExeName
} else if len(goFile) > 0 {
exeName = pathx.FileNameWithoutExt(filepath.Base(goFile))
} else {
absPath, err := filepath.Abs(projPath)
if err != nil {
return err
}
exeName = filepath.Base(absPath)
}
t := template.Must(template.New("dockerfile").Parse(text))
return t.Execute(out, Docker{
Chinese: env.InChina(),
GoMainFrom: path.Join(projPath, filepath.Base(goFile)),
GoRelPath: projPath,
GoFile: goFile,
ExeFile: exeName,
BaseImage: base,
HasPort: port > 0,
Port: port,
Argument: builder.String(),
Version: version,
HasTimezone: len(timezone) > 0,
Timezone: timezone,
})
}
func getFilePath(file string) (string, error) {
wd, err := os.Getwd()
if err != nil {
return "", err
}
projPath, ok := pathx.FindGoModPath(filepath.Join(wd, file))
if !ok {
projPath, err = pathx.PathFromGoSrc()
if err != nil {
return "", errors.New("no go.mod found, or not in GOPATH")
}
// ignore project root directory for GOPATH mode
pos := strings.IndexByte(projPath, os.PathSeparator)
if pos >= 0 {
projPath = projPath[pos+1:]
}
}
return projPath, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/docker/cmd.go | tools/goctl/docker/cmd.go | package docker
import "github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
var (
varExeName string
varStringGo string
varStringBase string
varIntPort int
varStringHome string
varStringRemote string
varStringBranch string
varStringVersion string
varStringTZ string
// Cmd describes a docker command.
Cmd = cobrax.NewCommand("docker", cobrax.WithRunE(dockerCommand))
)
func init() {
dockerCmdFlags := Cmd.Flags()
dockerCmdFlags.StringVar(&varExeName, "exe")
dockerCmdFlags.StringVar(&varStringGo, "go")
dockerCmdFlags.StringVarWithDefaultValue(&varStringBase, "base", "scratch")
dockerCmdFlags.IntVar(&varIntPort, "port")
dockerCmdFlags.StringVar(&varStringHome, "home")
dockerCmdFlags.StringVar(&varStringRemote, "remote")
dockerCmdFlags.StringVar(&varStringBranch, "branch")
dockerCmdFlags.StringVar(&varStringVersion, "version")
dockerCmdFlags.StringVarWithDefaultValue(&varStringTZ, "tz", "Asia/Shanghai")
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/docker/docker_test.go | tools/goctl/docker/docker_test.go | package docker
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestDockerCommand_EtcDirResolution(t *testing.T) {
// Create a temporary project structure
tempDir := t.TempDir()
// Create project structure: project/service/api/
serviceDir := filepath.Join(tempDir, "service", "api")
etcDir := filepath.Join(serviceDir, "etc")
require.NoError(t, os.MkdirAll(etcDir, 0755))
// Create a Go file
goFile := filepath.Join(serviceDir, "api.go")
require.NoError(t, os.WriteFile(goFile, []byte("package main\n\nfunc main() {}"), 0644))
// Create a config file
configFile := filepath.Join(etcDir, "config.yaml")
require.NoError(t, os.WriteFile(configFile, []byte("Name: test\n"), 0644))
// Create go.mod at the root
goModFile := filepath.Join(tempDir, "go.mod")
require.NoError(t, os.WriteFile(goModFile, []byte("module test\n\ngo 1.21\n"), 0644))
// Test: etc directory should be found relative to Go file, not CWD
t.Run("etc directory resolved relative to go file", func(t *testing.T) {
// Save and restore original working directory
originalWd, err := os.Getwd()
require.NoError(t, err)
defer func() {
require.NoError(t, os.Chdir(originalWd))
}()
// Change to temp directory (not service/api directory)
require.NoError(t, os.Chdir(tempDir))
// The relative path from tempDir to the go file
relGoFile := filepath.Join("service", "api", "api.go")
// Test the etc directory resolution logic
resolvedEtcDir := filepath.Join(filepath.Dir(relGoFile), "etc")
// Verify the resolved path exists
_, err = os.Stat(resolvedEtcDir)
assert.NoError(t, err, "etc directory should be found at service/api/etc")
// Verify it's the correct path (use EvalSymlinks to handle /private on macOS)
absResolvedEtc, err := filepath.Abs(resolvedEtcDir)
require.NoError(t, err)
absResolvedEtc, err = filepath.EvalSymlinks(absResolvedEtc)
require.NoError(t, err)
expectedEtc, err := filepath.EvalSymlinks(etcDir)
require.NoError(t, err)
assert.Equal(t, expectedEtc, absResolvedEtc)
})
t.Run("etc directory with empty goFile", func(t *testing.T) {
// When goFile is empty, should default to "./etc"
goFile := ""
resolvedEtcDir := filepath.Join(filepath.Dir(goFile), "etc")
// Should resolve to just "etc"
assert.Equal(t, "etc", resolvedEtcDir)
})
t.Run("etc directory with absolute path", func(t *testing.T) {
// When goFile is absolute path
absGoFile := filepath.Join(tempDir, "service", "api", "api.go")
resolvedEtcDir := filepath.Join(filepath.Dir(absGoFile), "etc")
// Should resolve correctly
_, err := os.Stat(resolvedEtcDir)
assert.NoError(t, err)
})
}
func TestGenerateDockerfile_GoMainFromPath(t *testing.T) {
tests := []struct {
name string
goFile string
projPath string
expectedPath string
}{
{
name: "relative path with subdirectory",
goFile: "service/api/api.go",
projPath: "service/api",
expectedPath: "service/api/api.go",
},
{
name: "simple filename",
goFile: "main.go",
projPath: ".",
expectedPath: "main.go",
},
{
name: "nested service path",
goFile: "internal/service/user/user.go",
projPath: "internal/service/user",
expectedPath: "internal/service/user/user.go",
},
{
name: "deep nested path",
goFile: "cmd/api/internal/handler/handler.go",
projPath: "cmd/api/internal/handler",
expectedPath: "cmd/api/internal/handler/handler.go",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Simulate the fix: using filepath.Base instead of full path
goMainFrom := filepath.Join(tt.projPath, filepath.Base(tt.goFile))
assert.Equal(t, tt.expectedPath, goMainFrom,
"GoMainFrom should not duplicate path segments")
// Verify the old buggy behavior would have been wrong
if tt.goFile != filepath.Base(tt.goFile) {
buggyPath := filepath.Join(tt.projPath, tt.goFile)
assert.NotEqual(t, tt.expectedPath, buggyPath,
"Old implementation would have created incorrect path")
}
})
}
}
func TestGenerateDockerfile_PathJoinBehavior(t *testing.T) {
t.Run("demonstrates the bug and fix", func(t *testing.T) {
projPath := "service/api"
goFile := "service/api/api.go"
// OLD (buggy) behavior: path duplication
buggyPath := filepath.Join(projPath, goFile)
assert.Equal(t, "service/api/service/api/api.go", buggyPath,
"Bug: path segments are duplicated")
// NEW (fixed) behavior: correct path
fixedPath := filepath.Join(projPath, filepath.Base(goFile))
assert.Equal(t, "service/api/api.go", fixedPath,
"Fix: using filepath.Base prevents duplication")
})
}
func TestFindConfig(t *testing.T) {
tempDir := t.TempDir()
etcDir := filepath.Join(tempDir, "etc")
require.NoError(t, os.MkdirAll(etcDir, 0755))
t.Run("finds config matching go file name", func(t *testing.T) {
// Create config files
require.NoError(t, os.WriteFile(
filepath.Join(etcDir, "api.yaml"), []byte("test"), 0644))
require.NoError(t, os.WriteFile(
filepath.Join(etcDir, "other.yaml"), []byte("test"), 0644))
cfg, err := findConfig("api.go", etcDir)
assert.NoError(t, err)
assert.Equal(t, "api.yaml", cfg)
})
t.Run("returns first config when no match", func(t *testing.T) {
etcDir2 := filepath.Join(tempDir, "etc2")
require.NoError(t, os.MkdirAll(etcDir2, 0755))
require.NoError(t, os.WriteFile(
filepath.Join(etcDir2, "config.yaml"), []byte("test"), 0644))
cfg, err := findConfig("main.go", etcDir2)
assert.NoError(t, err)
assert.Equal(t, "config.yaml", cfg)
})
t.Run("returns error when no yaml files", func(t *testing.T) {
emptyDir := filepath.Join(tempDir, "empty")
require.NoError(t, os.MkdirAll(emptyDir, 0755))
_, err := findConfig("api.go", emptyDir)
assert.Error(t, err)
assert.Contains(t, err.Error(), "no yaml file")
})
t.Run("handles path in go file name", func(t *testing.T) {
// Test with service/api/api.go - should extract just "api"
cfg, err := findConfig("service/api/api.go", etcDir)
assert.NoError(t, err)
assert.Equal(t, "api.yaml", cfg)
})
}
func TestGetFilePath(t *testing.T) {
// Create a temporary directory with go.mod
tempDir := t.TempDir()
require.NoError(t, os.WriteFile(
filepath.Join(tempDir, "go.mod"),
[]byte("module testproject\n\ngo 1.21\n"),
0644,
))
// Create subdirectories
serviceDir := filepath.Join(tempDir, "service", "api")
require.NoError(t, os.MkdirAll(serviceDir, 0755))
originalWd, err := os.Getwd()
require.NoError(t, err)
defer func() {
require.NoError(t, os.Chdir(originalWd))
}()
t.Run("returns relative path from go.mod", func(t *testing.T) {
require.NoError(t, os.Chdir(tempDir))
path, err := getFilePath("service/api")
assert.NoError(t, err)
assert.Equal(t, "service/api", path)
})
t.Run("handles current directory", func(t *testing.T) {
require.NoError(t, os.Chdir(tempDir))
path, err := getFilePath(".")
assert.NoError(t, err)
// Current directory returns empty string when at go.mod root
assert.True(t, path == "." || path == "")
})
}
// Integration test to verify the complete fix
func TestDockerCommandIntegration(t *testing.T) {
// Create a complete project structure
tempDir := t.TempDir()
// Setup: project/service/api/
serviceDir := filepath.Join(tempDir, "service", "api")
etcDir := filepath.Join(serviceDir, "etc")
require.NoError(t, os.MkdirAll(etcDir, 0755))
// Create files
goFile := filepath.Join(serviceDir, "api.go")
require.NoError(t, os.WriteFile(goFile, []byte("package main\n\nfunc main() {}"), 0644))
configFile := filepath.Join(etcDir, "api.yaml")
require.NoError(t, os.WriteFile(configFile, []byte("Name: test-api\n"), 0644))
goModFile := filepath.Join(tempDir, "go.mod")
require.NoError(t, os.WriteFile(goModFile, []byte("module testproject\n\ngo 1.21\n"), 0644))
goSumFile := filepath.Join(tempDir, "go.sum")
require.NoError(t, os.WriteFile(goSumFile, []byte(""), 0644))
originalWd, err := os.Getwd()
require.NoError(t, err)
defer func() {
require.NoError(t, os.Chdir(originalWd))
}()
t.Run("etc directory detected from different working directory", func(t *testing.T) {
// Change to project root (not service/api)
require.NoError(t, os.Chdir(tempDir))
// Relative path to Go file
relGoFile := filepath.Join("service", "api", "api.go")
// Apply the fix: resolve etc directory relative to go file
resolvedEtcDir := filepath.Join(filepath.Dir(relGoFile), "etc")
// Verify etc directory is found
stat, err := os.Stat(resolvedEtcDir)
assert.NoError(t, err)
assert.True(t, stat.IsDir())
// Verify config can be found
cfg, err := findConfig(relGoFile, resolvedEtcDir)
assert.NoError(t, err)
assert.Equal(t, "api.yaml", cfg)
})
t.Run("GoMainFrom path is correct", func(t *testing.T) {
require.NoError(t, os.Chdir(tempDir))
goFileRel := filepath.Join("service", "api", "api.go")
// Simulate getFilePath return value
projPath := "service/api"
// Apply the fix: use filepath.Base
goMainFrom := filepath.Join(projPath, filepath.Base(goFileRel))
assert.Equal(t, "service/api/api.go", goMainFrom)
// Verify no path duplication
assert.NotContains(t, goMainFrom, "service/api/service/api")
})
}
// Test that specifically validates the bug described in PR #4343
func TestPR4343_BugFixes(t *testing.T) {
t.Run("Bug 1: etc directory check uses correct base path", func(t *testing.T) {
// Setup: Create a project structure where etc is NOT in CWD but IS relative to Go file
tempDir := t.TempDir()
serviceDir := filepath.Join(tempDir, "service", "api")
etcDir := filepath.Join(serviceDir, "etc")
require.NoError(t, os.MkdirAll(etcDir, 0755))
// Create a config file
require.NoError(t, os.WriteFile(
filepath.Join(etcDir, "config.yaml"),
[]byte("Name: test\n"),
0644,
))
originalWd, err := os.Getwd()
require.NoError(t, err)
defer func() {
require.NoError(t, os.Chdir(originalWd))
}()
// Change to project root (CWD = tempDir)
require.NoError(t, os.Chdir(tempDir))
goFile := filepath.Join("service", "api", "api.go")
// OLD (buggy) behavior: checks for "etc" in CWD
_, errOld := os.Stat("etc")
assert.Error(t, errOld, "Bug: etc not found in CWD")
// NEW (fixed) behavior: checks for "etc" relative to go file
etcDirResolved := filepath.Join(filepath.Dir(goFile), "etc")
stat, errNew := os.Stat(etcDirResolved)
assert.NoError(t, errNew, "Fix: etc found relative to go file")
assert.True(t, stat.IsDir())
// Verify config is accessible
cfg, err := findConfig(goFile, etcDirResolved)
assert.NoError(t, err)
assert.Equal(t, "config.yaml", cfg)
})
t.Run("Bug 2: GoMainFrom path not duplicated", func(t *testing.T) {
// Test case from PR description
projPath := "service/api"
goFile := "service/api/api.go"
// OLD (buggy) behavior: duplicates path
buggyPath := filepath.Join(projPath, goFile)
assert.Equal(t, "service/api/service/api/api.go", buggyPath,
"Bug: path duplication occurs with old implementation")
// NEW (fixed) behavior: correct path using filepath.Base
fixedPath := filepath.Join(projPath, filepath.Base(goFile))
assert.Equal(t, "service/api/api.go", fixedPath,
"Fix: using filepath.Base() prevents path duplication")
// Verify the fix works for various scenarios
testCases := []struct {
projPath string
goFile string
expected string
}{
{"service/api", "service/api/api.go", "service/api/api.go"},
{"cmd/server", "cmd/server/main.go", "cmd/server/main.go"},
{"internal/handler", "internal/handler/handler.go", "internal/handler/handler.go"},
{".", "main.go", "main.go"},
}
for _, tc := range testCases {
result := filepath.Join(tc.projPath, filepath.Base(tc.goFile))
assert.Equal(t, tc.expected, result,
"Fix should work for projPath=%s, goFile=%s", tc.projPath, tc.goFile)
}
})
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/docker/template.go | tools/goctl/docker/template.go | package docker
import (
_ "embed"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const (
category = "docker"
dockerTemplateFile = "docker.tpl"
)
//go:embed docker.tpl
var dockerTemplate string
// Clean deletes all templates files
func Clean() error {
return pathx.Clean(category)
}
// GenTemplates creates docker template files
func GenTemplates() error {
return initTemplate()
}
// Category returns the const string of docker category
func Category() string {
return category
}
// RevertTemplate recovers the deleted template files
func RevertTemplate(name string) error {
return pathx.CreateTemplate(category, name, dockerTemplate)
}
// Update deletes and creates new template files
func Update() error {
err := Clean()
if err != nil {
return err
}
return initTemplate()
}
func initTemplate() error {
return pathx.InitTemplates(category, map[string]string{
dockerTemplateFile: dockerTemplate,
})
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/tpl/templates.go | tools/goctl/tpl/templates.go | package tpl
import (
"fmt"
"path/filepath"
"github.com/gookit/color"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/core/errorx"
"github.com/zeromicro/go-zero/tools/goctl/api/apigen"
"github.com/zeromicro/go-zero/tools/goctl/api/gogen"
apinew "github.com/zeromicro/go-zero/tools/goctl/api/new"
"github.com/zeromicro/go-zero/tools/goctl/docker"
"github.com/zeromicro/go-zero/tools/goctl/gateway"
"github.com/zeromicro/go-zero/tools/goctl/kube"
mongogen "github.com/zeromicro/go-zero/tools/goctl/model/mongo/generate"
modelgen "github.com/zeromicro/go-zero/tools/goctl/model/sql/gen"
rpcgen "github.com/zeromicro/go-zero/tools/goctl/rpc/generator"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const templateParentPath = "/"
// genTemplates writes the latest template text into file which is not exists
func genTemplates(_ *cobra.Command, _ []string) error {
path := varStringHome
if len(path) != 0 {
pathx.RegisterGoctlHome(path)
}
if err := errorx.Chain(
func() error {
return gogen.GenTemplates()
},
func() error {
return modelgen.GenTemplates()
},
func() error {
return rpcgen.GenTemplates()
},
func() error {
return docker.GenTemplates()
},
func() error {
return kube.GenTemplates()
},
func() error {
return mongogen.Templates()
},
func() error {
return apigen.GenTemplates()
},
func() error {
return apinew.GenTemplates()
},
func() error {
return gateway.GenTemplates()
},
); err != nil {
return err
}
dir, err := pathx.GetTemplateDir(templateParentPath)
if err != nil {
return err
}
abs, err := filepath.Abs(dir)
if err != nil {
return err
}
fmt.Printf("Templates are generated in %s, %s\n", color.Green.Render(abs),
color.Red.Render("edit on your risk!"))
return nil
}
// cleanTemplates deletes all templates
func cleanTemplates(_ *cobra.Command, _ []string) error {
path := varStringHome
if len(path) != 0 {
pathx.RegisterGoctlHome(path)
}
err := errorx.Chain(
func() error {
return gogen.Clean()
},
func() error {
return modelgen.Clean()
},
func() error {
return rpcgen.Clean()
},
func() error {
return docker.Clean()
},
func() error {
return kube.Clean()
},
func() error {
return mongogen.Clean()
},
func() error {
return apigen.Clean()
},
func() error {
return apinew.Clean()
},
func() error {
return gateway.Clean()
},
)
if err != nil {
return err
}
fmt.Printf("%s\n", color.Green.Render("templates are cleaned!"))
return nil
}
// updateTemplates writes the latest template text into file,
// it will delete the older templates if there are exists
func updateTemplates(_ *cobra.Command, _ []string) (err error) {
path := varStringHome
category := varStringCategory
if len(path) != 0 {
pathx.RegisterGoctlHome(path)
}
defer func() {
if err == nil {
fmt.Println(color.Green.Sprintf("%s template are update!", category))
}
}()
switch category {
case docker.Category():
return docker.Update()
case gogen.Category():
return gogen.Update()
case kube.Category():
return kube.Update()
case rpcgen.Category():
return rpcgen.Update()
case modelgen.Category():
return modelgen.Update()
case mongogen.Category():
return mongogen.Update()
case apigen.Category():
return apigen.Update()
case apinew.Category():
return apinew.Update()
case gateway.Category():
return gateway.Update()
default:
err = fmt.Errorf("unexpected category: %s", category)
return
}
}
// revertTemplates will overwrite the old template content with the new template
func revertTemplates(_ *cobra.Command, _ []string) (err error) {
path := varStringHome
category := varStringCategory
filename := varStringName
if len(path) != 0 {
pathx.RegisterGoctlHome(path)
}
defer func() {
if err == nil {
fmt.Println(color.Green.Sprintf("%s template are reverted!", filename))
}
}()
switch category {
case docker.Category():
return docker.RevertTemplate(filename)
case kube.Category():
return kube.RevertTemplate(filename)
case gogen.Category():
return gogen.RevertTemplate(filename)
case rpcgen.Category():
return rpcgen.RevertTemplate(filename)
case modelgen.Category():
return modelgen.RevertTemplate(filename)
case mongogen.Category():
return mongogen.RevertTemplate(filename)
case apigen.Category():
return apigen.RevertTemplate(filename)
case apinew.Category():
return apinew.RevertTemplate(filename)
case gateway.Category():
return gateway.RevertTemplate(filename)
default:
err = fmt.Errorf("unexpected category: %s", category)
return
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/tpl/cmd.go | tools/goctl/tpl/cmd.go | package tpl
import "github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
var (
varStringHome string
varStringCategory string
varStringName string
// Cmd describes a template command.
Cmd = cobrax.NewCommand("template")
initCmd = cobrax.NewCommand("init", cobrax.WithRunE(genTemplates))
cleanCmd = cobrax.NewCommand("clean", cobrax.WithRunE(cleanTemplates))
updateCmd = cobrax.NewCommand("update", cobrax.WithRunE(updateTemplates))
revertCmd = cobrax.NewCommand("revert", cobrax.WithRunE(revertTemplates))
)
func init() {
initCmd.Flags().StringVar(&varStringHome, "home")
cleanCmd.Flags().StringVar(&varStringHome, "home")
updateCmd.Flags().StringVar(&varStringHome, "home")
updateCmd.Flags().StringVarP(&varStringCategory, "category", "c")
revertCmd.Flags().StringVar(&varStringHome, "home")
revertCmd.Flags().StringVarP(&varStringCategory, "category", "c")
revertCmd.Flags().StringVarP(&varStringName, "name", "n")
Cmd.AddCommand(cleanCmd, initCmd, revertCmd, updateCmd)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/cmd.go | tools/goctl/model/cmd.go | package model
import (
"github.com/zeromicro/go-zero/tools/goctl/internal/cobrax"
"github.com/zeromicro/go-zero/tools/goctl/model/mongo"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/command"
)
var (
// Cmd describes a model command.
Cmd = cobrax.NewCommand("model")
mysqlCmd = cobrax.NewCommand("mysql")
ddlCmd = cobrax.NewCommand("ddl", cobrax.WithRunE(command.MysqlDDL))
datasourceCmd = cobrax.NewCommand("datasource", cobrax.WithRunE(command.MySqlDataSource))
pgCmd = cobrax.NewCommand("pg", cobrax.WithRunE(command.PostgreSqlDataSource))
pgDatasourceCmd = cobrax.NewCommand("datasource", cobrax.WithRunE(command.PostgreSqlDataSource))
mongoCmd = cobrax.NewCommand("mongo", cobrax.WithRunE(mongo.Action))
)
func init() {
var (
ddlCmdFlags = ddlCmd.Flags()
datasourceCmdFlags = datasourceCmd.Flags()
pgDatasourceCmdFlags = pgDatasourceCmd.Flags()
mongoCmdFlags = mongoCmd.Flags()
)
ddlCmdFlags.StringVarP(&command.VarStringSrc, "src", "s")
ddlCmdFlags.StringVarP(&command.VarStringDir, "dir", "d")
ddlCmdFlags.StringVar(&command.VarStringStyle, "style")
ddlCmdFlags.BoolVarP(&command.VarBoolCache, "cache", "c")
ddlCmdFlags.BoolVar(&command.VarBoolIdea, "idea")
ddlCmdFlags.StringVar(&command.VarStringDatabase, "database")
ddlCmdFlags.StringVar(&command.VarStringHome, "home")
ddlCmdFlags.StringVar(&command.VarStringRemote, "remote")
ddlCmdFlags.StringVar(&command.VarStringBranch, "branch")
datasourceCmdFlags.StringVar(&command.VarStringURL, "url")
datasourceCmdFlags.StringSliceVarP(&command.VarStringSliceTable, "table", "t")
datasourceCmdFlags.BoolVarP(&command.VarBoolCache, "cache", "c")
datasourceCmdFlags.StringVarP(&command.VarStringDir, "dir", "d")
datasourceCmdFlags.StringVar(&command.VarStringStyle, "style")
datasourceCmdFlags.BoolVar(&command.VarBoolIdea, "idea")
datasourceCmdFlags.StringVar(&command.VarStringHome, "home")
datasourceCmdFlags.StringVar(&command.VarStringRemote, "remote")
datasourceCmdFlags.StringVar(&command.VarStringBranch, "branch")
pgDatasourceCmdFlags.StringVar(&command.VarStringURL, "url")
pgDatasourceCmdFlags.StringSliceVarP(&command.VarStringSliceTable, "table", "t")
pgDatasourceCmdFlags.StringVarPWithDefaultValue(&command.VarStringSchema, "schema", "s", "public")
pgDatasourceCmdFlags.BoolVarP(&command.VarBoolCache, "cache", "c")
pgDatasourceCmdFlags.StringVarP(&command.VarStringDir, "dir", "d")
pgDatasourceCmdFlags.StringVar(&command.VarStringStyle, "style")
pgDatasourceCmdFlags.BoolVar(&command.VarBoolIdea, "idea")
pgDatasourceCmdFlags.BoolVar(&command.VarBoolStrict, "strict")
pgDatasourceCmdFlags.StringVar(&command.VarStringHome, "home")
pgDatasourceCmdFlags.StringVar(&command.VarStringRemote, "remote")
pgDatasourceCmdFlags.StringVar(&command.VarStringBranch, "branch")
pgCmd.PersistentFlags().StringSliceVarPWithDefaultValue(&command.VarStringSliceIgnoreColumns,
"ignore-columns", "i", []string{"create_at", "created_at", "create_time", "update_at", "updated_at", "update_time"})
pgCmd.PersistentFlags().StringVarPWithDefaultValue(&command.VarStringCachePrefix, "prefix", "p", "cache")
mongoCmdFlags.StringSliceVarP(&mongo.VarStringSliceType, "type", "t")
mongoCmdFlags.BoolVarP(&mongo.VarBoolCache, "cache", "c")
mongoCmdFlags.StringVarP(&mongo.VarStringPrefix, "prefix", "p")
mongoCmdFlags.BoolVarP(&mongo.VarBoolEasy, "easy", "e")
mongoCmdFlags.StringVarP(&mongo.VarStringDir, "dir", "d")
mongoCmdFlags.StringVar(&mongo.VarStringStyle, "style")
mongoCmdFlags.StringVar(&mongo.VarStringHome, "home")
mongoCmdFlags.StringVar(&mongo.VarStringRemote, "remote")
mongoCmdFlags.StringVar(&mongo.VarStringBranch, "branch")
mysqlCmd.PersistentFlags().BoolVar(&command.VarBoolStrict, "strict")
mysqlCmd.PersistentFlags().StringSliceVarPWithDefaultValue(&command.VarStringSliceIgnoreColumns,
"ignore-columns", "i", []string{"create_at", "created_at", "create_time", "update_at", "updated_at", "update_time"})
mysqlCmd.PersistentFlags().StringVarPWithDefaultValue(&command.VarStringCachePrefix, "prefix", "p", "cache")
mysqlCmd.AddCommand(datasourceCmd, ddlCmd)
pgCmd.AddCommand(pgDatasourceCmd)
Cmd.AddCommand(mysqlCmd, mongoCmd, pgCmd)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/mongo/mongo.go | tools/goctl/model/mongo/mongo.go | package mongo
import (
"errors"
"path/filepath"
"strings"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/model/mongo/generate"
file "github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
var (
// VarStringSliceType describes a golang data structure name for mongo.
VarStringSliceType []string
// VarStringDir describes an output directory.
VarStringDir string
// VarBoolCache describes whether cache is enabled.
VarBoolCache bool
// VarStringPrefix string describes the prefix for the cache key.
VarStringPrefix string
// VarBoolEasy describes whether to generate Collection Name in the code for easy declare.
VarBoolEasy bool
// VarStringStyle describes the style.
VarStringStyle string
// VarStringHome describes the goctl home.
VarStringHome string
// VarStringRemote describes the remote git repository.
VarStringRemote string
// VarStringBranch describes the git branch.
VarStringBranch string
)
// Action provides the entry for goctl mongo code generation.
func Action(_ *cobra.Command, _ []string) error {
tp := VarStringSliceType
c := VarBoolCache
p := VarStringPrefix
easy := VarBoolEasy
o := strings.TrimSpace(VarStringDir)
s := VarStringStyle
home := VarStringHome
remote := VarStringRemote
branch := VarStringBranch
if len(remote) > 0 {
repo, _ := file.CloneIntoGitHome(remote, branch)
if len(repo) > 0 {
home = repo
}
}
if len(home) > 0 {
pathx.RegisterGoctlHome(home)
}
if len(tp) == 0 {
return errors.New("missing type")
}
cfg, err := config.NewConfig(s)
if err != nil {
return err
}
a, err := filepath.Abs(o)
if err != nil {
return err
}
if err = pathx.MkdirIfNotExist(a); err != nil {
return err
}
return generate.Do(&generate.Context{
Types: tp,
Cache: c,
Prefix: p,
Easy: easy,
Output: a,
Cfg: cfg,
})
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/mongo/generate/generate_test.go | tools/goctl/model/mongo/generate/generate_test.go | package generate
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
var testTypes = `
type User struct{}
type Class struct{}
`
func TestDo(t *testing.T) {
t.Run("should generate model", func(t *testing.T) {
cfg, err := config.NewConfig(config.DefaultFormat)
assert.Nil(t, err)
tempDir := pathx.MustTempDir()
typesfile := filepath.Join(tempDir, "types.go")
err = os.WriteFile(typesfile, []byte(testTypes), 0o666)
assert.Nil(t, err)
err = Do(&Context{
Types: []string{"User", "Class"},
Cache: false,
Output: tempDir,
Cfg: cfg,
})
assert.Nil(t, err)
})
t.Run("missing config", func(t *testing.T) {
tempDir := t.TempDir()
typesfile := filepath.Join(tempDir, "types.go")
err := os.WriteFile(typesfile, []byte(testTypes), 0o666)
assert.Nil(t, err)
err = Do(&Context{
Types: []string{"User", "Class"},
Cache: false,
Output: tempDir,
Cfg: nil,
})
assert.Error(t, err)
})
t.Run("invalid config", func(t *testing.T) {
cfg := &config.Config{NamingFormat: "foo"}
tempDir := t.TempDir()
typesfile := filepath.Join(tempDir, "types.go")
err := os.WriteFile(typesfile, []byte(testTypes), 0o666)
assert.Nil(t, err)
err = Do(&Context{
Types: []string{"User", "Class"},
Cache: false,
Output: tempDir,
Cfg: cfg,
})
assert.Error(t, err)
})
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/mongo/generate/template_test.go | tools/goctl/model/mongo/generate/template_test.go | package generate
import (
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func TestTemplate(t *testing.T) {
tempDir := t.TempDir()
pathx.RegisterGoctlHome(tempDir)
t.Cleanup(func() {
pathx.RegisterGoctlHome("")
})
t.Run("Category", func(t *testing.T) {
assert.Equal(t, category, Category())
})
t.Run("Clean", func(t *testing.T) {
err := Clean()
assert.NoError(t, err)
})
t.Run("Templates", func(t *testing.T) {
err := Templates()
assert.NoError(t, err)
assert.True(t, pathx.FileExists(filepath.Join(tempDir, category, modelTemplateFile)))
})
t.Run("RevertTemplate", func(t *testing.T) {
assert.NoError(t, RevertTemplate(modelTemplateFile))
assert.Error(t, RevertTemplate("foo"))
})
t.Run("Update", func(t *testing.T) {
assert.NoError(t, Update())
})
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/mongo/generate/generate.go | tools/goctl/model/mongo/generate/generate.go | package generate
import (
"errors"
"path/filepath"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
"github.com/zeromicro/go-zero/tools/goctl/model/mongo/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
// Context defines the model generation data what they needs
type Context struct {
Types []string
Cache bool
Prefix string
Easy bool
Output string
Cfg *config.Config
}
// Do executes model template and output the result into the specified file path
func Do(ctx *Context) error {
if ctx.Cfg == nil {
return errors.New("missing config")
}
if err := generateTypes(ctx); err != nil {
return err
}
if err := generateModel(ctx); err != nil {
return err
}
if err := generateCustomModel(ctx); err != nil {
return err
}
return generateError(ctx)
}
func generateModel(ctx *Context) error {
for _, t := range ctx.Types {
fn, err := format.FileNamingFormat(ctx.Cfg.NamingFormat, t+"_model_gen")
if err != nil {
return err
}
text, err := pathx.LoadTemplate(category, modelTemplateFile, template.ModelText)
if err != nil {
return err
}
output := filepath.Join(ctx.Output, fn+".go")
if err = util.With("model").Parse(text).GoFmt(true).SaveTo(map[string]any{
"Type": stringx.From(t).Title(),
"lowerType": stringx.From(t).Untitle(),
"Cache": ctx.Cache,
"Prefix": ctx.Prefix,
"version": version.BuildVersion,
}, output, true); err != nil {
return err
}
}
return nil
}
func generateCustomModel(ctx *Context) error {
for _, t := range ctx.Types {
fn, err := format.FileNamingFormat(ctx.Cfg.NamingFormat, t+"_model")
if err != nil {
return err
}
text, err := pathx.LoadTemplate(category, modelCustomTemplateFile, template.ModelCustomText)
if err != nil {
return err
}
output := filepath.Join(ctx.Output, fn+".go")
err = util.With("model").Parse(text).GoFmt(true).SaveTo(map[string]any{
"Type": stringx.From(t).Title(),
"lowerType": stringx.From(t).Untitle(),
"snakeType": stringx.From(t).ToSnake(),
"Cache": ctx.Cache,
"Easy": ctx.Easy,
}, output, false)
if err != nil {
return err
}
}
return nil
}
func generateTypes(ctx *Context) error {
for _, t := range ctx.Types {
fn, err := format.FileNamingFormat(ctx.Cfg.NamingFormat, t+"_types")
if err != nil {
return err
}
text, err := pathx.LoadTemplate(category, modelTypesTemplateFile, template.ModelTypesText)
if err != nil {
return err
}
output := filepath.Join(ctx.Output, fn+".go")
if err = util.With("model").Parse(text).GoFmt(true).SaveTo(map[string]any{
"Type": stringx.From(t).Title(),
}, output, false); err != nil {
return err
}
}
return nil
}
func generateError(ctx *Context) error {
text, err := pathx.LoadTemplate(category, errTemplateFile, template.Error)
if err != nil {
return err
}
output := filepath.Join(ctx.Output, "error.go")
return util.With("error").Parse(text).GoFmt(true).SaveTo(ctx, output, false)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/mongo/generate/template.go | tools/goctl/model/mongo/generate/template.go | package generate
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/model/mongo/template"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const (
category = "mongo"
modelTemplateFile = "model.tpl"
modelCustomTemplateFile = "model_custom.tpl"
modelTypesTemplateFile = "model_types.tpl"
errTemplateFile = "err.tpl"
)
var templates = map[string]string{
modelTemplateFile: template.ModelText,
modelCustomTemplateFile: template.ModelCustomText,
modelTypesTemplateFile: template.ModelTypesText,
errTemplateFile: template.Error,
}
// Category returns the mongo category.
func Category() string {
return category
}
// Clean cleans the mongo templates.
func Clean() error {
return pathx.Clean(category)
}
// Templates initializes the mongo templates.
func Templates() error {
return pathx.InitTemplates(category, templates)
}
// RevertTemplate reverts the given template.
func RevertTemplate(name string) error {
content, ok := templates[name]
if !ok {
return fmt.Errorf("%s: no such file name", name)
}
return pathx.CreateTemplate(category, name, content)
}
// Update cleans and updates the templates.
func Update() error {
err := Clean()
if err != nil {
return err
}
return pathx.InitTemplates(category, templates)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/mongo/template/template.go | tools/goctl/model/mongo/template/template.go | package template
import _ "embed"
var (
// ModelText provides the default template for model to generate.
//go:embed model.tpl
ModelText string
// ModelCustomText provides the default template for model to generate.
//go:embed model_custom.tpl
ModelCustomText string
// ModelTypesText provides the default template for model to generate.
//go:embed types.tpl
ModelTypesText string
// Error provides the default template for error definition in mongo code generation.
//go:embed error.tpl
Error string
)
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/util/match_test.go | tools/goctl/model/sql/util/match_test.go | package util
import (
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
)
func TestMatchFiles(t *testing.T) {
dir, err := filepath.Abs("./")
assert.Nil(t, err)
files, err := MatchFiles("./*.sql")
assert.Nil(t, err)
assert.Equal(t, []string{filepath.Join(dir, "studeat.sql"), filepath.Join(dir, "student.sql"), filepath.Join(dir, "xx.sql")}, files)
files, err = MatchFiles("./??.sql")
assert.Nil(t, err)
assert.Equal(t, []string{filepath.Join(dir, "xx.sql")}, files)
files, err = MatchFiles("./*.sq*")
assert.Nil(t, err)
assert.Equal(t, []string{filepath.Join(dir, "studeat.sql"), filepath.Join(dir, "student.sql"), filepath.Join(dir, "xx.sql"), filepath.Join(dir, "xx.sql1")}, files)
files, err = MatchFiles("./student.sql")
assert.Nil(t, err)
assert.Equal(t, []string{filepath.Join(dir, "student.sql")}, files)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/util/slice.go | tools/goctl/model/sql/util/slice.go | package util
// TrimStringSlice returns a copy slice without empty string item
func TrimStringSlice(list []string) []string {
var out []string
for _, item := range list {
if len(item) == 0 {
continue
}
out = append(out, item)
}
return out
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/util/newline.go | tools/goctl/model/sql/util/newline.go | package util
import "strings"
// TrimNewLine trims \r and \n chars.
func TrimNewLine(s string) string {
return strings.NewReplacer("\r", "", "\n", "").Replace(s)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/util/matcher.go | tools/goctl/model/sql/util/matcher.go | package util
import (
"os"
"path/filepath"
)
// MatchFiles returns the match values by globbing patterns
func MatchFiles(in string) ([]string, error) {
dir, pattern := filepath.Split(in)
abs, err := filepath.Abs(dir)
if err != nil {
return nil, err
}
files, err := os.ReadDir(abs)
if err != nil {
return nil, err
}
var res []string
for _, file := range files {
if file.IsDir() {
continue
}
name := file.Name()
match, err := filepath.Match(pattern, name)
if err != nil {
return nil, err
}
if !match {
continue
}
res = append(res, filepath.Join(abs, name))
}
return res, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/builderx/builder.go | tools/goctl/model/sql/builderx/builder.go | package builderx
import "github.com/zeromicro/go-zero/core/stores/builder"
// Deprecated: Use github.com/zeromicro/go-zero/core/stores/builder.RawFieldNames instead.
func FieldNames(in any) []string {
return builder.RawFieldNames(in)
}
// Deprecated: Use github.com/zeromicro/go-zero/core/stores/builder.RawFieldNames instead.
func RawFieldNames(in any, postgresSql ...bool) []string {
return builder.RawFieldNames(in, postgresSql...)
}
// Deprecated: Use github.com/zeromicro/go-zero/core/stores/builderx.PostgreSqlJoin instead.
func PostgreSqlJoin(elems []string) string {
return builder.PostgreSqlJoin(elems)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/command/command_test.go | tools/goctl/model/sql/command/command_test.go | package command
import (
_ "embed"
"os"
"path/filepath"
"sort"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/gen"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
var (
//go:embed testdata/user.sql
sql string
cfg = &config.Config{
NamingFormat: "gozero",
}
)
func TestFromDDl(t *testing.T) {
err := gen.Clean()
assert.Nil(t, err)
err = fromDDL(ddlArg{
src: "./user.sql",
dir: pathx.MustTempDir(),
cfg: cfg,
cache: true,
database: "go-zero",
strict: false,
})
assert.Equal(t, errNotMatched, err)
// case dir is not exists
unknownDir := filepath.Join(pathx.MustTempDir(), "test", "user.sql")
err = fromDDL(ddlArg{
src: unknownDir,
dir: pathx.MustTempDir(),
cfg: cfg,
cache: true,
database: "go_zero",
})
assert.True(t, func() bool {
switch err.(type) {
case *os.PathError:
return true
default:
return false
}
}())
// case empty src
err = fromDDL(ddlArg{
dir: pathx.MustTempDir(),
cfg: cfg,
cache: true,
database: "go_zero",
})
if err != nil {
assert.Equal(t, "expected path or path globbing patterns, but nothing found", err.Error())
}
tempDir := filepath.Join(pathx.MustTempDir(), "test")
err = pathx.MkdirIfNotExist(tempDir)
if err != nil {
return
}
user1Sql := filepath.Join(tempDir, "user1.sql")
user2Sql := filepath.Join(tempDir, "user2.sql")
err = os.WriteFile(user1Sql, []byte(sql), os.ModePerm)
if err != nil {
return
}
err = os.WriteFile(user2Sql, []byte(sql), os.ModePerm)
if err != nil {
return
}
_, err = os.Stat(user1Sql)
assert.Nil(t, err)
_, err = os.Stat(user2Sql)
assert.Nil(t, err)
filename := filepath.Join(tempDir, "usermodel.go")
fromDDL := func(db string) {
err = fromDDL(ddlArg{
src: filepath.Join(tempDir, "user*.sql"),
dir: tempDir,
cfg: cfg,
cache: true,
database: db,
})
assert.Nil(t, err)
_, err = os.Stat(filename)
assert.Nil(t, err)
}
fromDDL("go_zero")
_ = os.Remove(filename)
fromDDL("go-zero")
_ = os.Remove(filename)
fromDDL("1gozero")
}
func Test_parseTableList(t *testing.T) {
testData := []string{"foo", "b*", "bar", "back_up", "foo,bar,b*"}
patterns := parseTableList(testData)
actual := patterns.list()
expected := []string{"foo", "b*", "bar", "back_up"}
sort.Slice(actual, func(i, j int) bool {
return actual[i] > actual[j]
})
sort.Slice(expected, func(i, j int) bool {
return expected[i] > expected[j]
})
assert.Equal(t, strings.Join(expected, ","), strings.Join(actual, ","))
matchTestData := map[string]bool{
"foo": true,
"bar": true,
"back_up": true,
"bit": true,
"ab": false,
"b": true,
}
for v, expected := range matchTestData {
actual := patterns.Match(v)
assert.Equal(t, expected, actual)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/command/command.go | tools/goctl/model/sql/command/command.go | package command
import (
"errors"
"path/filepath"
"strings"
"github.com/go-sql-driver/mysql"
"github.com/spf13/cobra"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/stores/postgres"
"github.com/zeromicro/go-zero/core/stores/sqlx"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/command/migrationnotes"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/gen"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/model"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/util"
file "github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
var (
// VarStringSrc describes the source file of sql.
VarStringSrc string
// VarStringDir describes the output directory of sql.
VarStringDir string
// VarBoolCache describes whether the cache is enabled.
VarBoolCache bool
// VarBoolIdea describes whether is idea or not.
VarBoolIdea bool
// VarStringURL describes the dsn of the sql.
VarStringURL string
// VarStringSliceTable describes tables.
VarStringSliceTable []string
// VarStringStyle describes the style.
VarStringStyle string
// VarStringDatabase describes the database.
VarStringDatabase string
// VarStringSchema describes the schema of postgresql.
VarStringSchema string
// VarStringHome describes the goctl home.
VarStringHome string
// VarStringRemote describes the remote git repository.
VarStringRemote string
// VarStringBranch describes the git branch of the repository.
VarStringBranch string
// VarBoolStrict describes whether the strict mode is enabled.
VarBoolStrict bool
// VarStringSliceIgnoreColumns represents the columns which are ignored.
VarStringSliceIgnoreColumns []string
// VarStringCachePrefix describes the prefix of cache.
VarStringCachePrefix string
)
var errNotMatched = errors.New("sql not matched")
// MysqlDDL generates model code from ddl
func MysqlDDL(_ *cobra.Command, _ []string) error {
migrationnotes.BeforeCommands(VarStringDir, VarStringStyle)
if VarBoolCache && len(VarStringCachePrefix) == 0 {
return errors.New("cache prefix is empty")
}
src := VarStringSrc
dir := VarStringDir
cache := VarBoolCache
idea := VarBoolIdea
style := VarStringStyle
database := VarStringDatabase
home := VarStringHome
remote := VarStringRemote
branch := VarStringBranch
if len(remote) > 0 {
repo, _ := file.CloneIntoGitHome(remote, branch)
if len(repo) > 0 {
home = repo
}
}
if len(home) > 0 {
pathx.RegisterGoctlHome(home)
}
cfg, err := config.NewConfig(style)
if err != nil {
return err
}
arg := ddlArg{
src: src,
dir: dir,
cfg: cfg,
cache: cache,
idea: idea,
database: database,
strict: VarBoolStrict,
ignoreColumns: mergeColumns(VarStringSliceIgnoreColumns),
prefix: VarStringCachePrefix,
}
return fromDDL(arg)
}
// MySqlDataSource generates model code from datasource
func MySqlDataSource(_ *cobra.Command, _ []string) error {
migrationnotes.BeforeCommands(VarStringDir, VarStringStyle)
if VarBoolCache && len(VarStringCachePrefix) == 0 {
return errors.New("cache prefix is empty")
}
url := strings.TrimSpace(VarStringURL)
dir := strings.TrimSpace(VarStringDir)
cache := VarBoolCache
idea := VarBoolIdea
style := VarStringStyle
home := VarStringHome
remote := VarStringRemote
branch := VarStringBranch
if len(remote) > 0 {
repo, _ := file.CloneIntoGitHome(remote, branch)
if len(repo) > 0 {
home = repo
}
}
if len(home) > 0 {
pathx.RegisterGoctlHome(home)
}
tableValue := VarStringSliceTable
patterns := parseTableList(tableValue)
cfg, err := config.NewConfig(style)
if err != nil {
return err
}
arg := dataSourceArg{
url: url,
dir: dir,
tablePat: patterns,
cfg: cfg,
cache: cache,
idea: idea,
strict: VarBoolStrict,
ignoreColumns: mergeColumns(VarStringSliceIgnoreColumns),
prefix: VarStringCachePrefix,
}
return fromMysqlDataSource(arg)
}
func mergeColumns(columns []string) []string {
set := collection.NewSet[string]()
for _, v := range columns {
fields := strings.FieldsFunc(v, func(r rune) bool {
return r == ','
})
set.Add(fields...)
}
return set.Keys()
}
type pattern map[string]struct{}
func (p pattern) Match(s string) bool {
for v := range p {
match, err := filepath.Match(v, s)
if err != nil {
console.Error("%+v", err)
continue
}
if match {
return true
}
}
return false
}
func (p pattern) list() []string {
ret := make([]string, 0, len(p))
for v := range p {
ret = append(ret, v)
}
return ret
}
func parseTableList(tableValue []string) pattern {
tablePattern := make(pattern)
for _, v := range tableValue {
fields := strings.FieldsFunc(v, func(r rune) bool {
return r == ','
})
for _, f := range fields {
tablePattern[f] = struct{}{}
}
}
return tablePattern
}
// PostgreSqlDataSource generates model code from datasource
func PostgreSqlDataSource(_ *cobra.Command, _ []string) error {
migrationnotes.BeforeCommands(VarStringDir, VarStringStyle)
url := strings.TrimSpace(VarStringURL)
dir := strings.TrimSpace(VarStringDir)
cache := VarBoolCache
idea := VarBoolIdea
style := VarStringStyle
schema := VarStringSchema
home := VarStringHome
remote := VarStringRemote
branch := VarStringBranch
if len(remote) > 0 {
repo, _ := file.CloneIntoGitHome(remote, branch)
if len(repo) > 0 {
home = repo
}
}
if len(home) > 0 {
pathx.RegisterGoctlHome(home)
}
if len(schema) == 0 {
schema = "public"
}
patterns := parseTableList(VarStringSliceTable)
cfg, err := config.NewConfig(style)
if err != nil {
return err
}
ignoreColumns := mergeColumns(VarStringSliceIgnoreColumns)
arg := pgDataSourceArg{
url: url,
dir: dir,
tablePat: patterns,
schema: schema,
cfg: cfg,
cache: cache,
idea: idea,
strict: VarBoolStrict,
ignoreColumns: ignoreColumns,
prefix: VarStringCachePrefix,
}
return fromPostgreSqlDataSource(arg)
}
type ddlArg struct {
src, dir string
cfg *config.Config
cache, idea bool
database string
strict bool
ignoreColumns []string
prefix string
}
func fromDDL(arg ddlArg) error {
log := console.NewConsole(arg.idea)
src := strings.TrimSpace(arg.src)
if len(src) == 0 {
return errors.New("expected path or path globbing patterns, but nothing found")
}
files, err := util.MatchFiles(src)
if err != nil {
return err
}
if len(files) == 0 {
return errNotMatched
}
generator, err := gen.NewDefaultGenerator(arg.prefix, arg.dir, arg.cfg,
gen.WithConsoleOption(log), gen.WithIgnoreColumns(arg.ignoreColumns))
if err != nil {
return err
}
for _, file := range files {
err = generator.StartFromDDL(file, arg.cache, arg.strict, arg.database)
if err != nil {
return err
}
}
return nil
}
type dataSourceArg struct {
url, dir string
tablePat pattern
cfg *config.Config
cache, idea bool
strict bool
ignoreColumns []string
prefix string
}
func fromMysqlDataSource(arg dataSourceArg) error {
log := console.NewConsole(arg.idea)
if len(arg.url) == 0 {
log.Error("%v", "expected data source of mysql, but nothing found")
return nil
}
if len(arg.tablePat) == 0 {
log.Error("%v", "expected table or table globbing patterns, but nothing found")
return nil
}
dsn, err := mysql.ParseDSN(arg.url)
if err != nil {
return err
}
logx.Disable()
databaseSource := strings.TrimSuffix(arg.url, "/"+dsn.DBName) + "/information_schema"
db := sqlx.NewMysql(databaseSource)
im := model.NewInformationSchemaModel(db)
tables, err := im.GetAllTables(dsn.DBName)
if err != nil {
return err
}
matchTables := make(map[string]*model.Table)
for _, item := range tables {
if !arg.tablePat.Match(item) {
continue
}
columnData, err := im.FindColumns(dsn.DBName, item)
if err != nil {
return err
}
table, err := columnData.Convert()
if err != nil {
return err
}
matchTables[item] = table
}
if len(matchTables) == 0 {
return errors.New("no tables matched")
}
generator, err := gen.NewDefaultGenerator(arg.prefix, arg.dir, arg.cfg,
gen.WithConsoleOption(log), gen.WithIgnoreColumns(arg.ignoreColumns))
if err != nil {
return err
}
return generator.StartFromInformationSchema(matchTables, arg.cache, arg.strict)
}
type pgDataSourceArg struct {
url, dir string
tablePat pattern
schema string
cfg *config.Config
cache, idea bool
strict bool
ignoreColumns []string
prefix string
}
func fromPostgreSqlDataSource(arg pgDataSourceArg) error {
log := console.NewConsole(arg.idea)
if len(arg.url) == 0 {
log.Error("%v", "expected data source of postgresql, but nothing found")
return nil
}
if len(arg.tablePat) == 0 {
log.Error("%v", "expected table or table globbing patterns, but nothing found")
return nil
}
db := postgres.New(arg.url)
im := model.NewPostgreSqlModel(db)
tables, err := im.GetAllTables(arg.schema)
if err != nil {
return err
}
matchTables := make(map[string]*model.Table)
for _, item := range tables {
if !arg.tablePat.Match(item) {
continue
}
columnData, err := im.FindColumns(arg.schema, item)
if err != nil {
return err
}
table, err := columnData.Convert()
if err != nil {
return err
}
matchTables[item] = table
}
if len(matchTables) == 0 {
return errors.New("no tables matched")
}
generator, err := gen.NewDefaultGenerator(arg.prefix, arg.dir, arg.cfg, gen.WithConsoleOption(log),
gen.WithPostgreSql(), gen.WithIgnoreColumns(arg.ignoreColumns))
if err != nil {
return err
}
return generator.StartFromInformationSchema(matchTables, arg.cache, arg.strict)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/command/migrationnotes/v1.3.4.go | tools/goctl/model/sql/command/migrationnotes/v1.3.4.go | package migrationnotes
import (
"fmt"
"os"
"strings"
)
func migrateBefore1_3_4(dir, style string) error {
ok, err := needShow1_3_4(dir, style)
if err != nil {
return err
}
if !ok {
return nil
}
fmt.Println(`It seems like that your goctl has just been upgraded to version 1.3.4 or later, which refactored the code of the model module. The original XXXmodel.go has been split into XXXmodel_gen.go (read-only) and XXXmodel.go. You just need to follow these steps to complete the migration:
1. back up the original XXXmodel.go (make sure the file name is no longer in the current directory)
2. re-run the generate command (a new XXXmodel.go will be created)
3. populate XXXmodel.go with the code that is not generated by goctl according to the comments in XXXmodel_gen.go`)
return nil
}
func needShow1_3_4(dir, style string) (bool, error) {
files, err := os.ReadDir(dir)
if err != nil {
return false, nil
}
// Returns false when the directory contains a file with the suffix "_gen.go"
// In addition, it returns true if it contains a model file extension.
// In other case, false is returned.
for _, f := range files {
if f.IsDir() {
continue
}
if strings.HasSuffix(f.Name(), "_gen.go") {
return false, nil
}
}
modelSuffix, err := getModelSuffix(style)
if err != nil {
return false, err
}
for _, f := range files {
if !f.IsDir() && strings.HasSuffix(f.Name(), modelSuffix) {
return true, nil
}
}
return false, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/command/migrationnotes/v1.3.4_test.go | tools/goctl/model/sql/command/migrationnotes/v1.3.4_test.go | package migrationnotes
import (
"io/fs"
"os"
"path"
"path/filepath"
"testing"
"github.com/stretchr/testify/require"
)
func Test_needShow1_3_4(t *testing.T) {
root, err := os.MkdirTemp("", "goctl-model")
require.NoError(t, err)
defer os.RemoveAll(root)
dir1 := path.Join(root, "dir1")
require.NoError(t, os.Mkdir(dir1, fs.ModePerm))
os.WriteFile(filepath.Join(dir1, "foo_gen.go"), nil, fs.ModePerm)
dir2 := path.Join(root, "dir2")
require.NoError(t, os.Mkdir(dir2, fs.ModePerm))
os.WriteFile(filepath.Join(dir2, "foomodel.go"), nil, fs.ModePerm)
dir3 := path.Join(root, "dir3")
require.NoError(t, os.Mkdir(dir3, fs.ModePerm))
os.WriteFile(filepath.Join(dir3, "irrelevant.go"), nil, fs.ModePerm)
type args struct {
dir string
style string
}
tests := []struct {
name string
args args
want bool
wantErr bool
}{
{
name: "dir that contains *_gen.go should return false",
args: args{
dir: dir1,
},
want: false,
},
{
name: "dir that contains *model.go without *_gen.go should return true",
args: args{
dir: dir2,
},
want: true,
},
{
name: "dir that only contains irrelevant files should return false",
args: args{
dir: dir3,
},
want: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := needShow1_3_4(tt.args.dir, tt.args.style)
if (err != nil) != tt.wantErr {
t.Errorf("needShow1_3_4() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("needShow1_3_4() = %v, want %v", got, tt.want)
}
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/command/migrationnotes/migrationnotes.go | tools/goctl/model/sql/command/migrationnotes/migrationnotes.go | package migrationnotes
import (
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
)
// BeforeCommands run before command run to show some migration notes
func BeforeCommands(dir, style string) error {
if err := migrateBefore1_3_4(dir, style); err != nil {
return err
}
return nil
}
func getModelSuffix(style string) (string, error) {
cfg, err := config.NewConfig(style)
if err != nil {
return "", err
}
baseSuffix, err := format.FileNamingFormat(cfg.NamingFormat, "_model")
if err != nil {
return "", err
}
return baseSuffix + ".go", nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/model/postgresqlmodel.go | tools/goctl/model/sql/model/postgresqlmodel.go | package model
import (
"database/sql"
"strings"
"github.com/zeromicro/go-zero/core/stores/sqlx"
)
var p2m = map[string]string{
"int8": "bigint",
"float8": "double",
"float4": "float",
"int2": "smallint",
"int4": "integer",
"timestamptz": "timestamp",
"uuid": "varchar",
}
// PostgreSqlModel gets table information from information_schema、pg_catalog
type PostgreSqlModel struct {
conn sqlx.SqlConn
}
// PostgreColumn describes a column in table
type PostgreColumn struct {
Num sql.NullInt32 `db:"num"`
Field sql.NullString `db:"field"`
Type sql.NullString `db:"type"`
NotNull sql.NullBool `db:"not_null"`
Comment sql.NullString `db:"comment"`
ColumnDefault sql.NullString `db:"column_default"`
IdentityIncrement sql.NullInt32 `db:"identity_increment"`
}
// PostgreIndex describes an index for a column
type PostgreIndex struct {
IndexName sql.NullString `db:"index_name"`
IndexId sql.NullInt32 `db:"index_id"`
IsUnique sql.NullBool `db:"is_unique"`
IsPrimary sql.NullBool `db:"is_primary"`
ColumnName sql.NullString `db:"column_name"`
IndexSort sql.NullInt32 `db:"index_sort"`
}
// NewPostgreSqlModel creates an instance and return
func NewPostgreSqlModel(conn sqlx.SqlConn) *PostgreSqlModel {
return &PostgreSqlModel{
conn: conn,
}
}
// GetAllTables selects all tables from TABLE_SCHEMA
func (m *PostgreSqlModel) GetAllTables(schema string) ([]string, error) {
query := `select table_name from information_schema.tables where table_schema = $1`
var tables []string
err := m.conn.QueryRows(&tables, query, schema)
if err != nil {
return nil, err
}
return tables, nil
}
// FindColumns return columns in specified database and table
func (m *PostgreSqlModel) FindColumns(schema, table string) (*ColumnData, error) {
querySql := `select t.num,t.field,t.type,t.not_null,t.comment, c.column_default, identity_increment
from (
SELECT a.attnum AS num,
c.relname,
a.attname AS field,
t.typname AS type,
a.atttypmod AS lengthvar,
a.attnotnull AS not_null,
b.description AS comment,
(c.relnamespace::regnamespace)::varchar AS schema_name
FROM pg_class c,
pg_attribute a
LEFT OUTER JOIN pg_description b ON a.attrelid = b.objoid AND a.attnum = b.objsubid,
pg_type t
WHERE c.relname = $1
and a.attnum > 0
and a.attrelid = c.oid
and a.atttypid = t.oid
GROUP BY a.attnum, c.relname, a.attname, t.typname, a.atttypmod, a.attnotnull, b.description, c.relnamespace::regnamespace
ORDER BY a.attnum) AS t
left join information_schema.columns AS c on t.relname = c.table_name and t.schema_name = c.table_schema
and t.field = c.column_name
where c.table_schema = $2`
var reply []*PostgreColumn
err := m.conn.QueryRowsPartial(&reply, querySql, table, schema)
if err != nil {
return nil, err
}
list, err := m.getColumns(schema, table, reply)
if err != nil {
return nil, err
}
var columnData ColumnData
columnData.Db = schema
columnData.Table = table
columnData.Columns = list
return &columnData, nil
}
func (m *PostgreSqlModel) getColumns(schema, table string, in []*PostgreColumn) ([]*Column, error) {
index, err := m.getIndex(schema, table)
if err != nil {
return nil, err
}
var list []*Column
for _, e := range in {
var dft any
if len(e.ColumnDefault.String) > 0 {
dft = e.ColumnDefault
}
isNullAble := "YES"
if e.NotNull.Bool {
isNullAble = "NO"
}
var extra string
// when identity is true, the column is auto increment
if e.IdentityIncrement.Int32 == 1 {
extra = "auto_increment"
}
// when type is serial, it's auto_increment. and the default value is tablename_columnname_seq
if strings.Contains(e.ColumnDefault.String, table+"_"+e.Field.String+"_seq") {
extra = "auto_increment"
}
if len(index[e.Field.String]) > 0 {
for _, i := range index[e.Field.String] {
list = append(list, &Column{
DbColumn: &DbColumn{
Name: e.Field.String,
DataType: m.convertPostgreSqlTypeIntoMysqlType(e.Type.String),
Extra: extra,
Comment: e.Comment.String,
ColumnDefault: dft,
IsNullAble: isNullAble,
OrdinalPosition: int(e.Num.Int32),
},
Index: i,
})
}
} else {
list = append(list, &Column{
DbColumn: &DbColumn{
Name: e.Field.String,
DataType: m.convertPostgreSqlTypeIntoMysqlType(e.Type.String),
Extra: extra,
Comment: e.Comment.String,
ColumnDefault: dft,
IsNullAble: isNullAble,
OrdinalPosition: int(e.Num.Int32),
},
})
}
}
return list, nil
}
func (m *PostgreSqlModel) convertPostgreSqlTypeIntoMysqlType(in string) string {
r, ok := p2m[strings.ToLower(in)]
if ok {
return r
}
return in
}
func (m *PostgreSqlModel) getIndex(schema, table string) (map[string][]*DbIndex, error) {
indexes, err := m.FindIndex(schema, table)
if err != nil {
return nil, err
}
index := make(map[string][]*DbIndex)
for _, e := range indexes {
if e.IsPrimary.Bool {
index[e.ColumnName.String] = append(index[e.ColumnName.String], &DbIndex{
IndexName: indexPri,
SeqInIndex: int(e.IndexSort.Int32),
})
continue
}
nonUnique := 0
if !e.IsUnique.Bool {
nonUnique = 1
}
index[e.ColumnName.String] = append(index[e.ColumnName.String], &DbIndex{
IndexName: e.IndexName.String,
NonUnique: nonUnique,
SeqInIndex: int(e.IndexSort.Int32),
})
}
return index, nil
}
// FindIndex finds index with given schema, table and column.
func (m *PostgreSqlModel) FindIndex(schema, table string) ([]*PostgreIndex, error) {
querySql := `select A.INDEXNAME AS index_name,
C.INDEXRELID AS index_id,
C.INDISUNIQUE AS is_unique,
C.INDISPRIMARY AS is_primary,
G.ATTNAME AS column_name,
G.attnum AS index_sort
from PG_AM B
left join PG_CLASS F on
B.OID = F.RELAM
left join PG_STAT_ALL_INDEXES E on
F.OID = E.INDEXRELID
left join PG_INDEX C on
E.INDEXRELID = C.INDEXRELID
left outer join PG_DESCRIPTION D on
C.INDEXRELID = D.OBJOID,
PG_INDEXES A,
pg_attribute G
where A.SCHEMANAME = E.SCHEMANAME
and A.TABLENAME = E.RELNAME
and A.INDEXNAME = E.INDEXRELNAME
and F.oid = G.attrelid
and E.SCHEMANAME = $1
and E.RELNAME = $2
order by C.INDEXRELID,G.attnum`
var reply []*PostgreIndex
err := m.conn.QueryRowsPartial(&reply, querySql, schema, table)
if err != nil {
return nil, err
}
return reply, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/model/infoschemamodel.go | tools/goctl/model/sql/model/infoschemamodel.go | package model
import (
"fmt"
"sort"
"github.com/zeromicro/go-zero/core/stores/sqlx"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/util"
)
const indexPri = "PRIMARY"
type (
// InformationSchemaModel defines information schema model
InformationSchemaModel struct {
conn sqlx.SqlConn
}
// Column defines column in table
Column struct {
*DbColumn
Index *DbIndex
}
// DbColumn defines column info of columns
DbColumn struct {
Name string `db:"COLUMN_NAME"`
DataType string `db:"DATA_TYPE"`
ColumnType string `db:"COLUMN_TYPE"`
Extra string `db:"EXTRA"`
Comment string `db:"COLUMN_COMMENT"`
ColumnDefault any `db:"COLUMN_DEFAULT"`
IsNullAble string `db:"IS_NULLABLE"`
OrdinalPosition int `db:"ORDINAL_POSITION"`
}
// DbIndex defines index of columns in information_schema.statistic
DbIndex struct {
IndexName string `db:"INDEX_NAME"`
NonUnique int `db:"NON_UNIQUE"`
SeqInIndex int `db:"SEQ_IN_INDEX"`
}
// ColumnData describes the columns of table
ColumnData struct {
Db string
Table string
Columns []*Column
}
// Table describes mysql table which contains database name, table name, columns, keys
Table struct {
Db string
Table string
Columns []*Column
// Primary key not included
UniqueIndex map[string][]*Column
PrimaryKey *Column
NormalIndex map[string][]*Column
}
// IndexType describes an alias of string
IndexType string
// Index describes a column index
Index struct {
IndexType IndexType
Columns []*Column
}
)
// NewInformationSchemaModel creates an instance for InformationSchemaModel
func NewInformationSchemaModel(conn sqlx.SqlConn) *InformationSchemaModel {
return &InformationSchemaModel{conn: conn}
}
// GetAllTables selects all tables from TABLE_SCHEMA
func (m *InformationSchemaModel) GetAllTables(database string) ([]string, error) {
query := `select TABLE_NAME from TABLES where TABLE_SCHEMA = ?`
var tables []string
err := m.conn.QueryRows(&tables, query, database)
if err != nil {
return nil, err
}
return tables, nil
}
// FindColumns return columns in specified database and table
func (m *InformationSchemaModel) FindColumns(db, table string) (*ColumnData, error) {
querySql := `SELECT c.COLUMN_NAME,c.DATA_TYPE,c.COLUMN_TYPE,EXTRA,c.COLUMN_COMMENT,c.COLUMN_DEFAULT,c.IS_NULLABLE,c.ORDINAL_POSITION from COLUMNS c WHERE c.TABLE_SCHEMA = ? and c.TABLE_NAME = ? `
var reply []*DbColumn
err := m.conn.QueryRowsPartial(&reply, querySql, db, table)
if err != nil {
return nil, err
}
var list []*Column
for _, item := range reply {
index, err := m.FindIndex(db, table, item.Name)
if err != nil {
if err != sqlx.ErrNotFound {
return nil, err
}
continue
}
if len(index) > 0 {
for _, i := range index {
list = append(list, &Column{
DbColumn: item,
Index: i,
})
}
} else {
list = append(list, &Column{
DbColumn: item,
})
}
}
sort.Slice(list, func(i, j int) bool {
return list[i].OrdinalPosition < list[j].OrdinalPosition
})
var columnData ColumnData
columnData.Db = db
columnData.Table = table
columnData.Columns = list
return &columnData, nil
}
// FindIndex finds index with given db, table and column.
func (m *InformationSchemaModel) FindIndex(db, table, column string) ([]*DbIndex, error) {
querySql := `SELECT s.INDEX_NAME,s.NON_UNIQUE,s.SEQ_IN_INDEX from STATISTICS s WHERE s.TABLE_SCHEMA = ? and s.TABLE_NAME = ? and s.COLUMN_NAME = ?`
var reply []*DbIndex
err := m.conn.QueryRowsPartial(&reply, querySql, db, table, column)
if err != nil {
return nil, err
}
return reply, nil
}
// Convert converts column data into Table
func (c *ColumnData) Convert() (*Table, error) {
var table Table
table.Table = c.Table
table.Db = c.Db
table.Columns = c.Columns
table.UniqueIndex = map[string][]*Column{}
table.NormalIndex = map[string][]*Column{}
m := make(map[string][]*Column)
for _, each := range c.Columns {
each.Comment = util.TrimNewLine(each.Comment)
if each.Index != nil {
m[each.Index.IndexName] = append(m[each.Index.IndexName], each)
}
}
primaryColumns := m[indexPri]
if len(primaryColumns) == 0 {
return nil, fmt.Errorf("db:%s, table:%s, missing primary key", c.Db, c.Table)
}
if len(primaryColumns) > 1 {
return nil, fmt.Errorf("db:%s, table:%s, joint primary key is not supported", c.Db, c.Table)
}
table.PrimaryKey = primaryColumns[0]
for indexName, columns := range m {
if indexName == indexPri {
continue
}
for _, one := range columns {
if one.Index != nil {
if one.Index.NonUnique == 0 {
table.UniqueIndex[indexName] = columns
} else {
table.NormalIndex[indexName] = columns
}
}
}
}
return &table, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/imports.go | tools/goctl/model/sql/gen/imports.go | package gen
import (
"fmt"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func genImports(table Table, withCache, timeImport bool) (string, error) {
var thirdImports []string
var m = map[string]struct{}{}
for _, c := range table.Fields {
if len(c.ThirdPkg) > 0 {
if _, ok := m[c.ThirdPkg]; ok {
continue
}
m[c.ThirdPkg] = struct{}{}
thirdImports = append(thirdImports, fmt.Sprintf("%q", c.ThirdPkg))
}
}
if withCache {
text, err := pathx.LoadTemplate(category, importsTemplateFile, template.Imports)
if err != nil {
return "", err
}
buffer, err := util.With("import").Parse(text).Execute(map[string]any{
"time": timeImport,
"containsPQ": table.ContainsPQ,
"data": table,
"third": strings.Join(thirdImports, "\n"),
})
if err != nil {
return "", err
}
return buffer.String(), nil
}
text, err := pathx.LoadTemplate(category, importsWithNoCacheTemplateFile, template.ImportsNoCache)
if err != nil {
return "", err
}
buffer, err := util.With("import").Parse(text).Execute(map[string]any{
"time": timeImport,
"containsPQ": table.ContainsPQ,
"data": table,
"third": strings.Join(thirdImports, "\n"),
})
if err != nil {
return "", err
}
return buffer.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/keys_test.go | tools/goctl/model/sql/gen/keys_test.go | package gen
import (
"sort"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/parser"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
func TestGenCacheKeys(t *testing.T) {
primaryField := &parser.Field{
Name: stringx.From("id"),
DataType: "int64",
Comment: "自增id",
SeqInIndex: 1,
}
mobileField := &parser.Field{
Name: stringx.From("mobile"),
DataType: "string",
Comment: "手机号",
SeqInIndex: 1,
}
classField := &parser.Field{
Name: stringx.From("class"),
DataType: "string",
Comment: "班级",
SeqInIndex: 1,
}
nameField := &parser.Field{
Name: stringx.From("name"),
DataType: "string",
Comment: "姓名",
SeqInIndex: 2,
}
primariCacheKey, uniqueCacheKey := genCacheKeys("cache", parser.Table{
Name: stringx.From("user"),
Db: stringx.From("go_zero"),
PrimaryKey: parser.Primary{
Field: *primaryField,
AutoIncrement: true,
},
UniqueIndex: map[string][]*parser.Field{
"mobile_unique": {
mobileField,
},
"class_name_unique": {
classField,
nameField,
},
},
Fields: []*parser.Field{
primaryField,
mobileField,
classField,
nameField,
{
Name: stringx.From("createTime"),
DataType: "time.Time",
Comment: "创建时间",
},
{
Name: stringx.From("updateTime"),
DataType: "time.Time",
Comment: "更新时间",
},
},
})
t.Run("primaryCacheKey", func(t *testing.T) {
assert.Equal(t, true, func() bool {
return cacheKeyEqual(primariCacheKey, Key{
VarLeft: "cacheGoZeroUserIdPrefix",
VarRight: `"cache:goZero:user:id:"`,
VarExpression: `cacheGoZeroUserIdPrefix = "cache:goZero:user:id:"`,
KeyLeft: "goZeroUserIdKey",
KeyRight: `fmt.Sprintf("%s%v", cacheGoZeroUserIdPrefix, id)`,
DataKeyRight: `fmt.Sprintf("%s%v", cacheGoZeroUserIdPrefix, data.Id)`,
KeyExpression: `goZeroUserIdKey := fmt.Sprintf("%s%v", cacheGoZeroUserIdPrefix, id)`,
DataKeyExpression: `goZeroUserIdKey := fmt.Sprintf("%s%v", cacheGoZeroUserIdPrefix, data.Id)`,
FieldNameJoin: []string{"id"},
})
}())
})
t.Run("uniqueCacheKey", func(t *testing.T) {
assert.Equal(t, true, func() bool {
expected := []Key{
{
VarLeft: "cacheGoZeroUserClassNamePrefix",
VarRight: `"cache:goZero:user:class:name:"`,
VarExpression: `cacheGoZeroUserClassNamePrefix = "cache:goZero:user:class:name:"`,
KeyLeft: "goZeroUserClassNameKey",
KeyRight: `fmt.Sprintf("%s%v:%v", cacheGoZeroUserClassNamePrefix, class, name)`,
DataKeyRight: `fmt.Sprintf("%s%v:%v", cacheGoZeroUserClassNamePrefix, data.Class, data.Name)`,
KeyExpression: `goZeroUserClassNameKey := fmt.Sprintf("%s%v:%v", cacheGoZeroUserClassNamePrefix, class, name)`,
DataKeyExpression: `goZeroUserClassNameKey := fmt.Sprintf("%s%v:%v", cacheGoZeroUserClassNamePrefix, data.Class, data.Name)`,
FieldNameJoin: []string{"class", "name"},
},
{
VarLeft: "cacheGoZeroUserMobilePrefix",
VarRight: `"cache:goZero:user:mobile:"`,
VarExpression: `cacheGoZeroUserMobilePrefix = "cache:goZero:user:mobile:"`,
KeyLeft: "goZeroUserMobileKey",
KeyRight: `fmt.Sprintf("%s%v", cacheGoZeroUserMobilePrefix, mobile)`,
DataKeyRight: `fmt.Sprintf("%s%v", cacheGoZeroUserMobilePrefix, data.Mobile)`,
KeyExpression: `goZeroUserMobileKey := fmt.Sprintf("%s%v", cacheGoZeroUserMobilePrefix, mobile)`,
DataKeyExpression: `goZeroUserMobileKey := fmt.Sprintf("%s%v", cacheGoZeroUserMobilePrefix, data.Mobile)`,
FieldNameJoin: []string{"mobile"},
},
}
sort.Slice(uniqueCacheKey, func(i, j int) bool {
return uniqueCacheKey[i].VarLeft < uniqueCacheKey[j].VarLeft
})
if len(expected) != len(uniqueCacheKey) {
return false
}
for index, each := range uniqueCacheKey {
expecting := expected[index]
if !cacheKeyEqual(expecting, each) {
return false
}
}
return true
}())
})
t.Run("no database name", func(t *testing.T) {
primariCacheKey, _ = genCacheKeys("cache", parser.Table{
Name: stringx.From("user"),
Db: stringx.From(""),
PrimaryKey: parser.Primary{
Field: *primaryField,
AutoIncrement: true,
},
UniqueIndex: map[string][]*parser.Field{
"mobile_unique": {
mobileField,
},
"class_name_unique": {
classField,
nameField,
},
},
Fields: []*parser.Field{
primaryField,
mobileField,
classField,
nameField,
{
Name: stringx.From("createTime"),
DataType: "time.Time",
Comment: "创建时间",
},
{
Name: stringx.From("updateTime"),
DataType: "time.Time",
Comment: "更新时间",
},
},
})
assert.Equal(t, true, func() bool {
return cacheKeyEqual(primariCacheKey, Key{
VarLeft: "cacheUserIdPrefix",
VarRight: `"cache:user:id:"`,
VarExpression: `cacheUserIdPrefix = "cache:user:id:"`,
KeyLeft: "userIdKey",
KeyRight: `fmt.Sprintf("%s%v", cacheUserIdPrefix, id)`,
DataKeyRight: `fmt.Sprintf("%s%v", cacheUserIdPrefix, data.Id)`,
KeyExpression: `userIdKey := fmt.Sprintf("%s%v", cacheUserIdPrefix, id)`,
DataKeyExpression: `userIdKey := fmt.Sprintf("%s%v", cacheUserIdPrefix, data.Id)`,
FieldNameJoin: []string{"id"},
})
}())
})
}
func cacheKeyEqual(k1, k2 Key) bool {
k1Join := k1.FieldNameJoin
k2Join := k2.FieldNameJoin
sort.Strings(k1Join)
sort.Strings(k2Join)
if len(k1Join) != len(k2Join) {
return false
}
for index, each := range k1Join {
k2Item := k2Join[index]
if each != k2Item {
return false
}
}
return k1.VarLeft == k2.VarLeft &&
k1.VarRight == k2.VarRight &&
k1.VarExpression == k2.VarExpression &&
k1.KeyLeft == k2.KeyLeft &&
k1.KeyRight == k2.KeyRight &&
k1.DataKeyRight == k2.DataKeyRight &&
k1.DataKeyExpression == k2.DataKeyExpression &&
k1.KeyExpression == k2.KeyExpression
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/types.go | tools/goctl/model/sql/gen/types.go | package gen
import (
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
func genTypes(table Table, methods string, withCache bool) (string, error) {
fields := table.Fields
fieldsString, err := genFields(table, fields)
if err != nil {
return "", err
}
text, err := pathx.LoadTemplate(category, typesTemplateFile, template.Types)
if err != nil {
return "", err
}
output, err := util.With("types").
Parse(text).
Execute(map[string]any{
"withCache": withCache,
"method": methods,
"upperStartCamelObject": table.Name.ToCamel(),
"lowerStartCamelObject": stringx.From(table.Name.ToCamel()).Untitle(),
"fields": fieldsString,
"data": table,
})
if err != nil {
return "", err
}
return output.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/delete.go | tools/goctl/model/sql/gen/delete.go | package gen
import (
"sort"
"strings"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
func genDelete(table Table, withCache, postgreSql bool) (string, string, error) {
keySet := collection.NewSet[string]()
keyVariableSet := collection.NewSet[string]()
keySet.Add(table.PrimaryCacheKey.KeyExpression)
keyVariableSet.Add(table.PrimaryCacheKey.KeyLeft)
for _, key := range table.UniqueCacheKey {
keySet.Add(key.DataKeyExpression)
keyVariableSet.Add(key.KeyLeft)
}
keys := keySet.Keys()
sort.Strings(keys)
keyVars := keyVariableSet.Keys()
sort.Strings(keyVars)
camel := table.Name.ToCamel()
text, err := pathx.LoadTemplate(category, deleteTemplateFile, template.Delete)
if err != nil {
return "", "", err
}
output, err := util.With("delete").
Parse(text).
Execute(map[string]any{
"upperStartCamelObject": camel,
"withCache": withCache,
"containsIndexCache": table.ContainsUniqueCacheKey,
"lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
"dataType": table.PrimaryKey.DataType,
"keys": strings.Join(keys, "\n"),
"originalPrimaryKey": wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
"keyValues": strings.Join(keyVars, ", "),
"postgreSql": postgreSql,
"data": table,
})
if err != nil {
return "", "", err
}
// interface method
text, err = pathx.LoadTemplate(category, deleteMethodTemplateFile, template.DeleteMethod)
if err != nil {
return "", "", err
}
deleteMethodOut, err := util.With("deleteMethod").
Parse(text).
Execute(map[string]any{
"lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
"dataType": table.PrimaryKey.DataType,
"data": table,
})
if err != nil {
return "", "", err
}
return output.String(), deleteMethodOut.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/gen.go | tools/goctl/model/sql/gen/gen.go | package gen
import (
"bytes"
"fmt"
"os"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/model"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/parser"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
modelutil "github.com/zeromicro/go-zero/tools/goctl/model/sql/util"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
"github.com/zeromicro/go-zero/tools/goctl/util/format"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
const pwd = "."
type (
defaultGenerator struct {
console.Console
// source string
dir string
pkg string
cfg *config.Config
isPostgreSql bool
ignoreColumns []string
prefix string
}
// Option defines a function with argument defaultGenerator
Option func(generator *defaultGenerator)
code struct {
importsCode string
varsCode string
typesCode string
newCode string
insertCode string
findCode []string
updateCode string
deleteCode string
cacheExtra string
tableName string
customizedCode string
}
codeTuple struct {
modelCode string
modelCustomCode string
}
)
// NewDefaultGenerator creates an instance for defaultGenerator
func NewDefaultGenerator(prefix, dir string, cfg *config.Config, opt ...Option) (*defaultGenerator, error) {
if dir == "" {
dir = pwd
}
dirAbs, err := filepath.Abs(dir)
if err != nil {
return nil, err
}
dir = dirAbs
pkg := util.SafeString(filepath.Base(dirAbs))
err = pathx.MkdirIfNotExist(dir)
if err != nil {
return nil, err
}
generator := &defaultGenerator{dir: dir, cfg: cfg, pkg: pkg, prefix: prefix}
var optionList []Option
optionList = append(optionList, newDefaultOption())
optionList = append(optionList, opt...)
for _, fn := range optionList {
fn(generator)
}
return generator, nil
}
// WithConsoleOption creates a console option.
func WithConsoleOption(c console.Console) Option {
return func(generator *defaultGenerator) {
generator.Console = c
}
}
// WithIgnoreColumns ignores the columns while insert or update rows.
func WithIgnoreColumns(ignoreColumns []string) Option {
return func(generator *defaultGenerator) {
generator.ignoreColumns = ignoreColumns
}
}
// WithPostgreSql marks defaultGenerator.isPostgreSql true.
func WithPostgreSql() Option {
return func(generator *defaultGenerator) {
generator.isPostgreSql = true
}
}
func newDefaultOption() Option {
return func(generator *defaultGenerator) {
generator.Console = console.NewColorConsole()
}
}
func (g *defaultGenerator) StartFromDDL(filename string, withCache, strict bool, database string) error {
modelList, err := g.genFromDDL(filename, withCache, strict, database)
if err != nil {
return err
}
return g.createFile(modelList)
}
func (g *defaultGenerator) StartFromInformationSchema(tables map[string]*model.Table, withCache, strict bool) error {
m := make(map[string]*codeTuple)
for _, each := range tables {
table, err := parser.ConvertDataType(each, strict)
if err != nil {
return err
}
code, err := g.genModel(*table, withCache)
if err != nil {
return err
}
customCode, err := g.genModelCustom(*table, withCache)
if err != nil {
return err
}
m[table.Name.Source()] = &codeTuple{
modelCode: code,
modelCustomCode: customCode,
}
}
return g.createFile(m)
}
func (g *defaultGenerator) createFile(modelList map[string]*codeTuple) error {
dirAbs, err := filepath.Abs(g.dir)
if err != nil {
return err
}
g.dir = dirAbs
g.pkg = util.SafeString(filepath.Base(dirAbs))
err = pathx.MkdirIfNotExist(dirAbs)
if err != nil {
return err
}
for tableName, codes := range modelList {
tn := stringx.From(tableName)
modelFilename, err := format.FileNamingFormat(g.cfg.NamingFormat,
fmt.Sprintf("%s_model", tn.Source()))
if err != nil {
return err
}
name := util.SafeString(modelFilename) + "_gen.go"
filename := filepath.Join(dirAbs, name)
err = os.WriteFile(filename, []byte(codes.modelCode), os.ModePerm)
if err != nil {
return err
}
name = util.SafeString(modelFilename) + ".go"
filename = filepath.Join(dirAbs, name)
if pathx.FileExists(filename) {
g.Warning("%s already exists, ignored.", name)
continue
}
err = os.WriteFile(filename, []byte(codes.modelCustomCode), os.ModePerm)
if err != nil {
return err
}
}
// generate error file
varFilename, err := format.FileNamingFormat(g.cfg.NamingFormat, "vars")
if err != nil {
return err
}
filename := filepath.Join(dirAbs, varFilename+".go")
text, err := pathx.LoadTemplate(category, errTemplateFile, template.Error)
if err != nil {
return err
}
err = util.With("vars").Parse(text).SaveTo(map[string]any{
"pkg": g.pkg,
}, filename, false)
if err != nil {
return err
}
g.Success("Done.")
return nil
}
// ret1: key-table name,value-code
func (g *defaultGenerator) genFromDDL(filename string, withCache, strict bool, database string) (
map[string]*codeTuple, error,
) {
m := make(map[string]*codeTuple)
tables, err := parser.Parse(filename, database, strict)
if err != nil {
return nil, err
}
for _, e := range tables {
code, err := g.genModel(*e, withCache)
if err != nil {
return nil, err
}
customCode, err := g.genModelCustom(*e, withCache)
if err != nil {
return nil, err
}
m[e.Name.Source()] = &codeTuple{
modelCode: code,
modelCustomCode: customCode,
}
}
return m, nil
}
// Table defines mysql table
type Table struct {
parser.Table
PrimaryCacheKey Key
UniqueCacheKey []Key
ContainsUniqueCacheKey bool
ignoreColumns []string
}
func (t Table) isIgnoreColumns(columnName string) bool {
for _, v := range t.ignoreColumns {
if v == columnName {
return true
}
}
return false
}
func (g *defaultGenerator) genModel(in parser.Table, withCache bool) (string, error) {
if len(in.PrimaryKey.Name.Source()) == 0 {
return "", fmt.Errorf("table %s: missing primary key", in.Name.Source())
}
primaryKey, uniqueKey := genCacheKeys(g.prefix, in)
var table Table
table.Table = in
table.PrimaryCacheKey = primaryKey
table.UniqueCacheKey = uniqueKey
table.ContainsUniqueCacheKey = len(uniqueKey) > 0
table.ignoreColumns = g.ignoreColumns
importsCode, err := genImports(table, withCache, in.ContainsTime())
if err != nil {
return "", err
}
varsCode, err := genVars(table, withCache, g.isPostgreSql)
if err != nil {
return "", err
}
insertCode, insertCodeMethod, err := genInsert(table, withCache, g.isPostgreSql)
if err != nil {
return "", err
}
findCode := make([]string, 0)
findOneCode, findOneCodeMethod, err := genFindOne(table, withCache, g.isPostgreSql)
if err != nil {
return "", err
}
ret, err := genFindOneByField(table, withCache, g.isPostgreSql)
if err != nil {
return "", err
}
findCode = append(findCode, findOneCode, ret.findOneMethod)
updateCode, updateCodeMethod, err := genUpdate(table, withCache, g.isPostgreSql)
if err != nil {
return "", err
}
deleteCode, deleteCodeMethod, err := genDelete(table, withCache, g.isPostgreSql)
if err != nil {
return "", err
}
var list []string
list = append(list, insertCodeMethod, findOneCodeMethod, ret.findOneInterfaceMethod,
updateCodeMethod, deleteCodeMethod)
typesCode, err := genTypes(table, strings.Join(modelutil.TrimStringSlice(list), pathx.NL), withCache)
if err != nil {
return "", err
}
newCode, err := genNew(table, withCache, g.isPostgreSql)
if err != nil {
return "", err
}
tableName, err := genTableName(table)
if err != nil {
return "", err
}
customizedCode, err := genCustomized(table, withCache, g.isPostgreSql)
if err != nil {
return "", err
}
code := &code{
importsCode: importsCode,
varsCode: varsCode,
typesCode: typesCode,
newCode: newCode,
insertCode: insertCode,
findCode: findCode,
updateCode: updateCode,
deleteCode: deleteCode,
cacheExtra: ret.cacheExtra,
tableName: tableName,
customizedCode: customizedCode,
}
output, err := g.executeModel(table, code)
if err != nil {
return "", err
}
return output.String(), nil
}
func (g *defaultGenerator) genModelCustom(in parser.Table, withCache bool) (string, error) {
text, err := pathx.LoadTemplate(category, modelCustomTemplateFile, template.ModelCustom)
if err != nil {
return "", err
}
t := util.With("model-custom").
Parse(text).
GoFmt(true)
output, err := t.Execute(map[string]any{
"pkg": g.pkg,
"withCache": withCache,
"upperStartCamelObject": in.Name.ToCamel(),
"lowerStartCamelObject": stringx.From(in.Name.ToCamel()).Untitle(),
})
if err != nil {
return "", err
}
return output.String(), nil
}
func (g *defaultGenerator) executeModel(table Table, code *code) (*bytes.Buffer, error) {
text, err := pathx.LoadTemplate(category, modelGenTemplateFile, template.ModelGen)
if err != nil {
return nil, err
}
t := util.With("model").
Parse(text).
GoFmt(true)
output, err := t.Execute(map[string]any{
"pkg": g.pkg,
"imports": code.importsCode,
"vars": code.varsCode,
"types": code.typesCode,
"new": code.newCode,
"insert": code.insertCode,
"find": strings.Join(code.findCode, "\n"),
"update": code.updateCode,
"delete": code.deleteCode,
"extraMethod": code.cacheExtra,
"tableName": code.tableName,
"data": table,
"customized": code.customizedCode,
})
if err != nil {
return nil, err
}
return output, nil
}
func wrapWithRawString(v string, postgreSql bool) string {
if postgreSql {
return v
}
if v == "`" {
return v
}
if !strings.HasPrefix(v, "`") {
v = "`" + v
}
if !strings.HasSuffix(v, "`") {
v = v + "`"
} else if len(v) == 1 {
v = v + "`"
}
return v
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/gen_test.go | tools/goctl/model/sql/gen/gen_test.go | package gen
import (
"database/sql"
_ "embed"
"os"
"path"
"path/filepath"
"strings"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/stores/builder"
"github.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/tools/goctl/config"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/parser"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
//go:embed testdata/user.sql
var source string
func TestCacheModel(t *testing.T) {
logx.Disable()
_ = Clean()
sqlFile := filepath.Join(pathx.MustTempDir(), "tmp.sql")
err := os.WriteFile(sqlFile, []byte(source), 0o777)
assert.Nil(t, err)
dir := filepath.Join(pathx.MustTempDir(), "./testmodel")
cacheDir := filepath.Join(dir, "cache")
noCacheDir := filepath.Join(dir, "nocache")
g, err := NewDefaultGenerator("cache", cacheDir, &config.Config{
NamingFormat: "GoZero",
})
assert.Nil(t, err)
err = g.StartFromDDL(sqlFile, true, false, "go_zero")
assert.Nil(t, err)
assert.True(t, func() bool {
_, err := os.Stat(filepath.Join(cacheDir, "TestUserModel.go"))
return err == nil
}())
g, err = NewDefaultGenerator("cache", noCacheDir, &config.Config{
NamingFormat: "gozero",
})
assert.Nil(t, err)
err = g.StartFromDDL(sqlFile, false, false, "go_zero")
assert.Nil(t, err)
assert.True(t, func() bool {
_, err := os.Stat(filepath.Join(noCacheDir, "testusermodel.go"))
return err == nil
}())
}
func TestNamingModel(t *testing.T) {
logx.Disable()
_ = Clean()
sqlFile := filepath.Join(pathx.MustTempDir(), "tmp.sql")
err := os.WriteFile(sqlFile, []byte(source), 0o777)
assert.Nil(t, err)
dir, _ := filepath.Abs("./testmodel")
camelDir := filepath.Join(dir, "camel")
snakeDir := filepath.Join(dir, "snake")
defer func() {
_ = os.RemoveAll(dir)
}()
g, err := NewDefaultGenerator("cache", camelDir, &config.Config{
NamingFormat: "GoZero",
})
assert.Nil(t, err)
err = g.StartFromDDL(sqlFile, true, false, "go_zero")
assert.Nil(t, err)
assert.True(t, func() bool {
_, err := os.Stat(filepath.Join(camelDir, "TestUserModel.go"))
return err == nil
}())
g, err = NewDefaultGenerator("cache", snakeDir, &config.Config{
NamingFormat: "go_zero",
})
assert.Nil(t, err)
err = g.StartFromDDL(sqlFile, true, false, "go_zero")
assert.Nil(t, err)
assert.True(t, func() bool {
_, err := os.Stat(filepath.Join(snakeDir, "test_user_model.go"))
return err == nil
}())
}
func TestFolderName(t *testing.T) {
logx.Disable()
_ = Clean()
sqlFile := filepath.Join(pathx.MustTempDir(), "tmp.sql")
err := os.WriteFile(sqlFile, []byte(source), 0o777)
assert.Nil(t, err)
dir, _ := filepath.Abs("./testmodel")
camelDir := filepath.Join(dir, "go-camel")
snakeDir := filepath.Join(dir, "go-snake")
defer func() {
_ = os.RemoveAll(dir)
}()
g, err := NewDefaultGenerator("cache", camelDir, &config.Config{
NamingFormat: "GoZero",
})
assert.Nil(t, err)
pkg := g.pkg
err = g.StartFromDDL(sqlFile, true, true, "go_zero")
assert.Nil(t, err)
assert.True(t, func() bool {
_, err := os.Stat(filepath.Join(camelDir, "TestUserModel.go"))
return err == nil
}())
assert.Equal(t, pkg, g.pkg)
g, err = NewDefaultGenerator("cache", snakeDir, &config.Config{
NamingFormat: "go_zero",
})
assert.Nil(t, err)
err = g.StartFromDDL(sqlFile, true, true, "go_zero")
assert.Nil(t, err)
assert.True(t, func() bool {
_, err := os.Stat(filepath.Join(snakeDir, "test_user_model.go"))
return err == nil
}())
}
func TestWrapWithRawString(t *testing.T) {
assert.Equal(t, "``", wrapWithRawString("", false))
assert.Equal(t, "``", wrapWithRawString("``", false))
assert.Equal(t, "`a`", wrapWithRawString("a", false))
assert.Equal(t, "a", wrapWithRawString("a", true))
assert.Equal(t, "` `", wrapWithRawString(" ", false))
}
func TestFields(t *testing.T) {
type Student struct {
ID int64 `db:"id"`
Name string `db:"name"`
Age sql.NullInt64 `db:"age"`
Score sql.NullFloat64 `db:"score"`
CreateTime time.Time `db:"create_time"`
UpdateTime sql.NullTime `db:"update_time"`
}
var (
studentFieldNames = builder.RawFieldNames(&Student{})
studentRows = strings.Join(studentFieldNames, ",")
studentRowsExpectAutoSet = strings.Join(stringx.Remove(studentFieldNames, "`id`", "`create_time`", "`update_time`"), ",")
studentRowsWithPlaceHolder = strings.Join(stringx.Remove(studentFieldNames, "`id`", "`create_time`", "`update_time`"), "=?,") + "=?"
)
assert.Equal(t, []string{"`id`", "`name`", "`age`", "`score`", "`create_time`", "`update_time`"}, studentFieldNames)
assert.Equal(t, "`id`,`name`,`age`,`score`,`create_time`,`update_time`", studentRows)
assert.Equal(t, "`name`,`age`,`score`", studentRowsExpectAutoSet)
assert.Equal(t, "`name`=?,`age`=?,`score`=?", studentRowsWithPlaceHolder)
}
func Test_genPublicModel(t *testing.T) {
var err error
dir := pathx.MustTempDir()
modelDir := path.Join(dir, "model")
err = os.MkdirAll(modelDir, 0o777)
require.NoError(t, err)
defer os.RemoveAll(dir)
modelFilename := filepath.Join(modelDir, "foo.sql")
err = os.WriteFile(modelFilename, []byte(source), 0o777)
require.NoError(t, err)
g, err := NewDefaultGenerator("cache", modelDir, &config.Config{
NamingFormat: config.DefaultFormat,
})
require.NoError(t, err)
tables, err := parser.Parse(modelFilename, "", false)
require.Equal(t, 1, len(tables))
code, err := g.genModelCustom(*tables[0], false)
assert.NoError(t, err)
assert.True(t, strings.Contains(code, "package model"))
assert.True(t, strings.Contains(code, ` TestUserModel interface {
testUserModel
withSession(session sqlx.Session) TestUserModel
}`))
assert.True(t, strings.Contains(code, "customTestUserModel struct {\n\t\t*defaultTestUserModel\n\t}\n"))
assert.True(t, strings.Contains(code, "func NewTestUserModel(conn sqlx.SqlConn) TestUserModel {"))
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/field.go | tools/goctl/model/sql/gen/field.go | package gen
import (
"strings"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/parser"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func genFields(table Table, fields []*parser.Field) (string, error) {
var list []string
for _, field := range fields {
result, err := genField(table, field)
if err != nil {
return "", err
}
list = append(list, result)
}
return strings.Join(list, "\n"), nil
}
func genField(table Table, field *parser.Field) (string, error) {
tag, err := genTag(table, field.NameOriginal)
if err != nil {
return "", err
}
text, err := pathx.LoadTemplate(category, fieldTemplateFile, template.Field)
if err != nil {
return "", err
}
output, err := util.With("types").
Parse(text).
Execute(map[string]any{
"name": util.SafeString(field.Name.ToCamel()),
"type": field.DataType,
"tag": tag,
"hasComment": field.Comment != "",
"comment": field.Comment,
"data": table,
})
if err != nil {
return "", err
}
return output.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/findonebyfield.go | tools/goctl/model/sql/gen/findonebyfield.go | package gen
import (
"fmt"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
type findOneCode struct {
findOneMethod string
findOneInterfaceMethod string
cacheExtra string
}
func genFindOneByField(table Table, withCache, postgreSql bool) (*findOneCode, error) {
text, err := pathx.LoadTemplate(category, findOneByFieldTemplateFile, template.FindOneByField)
if err != nil {
return nil, err
}
t := util.With("findOneByField").Parse(text)
var list []string
camelTableName := table.Name.ToCamel()
for _, key := range table.UniqueCacheKey {
in, paramJoinString, originalFieldString := convertJoin(key, postgreSql)
output, err := t.Execute(map[string]any{
"upperStartCamelObject": camelTableName,
"upperField": key.FieldNameJoin.Camel().With("").Source(),
"in": in,
"withCache": withCache,
"cacheKey": key.KeyExpression,
"cacheKeyVariable": key.KeyLeft,
"lowerStartCamelObject": stringx.From(camelTableName).Untitle(),
"lowerStartCamelField": paramJoinString,
"upperStartCamelPrimaryKey": table.PrimaryKey.Name.ToCamel(),
"originalField": originalFieldString,
"postgreSql": postgreSql,
"data": table,
})
if err != nil {
return nil, err
}
list = append(list, output.String())
}
text, err = pathx.LoadTemplate(category, findOneByFieldMethodTemplateFile, template.FindOneByFieldMethod)
if err != nil {
return nil, err
}
t = util.With("findOneByFieldMethod").Parse(text)
var listMethod []string
for _, key := range table.UniqueCacheKey {
var inJoin, paramJoin Join
for _, f := range key.Fields {
param := util.EscapeGolangKeyword(stringx.From(f.Name.ToCamel()).Untitle())
inJoin = append(inJoin, fmt.Sprintf("%s %s", param, f.DataType))
paramJoin = append(paramJoin, param)
}
var in string
if len(inJoin) > 0 {
in = inJoin.With(", ").Source()
}
output, err := t.Execute(map[string]any{
"upperStartCamelObject": camelTableName,
"upperField": key.FieldNameJoin.Camel().With("").Source(),
"in": in,
"data": table,
})
if err != nil {
return nil, err
}
listMethod = append(listMethod, output.String())
}
if withCache {
text, err := pathx.LoadTemplate(category, findOneByFieldExtraMethodTemplateFile,
template.FindOneByFieldExtraMethod)
if err != nil {
return nil, err
}
out, err := util.With("findOneByFieldExtraMethod").Parse(text).Execute(map[string]any{
"upperStartCamelObject": camelTableName,
"primaryKeyLeft": table.PrimaryCacheKey.VarLeft,
"lowerStartCamelObject": stringx.From(camelTableName).Untitle(),
"originalPrimaryField": wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
"postgreSql": postgreSql,
"data": table,
})
if err != nil {
return nil, err
}
return &findOneCode{
findOneMethod: strings.Join(list, pathx.NL),
findOneInterfaceMethod: strings.Join(listMethod, pathx.NL),
cacheExtra: out.String(),
}, nil
}
return &findOneCode{
findOneMethod: strings.Join(list, pathx.NL),
findOneInterfaceMethod: strings.Join(listMethod, pathx.NL),
}, nil
}
func convertJoin(key Key, postgreSql bool) (in, paramJoinString, originalFieldString string) {
var inJoin, paramJoin, argJoin Join
for index, f := range key.Fields {
param := util.EscapeGolangKeyword(stringx.From(f.Name.ToCamel()).Untitle())
inJoin = append(inJoin, fmt.Sprintf("%s %s", param, f.DataType))
paramJoin = append(paramJoin, param)
if postgreSql {
argJoin = append(argJoin, fmt.Sprintf("%s = $%d", wrapWithRawString(f.Name.Source(), postgreSql), index+1))
} else {
argJoin = append(argJoin, fmt.Sprintf("%s = ?", wrapWithRawString(f.Name.Source(), postgreSql)))
}
}
if len(inJoin) > 0 {
in = inJoin.With(", ").Source()
}
if len(paramJoin) > 0 {
paramJoinString = paramJoin.With(",").Source()
}
if len(argJoin) > 0 {
originalFieldString = argJoin.With(" and ").Source()
}
return in, paramJoinString, originalFieldString
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/customized.go | tools/goctl/model/sql/gen/customized.go | package gen
import (
"fmt"
"sort"
"strings"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
// Field describes a table field
type Field struct {
NameOriginal string
UpperName string
LowerName string
DataType string
Comment string
SeqInIndex int
OrdinalPosition int
}
func genCustomized(table Table, withCache, postgreSql bool) (string, error) {
expressions := make([]string, 0)
expressionValues := make([]string, 0)
fields := make([]Field, 0)
var count int
for _, field := range table.Fields {
camel := util.SafeString(field.Name.ToCamel())
if table.isIgnoreColumns(field.Name.Source()) {
continue
}
if field.Name.Source() == table.PrimaryKey.Name.Source() {
if table.PrimaryKey.AutoIncrement {
continue
}
}
count += 1
if postgreSql {
expressions = append(expressions, fmt.Sprintf("$%d", count))
} else {
expressions = append(expressions, "?")
}
expressionValues = append(expressionValues, "data."+camel)
f := Field{
NameOriginal: field.NameOriginal,
UpperName: camel,
LowerName: stringx.From(camel).Untitle(),
DataType: field.DataType,
Comment: field.Comment,
SeqInIndex: field.SeqInIndex,
OrdinalPosition: field.OrdinalPosition,
}
fields = append(fields, f)
}
keySet := collection.NewSet[string]()
keyVariableSet := collection.NewSet[string]()
keySet.Add(table.PrimaryCacheKey.KeyExpression)
keyVariableSet.Add(table.PrimaryCacheKey.KeyLeft)
for _, key := range table.UniqueCacheKey {
keySet.Add(key.DataKeyExpression)
keyVariableSet.Add(key.KeyLeft)
}
keys := keySet.Keys()
sort.Strings(keys)
keyVars := keyVariableSet.Keys()
sort.Strings(keyVars)
camel := table.Name.ToCamel()
text, err := pathx.LoadTemplate(category, customizedTemplateFile, template.Customized)
if err != nil {
return "", err
}
output, err := util.With("customized").
Parse(text).
Execute(map[string]any{
"withCache": withCache,
"containsIndexCache": table.ContainsUniqueCacheKey,
"upperStartCamelObject": camel,
"lowerStartCamelObject": stringx.From(camel).Untitle(),
"lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
"upperStartCamelPrimaryKey": table.PrimaryKey.Name.ToCamel(),
"primaryKeyDataType": table.PrimaryKey.DataType,
"originalPrimaryKey": wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
"primaryCacheKey": table.PrimaryCacheKey.DataKeyExpression,
"primaryKeyVariable": table.PrimaryCacheKey.KeyLeft,
"keys": strings.Join(keys, "\n"),
"keyValues": strings.Join(keyVars, ", "),
"expression": strings.Join(expressions, ", "),
"expressionValues": strings.Join(expressionValues, ", "),
"postgreSql": postgreSql,
"fields": fields,
"data": table,
})
if err != nil {
return "", err
}
return output.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/tag.go | tools/goctl/model/sql/gen/tag.go | package gen
import (
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func genTag(table Table, in string) (string, error) {
if in == "" {
return in, nil
}
text, err := pathx.LoadTemplate(category, tagTemplateFile, template.Tag)
if err != nil {
return "", err
}
output, err := util.With("tag").Parse(text).Execute(map[string]any{
"field": in,
"data": table,
})
if err != nil {
return "", err
}
return output.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/vars.go | tools/goctl/model/sql/gen/vars.go | package gen
import (
"fmt"
"sort"
"strings"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
func genVars(table Table, withCache, postgreSql bool) (string, error) {
keys := make([]string, 0)
keys = append(keys, table.PrimaryCacheKey.VarExpression)
for _, v := range table.UniqueCacheKey {
keys = append(keys, v.VarExpression)
}
camel := table.Name.ToCamel()
text, err := pathx.LoadTemplate(category, varTemplateFile, template.Vars)
if err != nil {
return "", err
}
output, err := util.With("var").Parse(text).
GoFmt(true).Execute(map[string]any{
"lowerStartCamelObject": stringx.From(camel).Untitle(),
"upperStartCamelObject": camel,
"cacheKeys": strings.Join(keys, "\n"),
"autoIncrement": table.PrimaryKey.AutoIncrement,
"originalPrimaryKey": wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
"withCache": withCache,
"postgreSql": postgreSql,
"data": table,
"ignoreColumns": func() string {
var set = collection.NewSet[string]()
for _, c := range table.ignoreColumns {
if postgreSql {
set.Add(fmt.Sprintf(`"%s"`, c))
} else {
set.Add(fmt.Sprintf("\"`%s`\"", c))
}
}
list := set.Keys()
sort.Strings(list)
return strings.Join(list, ", ")
}(),
})
if err != nil {
return "", err
}
return output.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/tablename.go | tools/goctl/model/sql/gen/tablename.go | package gen
import (
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func genTableName(table Table) (string, error) {
text, err := pathx.LoadTemplate(category, tableNameTemplateFile, template.TableName)
if err != nil {
return "", err
}
output, err := util.With("tableName").
Parse(text).
Execute(map[string]any{
"tableName": table.Name.Source(),
"upperStartCamelObject": table.Name.ToCamel(),
})
if err != nil {
return "", nil
}
return output.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/new.go | tools/goctl/model/sql/gen/new.go | package gen
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func genNew(table Table, withCache, postgreSql bool) (string, error) {
text, err := pathx.LoadTemplate(category, modelNewTemplateFile, template.New)
if err != nil {
return "", err
}
t := fmt.Sprintf(`"%s"`, wrapWithRawString(table.Name.Source(), postgreSql))
if postgreSql {
t = "`" + fmt.Sprintf(`"%s"."%s"`, table.Db.Source(), table.Name.Source()) + "`"
}
output, err := util.With("new").
Parse(text).
Execute(map[string]any{
"table": t,
"withCache": withCache,
"upperStartCamelObject": table.Name.ToCamel(),
"data": table,
})
if err != nil {
return "", err
}
return output.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/template_test.go | tools/goctl/model/sql/gen/template_test.go | package gen
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func TestGenTemplates(t *testing.T) {
err := pathx.InitTemplates(category, templates)
assert.Nil(t, err)
dir, err := pathx.GetTemplateDir(category)
assert.Nil(t, err)
file := filepath.Join(dir, "model-new.tpl")
data, err := os.ReadFile(file)
assert.Nil(t, err)
assert.Equal(t, string(data), template.New)
}
func TestRevertTemplate(t *testing.T) {
name := "model-new.tpl"
err := pathx.InitTemplates(category, templates)
assert.Nil(t, err)
dir, err := pathx.GetTemplateDir(category)
assert.Nil(t, err)
file := filepath.Join(dir, name)
data, err := os.ReadFile(file)
assert.Nil(t, err)
modifyData := string(data) + "modify"
err = pathx.CreateTemplate(category, name, modifyData)
assert.Nil(t, err)
data, err = os.ReadFile(file)
assert.Nil(t, err)
assert.Equal(t, string(data), modifyData)
assert.Nil(t, RevertTemplate(name))
data, err = os.ReadFile(file)
assert.Nil(t, err)
assert.Equal(t, template.New, string(data))
}
func TestClean(t *testing.T) {
name := "model-new.tpl"
err := pathx.InitTemplates(category, templates)
assert.Nil(t, err)
assert.Nil(t, Clean())
dir, err := pathx.GetTemplateDir(category)
assert.Nil(t, err)
file := filepath.Join(dir, name)
_, err = os.ReadFile(file)
assert.NotNil(t, err)
}
func TestUpdate(t *testing.T) {
name := "model-new.tpl"
err := pathx.InitTemplates(category, templates)
assert.Nil(t, err)
dir, err := pathx.GetTemplateDir(category)
assert.Nil(t, err)
file := filepath.Join(dir, name)
data, err := os.ReadFile(file)
assert.Nil(t, err)
modifyData := string(data) + "modify"
err = pathx.CreateTemplate(category, name, modifyData)
assert.Nil(t, err)
data, err = os.ReadFile(file)
assert.Nil(t, err)
assert.Equal(t, string(data), modifyData)
assert.Nil(t, Update())
data, err = os.ReadFile(file)
assert.Nil(t, err)
assert.Equal(t, template.New, string(data))
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/keys.go | tools/goctl/model/sql/gen/keys.go | package gen
import (
"fmt"
"sort"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/parser"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
// Key describes cache key
type Key struct {
// VarLeft describes the variable of cache key expression which likes cacheUserIdPrefix
VarLeft string
// VarRight describes the value of cache key expression which likes "cache:user:id:"
VarRight string
// VarExpression describes the cache key expression which likes cacheUserIdPrefix = "cache:user:id:"
VarExpression string
// KeyLeft describes the variable of key definition expression which likes userKey
KeyLeft string
// KeyRight describes the value of key definition expression which likes fmt.Sprintf("%s%v", cacheUserPrefix, user)
KeyRight string
// DataKeyRight describes data key likes fmt.Sprintf("%s%v", cacheUserPrefix, data.User)
DataKeyRight string
// KeyExpression describes key expression likes userKey := fmt.Sprintf("%s%v", cacheUserPrefix, user)
KeyExpression string
// DataKeyExpression describes data key expression likes userKey := fmt.Sprintf("%s%v", cacheUserPrefix, data.User)
DataKeyExpression string
// FieldNameJoin describes the filed slice of table
FieldNameJoin Join
// Fields describes the fields of table
Fields []*parser.Field
}
// Join describes an alias of string slice
type Join []string
func genCacheKeys(prefix string, table parser.Table) (Key, []Key) {
var primaryKey Key
primaryKey = genCacheKey(prefix, table.Db, table.Name, []*parser.Field{&table.PrimaryKey.Field})
uniqueKey := make([]Key, 0, len(table.UniqueIndex))
for _, each := range table.UniqueIndex {
uniqueKey = append(uniqueKey, genCacheKey(prefix, table.Db, table.Name, each))
}
sort.Slice(uniqueKey, func(i, j int) bool {
return uniqueKey[i].VarLeft < uniqueKey[j].VarLeft
})
return primaryKey, uniqueKey
}
func genCacheKey(prefix string, db, table stringx.String, in []*parser.Field) Key {
var (
varLeftJoin, varRightJoin, fieldNameJoin Join
varLeft, varRight, varExpression string
keyLeftJoin, keyRightJoin, keyRightArgJoin, dataRightJoin Join
keyLeft, keyRight, dataKeyRight, keyExpression, dataKeyExpression string
)
dbName, tableName := util.SafeString(db.Source()), util.SafeString(table.Source())
if len(dbName) > 0 {
varLeftJoin = append(varLeftJoin, prefix, dbName, tableName)
varRightJoin = append(varRightJoin, prefix, dbName, tableName)
keyLeftJoin = append(keyLeftJoin, dbName, tableName)
} else {
varLeftJoin = append(varLeftJoin, prefix, tableName)
varRightJoin = append(varRightJoin, prefix, tableName)
keyLeftJoin = append(keyLeftJoin, tableName)
}
for _, each := range in {
varLeftJoin = append(varLeftJoin, each.Name.Source())
varRightJoin = append(varRightJoin, each.Name.Source())
keyLeftJoin = append(keyLeftJoin, each.Name.Source())
keyRightJoin = append(keyRightJoin, util.EscapeGolangKeyword(stringx.From(each.Name.ToCamel()).Untitle()))
keyRightArgJoin = append(keyRightArgJoin, "%v")
dataRightJoin = append(dataRightJoin, "data."+each.Name.ToCamel())
fieldNameJoin = append(fieldNameJoin, each.Name.Source())
}
varLeftJoin = append(varLeftJoin, "prefix")
keyLeftJoin = append(keyLeftJoin, "key")
varLeft = util.SafeString(varLeftJoin.Camel().With("").Untitle())
varRight = fmt.Sprintf(`"%s"`, varRightJoin.Camel().Untitle().With(":").Source()+":")
varExpression = fmt.Sprintf(`%s = %s`, varLeft, varRight)
keyLeft = util.SafeString(keyLeftJoin.Camel().With("").Untitle())
keyRight = fmt.Sprintf(`fmt.Sprintf("%s%s", %s, %s)`, "%s", keyRightArgJoin.With(":").Source(), varLeft, keyRightJoin.With(", ").Source())
dataKeyRight = fmt.Sprintf(`fmt.Sprintf("%s%s", %s, %s)`, "%s", keyRightArgJoin.With(":").Source(), varLeft, dataRightJoin.With(", ").Source())
keyExpression = fmt.Sprintf("%s := %s", keyLeft, keyRight)
dataKeyExpression = fmt.Sprintf("%s := %s", keyLeft, dataKeyRight)
return Key{
VarLeft: varLeft,
VarRight: varRight,
VarExpression: varExpression,
KeyLeft: keyLeft,
KeyRight: keyRight,
DataKeyRight: dataKeyRight,
KeyExpression: keyExpression,
DataKeyExpression: dataKeyExpression,
Fields: in,
FieldNameJoin: fieldNameJoin,
}
}
// Title convert items into Title and return
func (j Join) Title() Join {
var join Join
for _, each := range j {
join = append(join, stringx.From(each).Title())
}
return join
}
// Camel convert items into Camel and return
func (j Join) Camel() Join {
var join Join
for _, each := range j {
join = append(join, stringx.From(each).ToCamel())
}
return join
}
// Snake convert items into Snake and return
func (j Join) Snake() Join {
var join Join
for _, each := range j {
join = append(join, stringx.From(each).ToSnake())
}
return join
}
// Untitle converts items into Untitle and return
func (j Join) Untitle() Join {
var join Join
for _, each := range j {
join = append(join, stringx.From(each).Untitle())
}
return join
}
// Upper convert items into Upper and return
func (j Join) Upper() Join {
var join Join
for _, each := range j {
join = append(join, stringx.From(each).Upper())
}
return join
}
// Lower convert items into Lower and return
func (j Join) Lower() Join {
var join Join
for _, each := range j {
join = append(join, stringx.From(each).Lower())
}
return join
}
// With convert items into With and return
func (j Join) With(sep string) stringx.String {
return stringx.From(strings.Join(j, sep))
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/insert.go | tools/goctl/model/sql/gen/insert.go | package gen
import (
"fmt"
"sort"
"strings"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
func genInsert(table Table, withCache, postgreSql bool) (string, string, error) {
keySet := collection.NewSet[string]()
keyVariableSet := collection.NewSet[string]()
keySet.Add(table.PrimaryCacheKey.DataKeyExpression)
keyVariableSet.Add(table.PrimaryCacheKey.KeyLeft)
for _, key := range table.UniqueCacheKey {
keySet.Add(key.DataKeyExpression)
keyVariableSet.Add(key.KeyLeft)
}
keys := keySet.Keys()
sort.Strings(keys)
keyVars := keyVariableSet.Keys()
sort.Strings(keyVars)
expressions := make([]string, 0)
expressionValues := make([]string, 0)
var count int
for _, field := range table.Fields {
camel := util.SafeString(field.Name.ToCamel())
if table.isIgnoreColumns(field.Name.Source()) {
continue
}
if field.Name.Source() == table.PrimaryKey.Name.Source() {
if table.PrimaryKey.AutoIncrement {
continue
}
}
count += 1
if postgreSql {
expressions = append(expressions, fmt.Sprintf("$%d", count))
} else {
expressions = append(expressions, "?")
}
expressionValues = append(expressionValues, "data."+camel)
}
camel := table.Name.ToCamel()
text, err := pathx.LoadTemplate(category, insertTemplateFile, template.Insert)
if err != nil {
return "", "", err
}
output, err := util.With("insert").
Parse(text).
Execute(map[string]any{
"withCache": withCache,
"upperStartCamelObject": camel,
"lowerStartCamelObject": stringx.From(camel).Untitle(),
"expression": strings.Join(expressions, ", "),
"expressionValues": strings.Join(expressionValues, ", "),
"keys": strings.Join(keys, "\n"),
"keyValues": strings.Join(keyVars, ", "),
"data": table,
})
if err != nil {
return "", "", err
}
// interface method
text, err = pathx.LoadTemplate(category, insertTemplateMethodFile, template.InsertMethod)
if err != nil {
return "", "", err
}
insertMethodOutput, err := util.With("insertMethod").Parse(text).Execute(map[string]any{
"upperStartCamelObject": camel,
"data": table,
})
if err != nil {
return "", "", err
}
return output.String(), insertMethodOutput.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/template.go | tools/goctl/model/sql/gen/template.go | package gen
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const (
category = "model"
customizedTemplateFile = "customized.tpl"
deleteTemplateFile = "delete.tpl"
deleteMethodTemplateFile = "interface-delete.tpl"
fieldTemplateFile = "field.tpl"
findOneTemplateFile = "find-one.tpl"
findOneMethodTemplateFile = "interface-find-one.tpl"
findOneByFieldTemplateFile = "find-one-by-field.tpl"
findOneByFieldMethodTemplateFile = "interface-find-one-by-field.tpl"
findOneByFieldExtraMethodTemplateFile = "find-one-by-field-extra-method.tpl"
importsTemplateFile = "import.tpl"
importsWithNoCacheTemplateFile = "import-no-cache.tpl"
insertTemplateFile = "insert.tpl"
insertTemplateMethodFile = "interface-insert.tpl"
modelGenTemplateFile = "model-gen.tpl"
modelCustomTemplateFile = "model.tpl"
modelNewTemplateFile = "model-new.tpl"
tableNameTemplateFile = "table-name.tpl"
tagTemplateFile = "tag.tpl"
typesTemplateFile = "types.tpl"
updateTemplateFile = "update.tpl"
updateMethodTemplateFile = "interface-update.tpl"
varTemplateFile = "var.tpl"
errTemplateFile = "err.tpl"
)
var templates = map[string]string{
customizedTemplateFile: template.Customized,
deleteTemplateFile: template.Delete,
deleteMethodTemplateFile: template.DeleteMethod,
fieldTemplateFile: template.Field,
findOneTemplateFile: template.FindOne,
findOneMethodTemplateFile: template.FindOneMethod,
findOneByFieldTemplateFile: template.FindOneByField,
findOneByFieldMethodTemplateFile: template.FindOneByFieldMethod,
findOneByFieldExtraMethodTemplateFile: template.FindOneByFieldExtraMethod,
importsTemplateFile: template.Imports,
importsWithNoCacheTemplateFile: template.ImportsNoCache,
insertTemplateFile: template.Insert,
insertTemplateMethodFile: template.InsertMethod,
modelGenTemplateFile: template.ModelGen,
modelCustomTemplateFile: template.ModelCustom,
modelNewTemplateFile: template.New,
tableNameTemplateFile: template.TableName,
tagTemplateFile: template.Tag,
typesTemplateFile: template.Types,
updateTemplateFile: template.Update,
updateMethodTemplateFile: template.UpdateMethod,
varTemplateFile: template.Vars,
errTemplateFile: template.Error,
}
// Category returns model const value
func Category() string {
return category
}
// Clean deletes all template files
func Clean() error {
return pathx.Clean(category)
}
// GenTemplates creates template files if not exists
func GenTemplates() error {
return pathx.InitTemplates(category, templates)
}
// RevertTemplate reverts the deleted template files
func RevertTemplate(name string) error {
content, ok := templates[name]
if !ok {
return fmt.Errorf("%s: no such file name", name)
}
return pathx.CreateTemplate(category, name, content)
}
// Update provides template clean and init
func Update() error {
err := Clean()
if err != nil {
return err
}
return pathx.InitTemplates(category, templates)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/update.go | tools/goctl/model/sql/gen/update.go | package gen
import (
"sort"
"strings"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
func genUpdate(table Table, withCache, postgreSql bool) (
string, string, error,
) {
expressionValues := make([]string, 0)
pkg := "data."
if table.ContainsUniqueCacheKey {
pkg = "newData."
}
for _, field := range table.Fields {
camel := util.SafeString(field.Name.ToCamel())
if table.isIgnoreColumns(field.Name.Source()) {
continue
}
if field.Name.Source() == table.PrimaryKey.Name.Source() {
continue
}
expressionValues = append(expressionValues, pkg+camel)
}
keySet := collection.NewSet[string]()
keyVariableSet := collection.NewSet[string]()
keySet.Add(table.PrimaryCacheKey.DataKeyExpression)
keyVariableSet.Add(table.PrimaryCacheKey.KeyLeft)
for _, key := range table.UniqueCacheKey {
keySet.Add(key.DataKeyExpression)
keyVariableSet.Add(key.KeyLeft)
}
keys := keySet.Keys()
sort.Strings(keys)
keyVars := keyVariableSet.Keys()
sort.Strings(keyVars)
if postgreSql {
expressionValues = append(
[]string{pkg + table.PrimaryKey.Name.ToCamel()},
expressionValues...,
)
} else {
expressionValues = append(
expressionValues, pkg+table.PrimaryKey.Name.ToCamel(),
)
}
camelTableName := table.Name.ToCamel()
text, err := pathx.LoadTemplate(category, updateTemplateFile, template.Update)
if err != nil {
return "", "", err
}
output, err := util.With("update").Parse(text).Execute(
map[string]any{
"withCache": withCache,
"containsIndexCache": table.ContainsUniqueCacheKey,
"upperStartCamelObject": camelTableName,
"keys": strings.Join(keys, "\n"),
"keyValues": strings.Join(keyVars, ", "),
"primaryCacheKey": table.PrimaryCacheKey.DataKeyExpression,
"primaryKeyVariable": table.PrimaryCacheKey.KeyLeft,
"lowerStartCamelObject": stringx.From(camelTableName).Untitle(),
"upperStartCamelPrimaryKey": util.EscapeGolangKeyword(
stringx.From(table.PrimaryKey.Name.ToCamel()).Title(),
),
"originalPrimaryKey": wrapWithRawString(
table.PrimaryKey.Name.Source(), postgreSql,
),
"expressionValues": strings.Join(
expressionValues, ", ",
),
"postgreSql": postgreSql,
"data": table,
},
)
if err != nil {
return "", "", nil
}
// update interface method
text, err = pathx.LoadTemplate(category, updateMethodTemplateFile, template.UpdateMethod)
if err != nil {
return "", "", err
}
updateMethodOutput, err := util.With("updateMethod").Parse(text).Execute(
map[string]any{
"upperStartCamelObject": camelTableName,
"data": table,
},
)
if err != nil {
return "", "", nil
}
return output.String(), updateMethodOutput.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/gen/findone.go | tools/goctl/model/sql/gen/findone.go | package gen
import (
"github.com/zeromicro/go-zero/tools/goctl/model/sql/template"
"github.com/zeromicro/go-zero/tools/goctl/util"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
func genFindOne(table Table, withCache, postgreSql bool) (string, string, error) {
camel := table.Name.ToCamel()
text, err := pathx.LoadTemplate(category, findOneTemplateFile, template.FindOne)
if err != nil {
return "", "", err
}
output, err := util.With("findOne").
Parse(text).
Execute(map[string]any{
"withCache": withCache,
"upperStartCamelObject": camel,
"lowerStartCamelObject": stringx.From(camel).Untitle(),
"originalPrimaryKey": wrapWithRawString(table.PrimaryKey.Name.Source(), postgreSql),
"lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
"dataType": table.PrimaryKey.DataType,
"cacheKey": table.PrimaryCacheKey.KeyExpression,
"cacheKeyVariable": table.PrimaryCacheKey.KeyLeft,
"postgreSql": postgreSql,
"data": table,
})
if err != nil {
return "", "", err
}
text, err = pathx.LoadTemplate(category, findOneMethodTemplateFile, template.FindOneMethod)
if err != nil {
return "", "", err
}
findOneMethod, err := util.With("findOneMethod").
Parse(text).
Execute(map[string]any{
"upperStartCamelObject": camel,
"lowerStartCamelPrimaryKey": util.EscapeGolangKeyword(stringx.From(table.PrimaryKey.Name.ToCamel()).Untitle()),
"dataType": table.PrimaryKey.DataType,
"data": table,
})
if err != nil {
return "", "", err
}
return output.String(), findOneMethod.String(), nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/test/stmt.go | tools/goctl/model/sql/test/stmt.go | // copy from core/stores/sqlx/stmt.go
package mocksql
import (
"database/sql"
"fmt"
"time"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/timex"
)
const slowThreshold = time.Millisecond * 500
func exec(db *sql.DB, q string, args ...any) (sql.Result, error) {
tx, err := db.Begin()
if err != nil {
return nil, err
}
defer func() {
switch err {
case nil:
err = tx.Commit()
default:
tx.Rollback()
}
}()
stmt, err := format(q, args...)
if err != nil {
return nil, err
}
startTime := timex.Now()
result, err := tx.Exec(q, args...)
duration := timex.Since(startTime)
if duration > slowThreshold {
logx.WithDuration(duration).Slowf("[SQL] exec: slowcall - %s", stmt)
} else {
logx.WithDuration(duration).Infof("sql exec: %s", stmt)
}
if err != nil {
logSqlError(stmt, err)
}
return result, err
}
func execStmt(conn *sql.Stmt, args ...any) (sql.Result, error) {
stmt := fmt.Sprint(args...)
startTime := timex.Now()
result, err := conn.Exec(args...)
duration := timex.Since(startTime)
if duration > slowThreshold {
logx.WithDuration(duration).Slowf("[SQL] execStmt: slowcall - %s", stmt)
} else {
logx.WithDuration(duration).Infof("sql execStmt: %s", stmt)
}
if err != nil {
logSqlError(stmt, err)
}
return result, err
}
func query(db *sql.DB, scanner func(*sql.Rows) error, q string, args ...any) error {
tx, err := db.Begin()
if err != nil {
return err
}
defer func() {
switch err {
case nil:
err = tx.Commit()
default:
tx.Rollback()
}
}()
stmt, err := format(q, args...)
if err != nil {
return err
}
startTime := timex.Now()
rows, err := tx.Query(q, args...)
duration := timex.Since(startTime)
if duration > slowThreshold {
logx.WithDuration(duration).Slowf("[SQL] query: slowcall - %s", stmt)
} else {
logx.WithDuration(duration).Infof("sql query: %s", stmt)
}
if err != nil {
logSqlError(stmt, err)
return err
}
defer rows.Close()
return scanner(rows)
}
func queryStmt(conn *sql.Stmt, scanner func(*sql.Rows) error, args ...any) error {
stmt := fmt.Sprint(args...)
startTime := timex.Now()
rows, err := conn.Query(args...)
duration := timex.Since(startTime)
if duration > slowThreshold {
logx.WithDuration(duration).Slowf("[SQL] queryStmt: slowcall - %s", stmt)
} else {
logx.WithDuration(duration).Infof("sql queryStmt: %s", stmt)
}
if err != nil {
logSqlError(stmt, err)
return err
}
defer rows.Close()
return scanner(rows)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/test/utils.go | tools/goctl/model/sql/test/utils.go | // copy from core/stores/sqlx/utils.go
package mocksql
import (
"database/sql"
"fmt"
"strings"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/mapping"
)
// ErrNotFound is the alias of sql.ErrNoRows
var ErrNotFound = sql.ErrNoRows
func escape(input string) string {
var b strings.Builder
for _, ch := range input {
switch ch {
case '\x00':
b.WriteString(`\x00`)
case '\r':
b.WriteString(`\r`)
case '\n':
b.WriteString(`\n`)
case '\\':
b.WriteString(`\\`)
case '\'':
b.WriteString(`\'`)
case '"':
b.WriteString(`\"`)
case '\x1a':
b.WriteString(`\x1a`)
default:
b.WriteRune(ch)
}
}
return b.String()
}
func format(query string, args ...any) (string, error) {
numArgs := len(args)
if numArgs == 0 {
return query, nil
}
var b strings.Builder
argIndex := 0
for _, ch := range query {
if ch == '?' {
if argIndex >= numArgs {
return "", fmt.Errorf("%d ? in sql, but less arguments provided", argIndex)
}
arg := args[argIndex]
argIndex++
switch v := arg.(type) {
case bool:
if v {
b.WriteByte('1')
} else {
b.WriteByte('0')
}
case string:
b.WriteByte('\'')
b.WriteString(escape(v))
b.WriteByte('\'')
default:
b.WriteString(mapping.Repr(v))
}
} else {
b.WriteRune(ch)
}
}
if argIndex < numArgs {
return "", fmt.Errorf("%d ? in sql, but more arguments provided", argIndex)
}
return b.String(), nil
}
func logSqlError(stmt string, err error) {
if err != nil && err != ErrNotFound {
logx.Errorf("stmt: %s, error: %s", stmt, err.Error())
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/test/orm.go | tools/goctl/model/sql/test/orm.go | // copy from core/stores/sqlx/orm.go
package mocksql
import (
"errors"
"reflect"
"strings"
"github.com/zeromicro/go-zero/core/mapping"
)
const tagName = "db"
var (
// ErrNotMatchDestination defines an error for mismatching case
ErrNotMatchDestination = errors.New("not matching destination to scan")
// ErrNotReadableValue defines an error for the value is not addressable or interfaceable
ErrNotReadableValue = errors.New("value not addressable or interfaceable")
// ErrNotSettable defines an error for the variable is not settable
ErrNotSettable = errors.New("passed in variable is not settable")
// ErrUnsupportedValueType deinfes an error for unsupported unmarshal type
ErrUnsupportedValueType = errors.New("unsupported unmarshal type")
)
type rowsScanner interface {
Columns() ([]string, error)
Err() error
Next() bool
Scan(v ...any) error
}
func getTaggedFieldValueMap(v reflect.Value) (map[string]any, error) {
rt := mapping.Deref(v.Type())
size := rt.NumField()
result := make(map[string]any, size)
for i := 0; i < size; i++ {
key := parseTagName(rt.Field(i))
if len(key) == 0 {
return nil, nil
}
valueField := reflect.Indirect(v).Field(i)
switch valueField.Kind() {
case reflect.Ptr:
if !valueField.CanInterface() {
return nil, ErrNotReadableValue
}
if valueField.IsNil() {
baseValueType := mapping.Deref(valueField.Type())
valueField.Set(reflect.New(baseValueType))
}
result[key] = valueField.Interface()
default:
if !valueField.CanAddr() || !valueField.Addr().CanInterface() {
return nil, ErrNotReadableValue
}
result[key] = valueField.Addr().Interface()
}
}
return result, nil
}
func mapStructFieldsIntoSlice(v reflect.Value, columns []string, strict bool) ([]any, error) {
fields := unwrapFields(v)
if strict && len(columns) < len(fields) {
return nil, ErrNotMatchDestination
}
taggedMap, err := getTaggedFieldValueMap(v)
if err != nil {
return nil, err
}
values := make([]any, len(columns))
if len(taggedMap) == 0 {
for i := 0; i < len(values); i++ {
valueField := fields[i]
switch valueField.Kind() {
case reflect.Ptr:
if !valueField.CanInterface() {
return nil, ErrNotReadableValue
}
if valueField.IsNil() {
baseValueType := mapping.Deref(valueField.Type())
valueField.Set(reflect.New(baseValueType))
}
values[i] = valueField.Interface()
default:
if !valueField.CanAddr() || !valueField.Addr().CanInterface() {
return nil, ErrNotReadableValue
}
values[i] = valueField.Addr().Interface()
}
}
} else {
for i, column := range columns {
if tagged, ok := taggedMap[column]; ok {
values[i] = tagged
} else {
var anonymous any
values[i] = &anonymous
}
}
}
return values, nil
}
func parseTagName(field reflect.StructField) string {
key := field.Tag.Get(tagName)
if len(key) == 0 {
return ""
}
options := strings.Split(key, ",")
return options[0]
}
func unmarshalRow(v any, scanner rowsScanner, strict bool) error {
if !scanner.Next() {
if err := scanner.Err(); err != nil {
return err
}
return ErrNotFound
}
rv := reflect.ValueOf(v)
if err := mapping.ValidatePtr(rv); err != nil {
return err
}
rte := reflect.TypeOf(v).Elem()
rve := rv.Elem()
switch rte.Kind() {
case reflect.Bool,
reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64,
reflect.String:
if rve.CanSet() {
return scanner.Scan(v)
}
return ErrNotSettable
case reflect.Struct:
columns, err := scanner.Columns()
if err != nil {
return err
}
values, err := mapStructFieldsIntoSlice(rve, columns, strict)
if err != nil {
return err
}
return scanner.Scan(values...)
default:
return ErrUnsupportedValueType
}
}
func unmarshalRows(v any, scanner rowsScanner, strict bool) error {
rv := reflect.ValueOf(v)
if err := mapping.ValidatePtr(rv); err != nil {
return err
}
rt := reflect.TypeOf(v)
rte := rt.Elem()
rve := rv.Elem()
switch rte.Kind() {
case reflect.Slice:
if rve.CanSet() {
ptr := rte.Elem().Kind() == reflect.Ptr
appendFn := func(item reflect.Value) {
if ptr {
rve.Set(reflect.Append(rve, item))
} else {
rve.Set(reflect.Append(rve, reflect.Indirect(item)))
}
}
fillFn := func(value any) error {
if rve.CanSet() {
if err := scanner.Scan(value); err != nil {
return err
}
appendFn(reflect.ValueOf(value))
return nil
}
return ErrNotSettable
}
base := mapping.Deref(rte.Elem())
switch base.Kind() {
case reflect.Bool,
reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64,
reflect.String:
for scanner.Next() {
value := reflect.New(base)
if err := fillFn(value.Interface()); err != nil {
return err
}
}
case reflect.Struct:
columns, err := scanner.Columns()
if err != nil {
return err
}
for scanner.Next() {
value := reflect.New(base)
values, err := mapStructFieldsIntoSlice(value, columns, strict)
if err != nil {
return err
}
if err := scanner.Scan(values...); err != nil {
return err
}
appendFn(value)
}
default:
return ErrUnsupportedValueType
}
return nil
}
return ErrNotSettable
default:
return ErrUnsupportedValueType
}
}
func unwrapFields(v reflect.Value) []reflect.Value {
var fields []reflect.Value
indirect := reflect.Indirect(v)
for i := 0; i < indirect.NumField(); i++ {
child := indirect.Field(i)
if child.Kind() == reflect.Ptr && child.IsNil() {
baseValueType := mapping.Deref(child.Type())
child.Set(reflect.New(baseValueType))
}
child = reflect.Indirect(child)
childType := indirect.Type().Field(i)
if child.Kind() == reflect.Struct && childType.Anonymous {
fields = append(fields, unwrapFields(child)...)
} else {
fields = append(fields, child)
}
}
return fields
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/test/sqlconn.go | tools/goctl/model/sql/test/sqlconn.go | // copy from core/stores/sqlx/sqlconn.go
package mocksql
import (
"context"
"database/sql"
"github.com/zeromicro/go-zero/core/stores/sqlx"
)
type (
// MockConn defines a mock connection instance for mysql
MockConn struct {
db *sql.DB
}
statement struct {
stmt *sql.Stmt
}
)
// NewMockConn creates an instance for MockConn
func NewMockConn(db *sql.DB) *MockConn {
return &MockConn{db: db}
}
// Exec executes sql and returns the result
func (conn *MockConn) Exec(query string, args ...any) (sql.Result, error) {
return exec(conn.db, query, args...)
}
// ExecCtx executes sql and returns the result
func (conn *MockConn) ExecCtx(_ context.Context, query string, args ...any) (sql.Result, error) {
return exec(conn.db, query, args...)
}
// Prepare executes sql by sql.DB
func (conn *MockConn) Prepare(query string) (sqlx.StmtSession, error) {
st, err := conn.db.Prepare(query)
return statement{stmt: st}, err
}
// PrepareCtx executes sql by sql.DB
func (conn *MockConn) PrepareCtx(_ context.Context, query string) (sqlx.StmtSession, error) {
return conn.Prepare(query)
}
// QueryRow executes sql and returns a query row
func (conn *MockConn) QueryRow(v any, q string, args ...any) error {
return query(conn.db, func(rows *sql.Rows) error {
return unmarshalRow(v, rows, true)
}, q, args...)
}
// QueryRowCtx executes sql and returns a query row
func (conn *MockConn) QueryRowCtx(_ context.Context, v any, query string, args ...any) error {
return conn.QueryRow(v, query, args...)
}
// QueryRowPartial executes sql and returns a partial query row
func (conn *MockConn) QueryRowPartial(v any, q string, args ...any) error {
return query(conn.db, func(rows *sql.Rows) error {
return unmarshalRow(v, rows, false)
}, q, args...)
}
// QueryRowPartialCtx executes sql and returns a partial query row
func (conn *MockConn) QueryRowPartialCtx(_ context.Context, v any, query string, args ...any) error {
return conn.QueryRowPartial(v, query, args...)
}
// QueryRows executes sql and returns query rows
func (conn *MockConn) QueryRows(v any, q string, args ...any) error {
return query(conn.db, func(rows *sql.Rows) error {
return unmarshalRows(v, rows, true)
}, q, args...)
}
// QueryRowsCtx executes sql and returns query rows
func (conn *MockConn) QueryRowsCtx(_ context.Context, v any, query string, args ...any) error {
return conn.QueryRows(v, query, args...)
}
// QueryRowsPartial executes sql and returns partial query rows
func (conn *MockConn) QueryRowsPartial(v any, q string, args ...any) error {
return query(conn.db, func(rows *sql.Rows) error {
return unmarshalRows(v, rows, false)
}, q, args...)
}
// QueryRowsPartialCtx executes sql and returns partial query rows
func (conn *MockConn) QueryRowsPartialCtx(_ context.Context, v any, query string, args ...any) error {
return conn.QueryRowsPartial(v, query, args...)
}
// RawDB returns the underlying sql.DB.
func (conn *MockConn) RawDB() (*sql.DB, error) {
return conn.db, nil
}
// Transact is the implementation of sqlx.SqlConn, nothing to do
func (conn *MockConn) Transact(func(session sqlx.Session) error) error {
return nil
}
// TransactCtx is the implementation of sqlx.SqlConn, nothing to do
func (conn *MockConn) TransactCtx(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
return nil
}
func (s statement) Close() error {
return s.stmt.Close()
}
func (s statement) Exec(args ...any) (sql.Result, error) {
return execStmt(s.stmt, args...)
}
func (s statement) ExecCtx(_ context.Context, args ...any) (sql.Result, error) {
return s.Exec(args...)
}
func (s statement) QueryRow(v any, args ...any) error {
return queryStmt(s.stmt, func(rows *sql.Rows) error {
return unmarshalRow(v, rows, true)
}, args...)
}
func (s statement) QueryRowCtx(_ context.Context, v any, args ...any) error {
return s.QueryRow(v, args...)
}
func (s statement) QueryRowPartial(v any, args ...any) error {
return queryStmt(s.stmt, func(rows *sql.Rows) error {
return unmarshalRow(v, rows, false)
}, args...)
}
func (s statement) QueryRowPartialCtx(_ context.Context, v any, args ...any) error {
return s.QueryRowPartial(v, args...)
}
func (s statement) QueryRows(v any, args ...any) error {
return queryStmt(s.stmt, func(rows *sql.Rows) error {
return unmarshalRows(v, rows, true)
}, args...)
}
func (s statement) QueryRowsCtx(_ context.Context, v any, args ...any) error {
return s.QueryRows(v, args...)
}
func (s statement) QueryRowsPartial(v any, args ...any) error {
return queryStmt(s.stmt, func(rows *sql.Rows) error {
return unmarshalRows(v, rows, false)
}, args...)
}
func (s statement) QueryRowsPartialCtx(_ context.Context, v any, args ...any) error {
return s.QueryRowsPartial(v, args...)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/test/model/usermodel.go | tools/goctl/model/sql/test/model/usermodel.go | package model
import (
"database/sql"
"fmt"
"strings"
"time"
"github.com/zeromicro/go-zero/core/stores/builder"
"github.com/zeromicro/go-zero/core/stores/sqlc"
"github.com/zeromicro/go-zero/core/stores/sqlx"
"github.com/zeromicro/go-zero/core/stringx"
)
var (
userFieldNames = builder.RawFieldNames(&User{})
userRows = strings.Join(userFieldNames, ",")
userRowsExpectAutoSet = strings.Join(stringx.Remove(userFieldNames,
"`id`", "`create_time`", "`update_time`"), ",")
userRowsWithPlaceHolder = strings.Join(stringx.Remove(userFieldNames,
"`id`", "`create_time`", "`update_time`"), "=?,") + "=?"
)
type (
// UserModel defines a model for user
UserModel interface {
Insert(data User) (sql.Result, error)
FindOne(id int64) (*User, error)
FindOneByUser(user string) (*User, error)
FindOneByMobile(mobile string) (*User, error)
FindOneByName(name string) (*User, error)
Update(data User) error
Delete(id int64) error
}
defaultUserModel struct {
conn sqlx.SqlConn
table string
}
// User defines an data structure for mysql
User struct {
ID int64 `db:"id"`
User string `db:"user"` // user
Name string `db:"name"` // user name
Password string `db:"password"` // user password
Mobile string `db:"mobile"` // user mobile
Gender string `db:"gender"` // male | female | unknown
Nickname string `db:"nickname"` // user nickname
CreateTime time.Time `db:"create_time"`
UpdateTime time.Time `db:"update_time"`
}
)
// NewUserModel creates an instance for UserModel
func NewUserModel(conn sqlx.SqlConn) UserModel {
return &defaultUserModel{
conn: conn,
table: "`user`",
}
}
func (m *defaultUserModel) Insert(data User) (sql.Result, error) {
query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?)", m.table, userRowsExpectAutoSet)
ret, err := m.conn.Exec(query, data.User, data.Name, data.Password, data.Mobile, data.Gender, data.Nickname)
return ret, err
}
func (m *defaultUserModel) FindOne(id int64) (*User, error) {
query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", userRows, m.table)
var resp User
err := m.conn.QueryRow(&resp, query, id)
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultUserModel) FindOneByUser(user string) (*User, error) {
var resp User
query := fmt.Sprintf("select %s from %s where `user` = ? limit 1", userRows, m.table)
err := m.conn.QueryRow(&resp, query, user)
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultUserModel) FindOneByMobile(mobile string) (*User, error) {
var resp User
query := fmt.Sprintf("select %s from %s where `mobile` = ? limit 1", userRows, m.table)
err := m.conn.QueryRow(&resp, query, mobile)
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultUserModel) FindOneByName(name string) (*User, error) {
var resp User
query := fmt.Sprintf("select %s from %s where `name` = ? limit 1", userRows, m.table)
err := m.conn.QueryRow(&resp, query, name)
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultUserModel) Update(data User) error {
query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, userRowsWithPlaceHolder)
_, err := m.conn.Exec(query, data.User, data.Name, data.Password, data.Mobile, data.Gender, data.Nickname, data.ID)
return err
}
func (m *defaultUserModel) Delete(id int64) error {
query := fmt.Sprintf("delete from %s where `id` = ?", m.table)
_, err := m.conn.Exec(query, id)
return err
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/test/model/model_test.go | tools/goctl/model/sql/test/model/model_test.go | package model
import (
"database/sql"
"encoding/json"
"fmt"
"testing"
"time"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/core/stores/redis"
"github.com/zeromicro/go-zero/core/stores/redis/redistest"
mocksql "github.com/zeromicro/go-zero/tools/goctl/model/sql/test"
)
func TestStudentModel(t *testing.T) {
var (
testTimeValue = time.Now()
testTable = "`student`"
testUpdateName = "gozero1"
testRowsAffected int64 = 1
testInsertId int64 = 1
class = "一年级1班"
)
var data Student
data.Id = testInsertId
data.Class = class
data.Name = "gozero"
data.Age = sql.NullInt64{
Int64: 1,
Valid: true,
}
data.Score = sql.NullFloat64{
Float64: 100,
Valid: true,
}
data.CreateTime = testTimeValue
data.UpdateTime = sql.NullTime{
Time: testTimeValue,
Valid: true,
}
err := mockStudent(t, func(mock sqlmock.Sqlmock) {
mock.ExpectExec(fmt.Sprintf("insert into %s", testTable)).
WithArgs(data.Class, data.Name, data.Age, data.Score).
WillReturnResult(sqlmock.NewResult(testInsertId, testRowsAffected))
}, func(m StudentModel, redis *redis.Redis) {
r, err := m.Insert(data)
assert.Nil(t, err)
lastInsertId, err := r.LastInsertId()
assert.Nil(t, err)
assert.Equal(t, testInsertId, lastInsertId)
rowsAffected, err := r.RowsAffected()
assert.Nil(t, err)
assert.Equal(t, testRowsAffected, rowsAffected)
})
assert.Nil(t, err)
err = mockStudent(t, func(mock sqlmock.Sqlmock) {
mock.ExpectQuery(fmt.Sprintf("select (.+) from %s", testTable)).
WithArgs(testInsertId).
WillReturnRows(sqlmock.NewRows([]string{"id", "class", "name", "age", "score", "create_time", "update_time"}).AddRow(testInsertId, data.Class, data.Name, data.Age, data.Score, testTimeValue, testTimeValue))
}, func(m StudentModel, redis *redis.Redis) {
result, err := m.FindOne(testInsertId)
assert.Nil(t, err)
assert.Equal(t, *result, data)
var resp Student
val, err := redis.Get(fmt.Sprintf("%s%v", cacheStudentIdPrefix, testInsertId))
assert.Nil(t, err)
err = json.Unmarshal([]byte(val), &resp)
assert.Nil(t, err)
assert.Equal(t, resp.Name, data.Name)
})
assert.Nil(t, err)
err = mockStudent(t, func(mock sqlmock.Sqlmock) {
mock.ExpectExec(fmt.Sprintf("update %s", testTable)).WithArgs(data.Class, testUpdateName, data.Age, data.Score, testInsertId).WillReturnResult(sqlmock.NewResult(testInsertId, testRowsAffected))
}, func(m StudentModel, redis *redis.Redis) {
data.Name = testUpdateName
err := m.Update(data)
assert.Nil(t, err)
val, err := redis.Get(fmt.Sprintf("%s%v", cacheStudentIdPrefix, testInsertId))
assert.Nil(t, err)
assert.Equal(t, "", val)
})
assert.Nil(t, err)
data.Name = testUpdateName
err = mockStudent(t, func(mock sqlmock.Sqlmock) {
mock.ExpectQuery(fmt.Sprintf("select (.+) from %s ", testTable)).
WithArgs(testInsertId).
WillReturnRows(sqlmock.NewRows([]string{"id", "class", "name", "age", "score", "create_time", "update_time"}).AddRow(testInsertId, data.Class, data.Name, data.Age, data.Score, testTimeValue, testTimeValue))
}, func(m StudentModel, redis *redis.Redis) {
result, err := m.FindOne(testInsertId)
assert.Nil(t, err)
assert.Equal(t, *result, data)
var resp Student
val, err := redis.Get(fmt.Sprintf("%s%v", cacheStudentIdPrefix, testInsertId))
assert.Nil(t, err)
err = json.Unmarshal([]byte(val), &resp)
assert.Nil(t, err)
assert.Equal(t, testUpdateName, data.Name)
})
assert.Nil(t, err)
err = mockStudent(t, func(mock sqlmock.Sqlmock) {
mock.ExpectQuery(fmt.Sprintf("select (.+) from %s ", testTable)).
WithArgs(class, testUpdateName).
WillReturnRows(sqlmock.NewRows([]string{"id", "class", "name", "age", "score", "create_time", "update_time"}).AddRow(testInsertId, data.Class, data.Name, data.Age, data.Score, testTimeValue, testTimeValue))
}, func(m StudentModel, redis *redis.Redis) {
result, err := m.FindOneByClassName(class, testUpdateName)
assert.Nil(t, err)
assert.Equal(t, *result, data)
val, err := redis.Get(fmt.Sprintf("%s%v%v", cacheStudentClassNamePrefix, class, testUpdateName))
assert.Nil(t, err)
assert.Equal(t, "1", val)
})
assert.Nil(t, err)
err = mockStudent(t, func(mock sqlmock.Sqlmock) {
mock.ExpectExec(fmt.Sprintf("delete from %s where `id` = ?", testTable)).WithArgs(testInsertId).WillReturnResult(sqlmock.NewResult(testInsertId, testRowsAffected))
}, func(m StudentModel, redis *redis.Redis) {
err = m.Delete(testInsertId, class, testUpdateName)
assert.Nil(t, err)
val, err := redis.Get(fmt.Sprintf("%s%v", cacheStudentIdPrefix, testInsertId))
assert.Nil(t, err)
assert.Equal(t, "", val)
val, err = redis.Get(fmt.Sprintf("%s%v%v", cacheStudentClassNamePrefix, class, testUpdateName))
assert.Nil(t, err)
assert.Equal(t, "", val)
})
assert.Nil(t, err)
}
func TestUserModel(t *testing.T) {
var (
testTimeValue = time.Now()
testTable = "`user`"
testUpdateName = "gozero1"
testUser = "gozero"
testPassword = "test"
testMobile = "test_mobile"
testGender = "男"
testNickname = "test_nickname"
testRowsAffected int64 = 1
testInsertId int64 = 1
)
var data User
data.ID = testInsertId
data.User = testUser
data.Name = "gozero"
data.Password = testPassword
data.Mobile = testMobile
data.Gender = testGender
data.Nickname = testNickname
data.CreateTime = testTimeValue
data.UpdateTime = testTimeValue
err := mockUser(func(mock sqlmock.Sqlmock) {
mock.ExpectExec(fmt.Sprintf("insert into %s", testTable)).
WithArgs(data.User, data.Name, data.Password, data.Mobile, data.Gender, data.Nickname).
WillReturnResult(sqlmock.NewResult(testInsertId, testRowsAffected))
}, func(m UserModel) {
r, err := m.Insert(data)
assert.Nil(t, err)
lastInsertId, err := r.LastInsertId()
assert.Nil(t, err)
assert.Equal(t, testInsertId, lastInsertId)
rowsAffected, err := r.RowsAffected()
assert.Nil(t, err)
assert.Equal(t, testRowsAffected, rowsAffected)
})
assert.Nil(t, err)
err = mockUser(func(mock sqlmock.Sqlmock) {
mock.ExpectQuery(fmt.Sprintf("select (.+) from %s", testTable)).
WithArgs(testInsertId).
WillReturnRows(sqlmock.NewRows([]string{"id", "user", "name", "password", "mobile", "gender", "nickname", "create_time", "update_time"}).AddRow(testInsertId, data.User, data.Name, data.Password, data.Mobile, data.Gender, data.Nickname, testTimeValue, testTimeValue))
}, func(m UserModel) {
result, err := m.FindOne(testInsertId)
assert.Nil(t, err)
assert.Equal(t, *result, data)
})
assert.Nil(t, err)
err = mockUser(func(mock sqlmock.Sqlmock) {
mock.ExpectExec(fmt.Sprintf("update %s", testTable)).WithArgs(data.User, testUpdateName, data.Password, data.Mobile, data.Gender, data.Nickname, testInsertId).WillReturnResult(sqlmock.NewResult(testInsertId, testRowsAffected))
}, func(m UserModel) {
data.Name = testUpdateName
err := m.Update(data)
assert.Nil(t, err)
})
assert.Nil(t, err)
err = mockUser(func(mock sqlmock.Sqlmock) {
mock.ExpectQuery(fmt.Sprintf("select (.+) from %s ", testTable)).
WithArgs(testInsertId).
WillReturnRows(sqlmock.NewRows([]string{"id", "user", "name", "password", "mobile", "gender", "nickname", "create_time", "update_time"}).AddRow(testInsertId, data.User, data.Name, data.Password, data.Mobile, data.Gender, data.Nickname, testTimeValue, testTimeValue))
}, func(m UserModel) {
result, err := m.FindOne(testInsertId)
assert.Nil(t, err)
assert.Equal(t, *result, data)
})
assert.Nil(t, err)
err = mockUser(func(mock sqlmock.Sqlmock) {
mock.ExpectExec(fmt.Sprintf("delete from %s where `id` = ?", testTable)).WithArgs(testInsertId).WillReturnResult(sqlmock.NewResult(testInsertId, testRowsAffected))
}, func(m UserModel) {
err := m.Delete(testInsertId)
assert.Nil(t, err)
})
assert.Nil(t, err)
}
// with cache
func mockStudent(t *testing.T, mockFn func(mock sqlmock.Sqlmock), fn func(m StudentModel, r *redis.Redis)) error {
db, mock, err := sqlmock.New()
if err != nil {
return err
}
defer db.Close()
mock.ExpectBegin()
mockFn(mock)
mock.ExpectCommit()
conn := mocksql.NewMockConn(db)
r := redistest.CreateRedis(t)
m := NewStudentModel(conn, cache.CacheConf{
{
RedisConf: redis.RedisConf{
Host: r.Addr,
Type: "node",
},
Weight: 100,
},
})
mock.ExpectBegin()
fn(m, r)
mock.ExpectCommit()
return nil
}
// without cache
func mockUser(mockFn func(mock sqlmock.Sqlmock), fn func(m UserModel)) error {
db, mock, err := sqlmock.New()
if err != nil {
return err
}
defer db.Close()
mock.ExpectBegin()
mockFn(mock)
mock.ExpectCommit()
conn := mocksql.NewMockConn(db)
m := NewUserModel(conn)
fn(m)
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/test/model/vars.go | tools/goctl/model/sql/test/model/vars.go | package model
import "github.com/zeromicro/go-zero/core/stores/sqlx"
// ErrNotFound types an alias for sqlx.ErrNotFound
var ErrNotFound = sqlx.ErrNotFound
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/model/sql/test/model/studentmodel.go | tools/goctl/model/sql/test/model/studentmodel.go | package model
import (
"database/sql"
"fmt"
"strings"
"time"
"github.com/zeromicro/go-zero/core/stores/builder"
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/core/stores/sqlc"
"github.com/zeromicro/go-zero/core/stores/sqlx"
"github.com/zeromicro/go-zero/core/stringx"
)
var (
studentFieldNames = builder.RawFieldNames(&Student{})
studentRows = strings.Join(studentFieldNames, ",")
studentRowsExpectAutoSet = strings.Join(stringx.Remove(studentFieldNames, "`id`", "`create_time`", "`update_time`"), ",")
studentRowsWithPlaceHolder = strings.Join(stringx.Remove(studentFieldNames, "`id`", "`create_time`", "`update_time`"), "=?,") + "=?"
cacheStudentIdPrefix = "cache#student#id#"
cacheStudentClassNamePrefix = "cache#student#class#name#"
)
type (
// StudentModel only for test
StudentModel interface {
Insert(data Student) (sql.Result, error)
FindOne(id int64) (*Student, error)
FindOneByClassName(class, name string) (*Student, error)
Update(data Student) error
// only for test
Delete(id int64, className, studentName string) error
}
defaultStudentModel struct {
sqlc.CachedConn
table string
}
// Student only for test
Student struct {
Id int64 `db:"id"`
Class string `db:"class"`
Name string `db:"name"`
Age sql.NullInt64 `db:"age"`
Score sql.NullFloat64 `db:"score"`
CreateTime time.Time `db:"create_time"`
UpdateTime sql.NullTime `db:"update_time"`
}
)
// NewStudentModel only for test
func NewStudentModel(conn sqlx.SqlConn, c cache.CacheConf) StudentModel {
return &defaultStudentModel{
CachedConn: sqlc.NewConn(conn, c),
table: "`student`",
}
}
func (m *defaultStudentModel) Insert(data Student) (sql.Result, error) {
studentClassNameKey := fmt.Sprintf("%s%v%v", cacheStudentClassNamePrefix, data.Class, data.Name)
ret, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?)", m.table, studentRowsExpectAutoSet)
return conn.Exec(query, data.Class, data.Name, data.Age, data.Score)
}, studentClassNameKey)
return ret, err
}
func (m *defaultStudentModel) FindOne(id int64) (*Student, error) {
studentIdKey := fmt.Sprintf("%s%v", cacheStudentIdPrefix, id)
var resp Student
err := m.QueryRow(&resp, studentIdKey, func(conn sqlx.SqlConn, v any) error {
query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", studentRows, m.table)
return conn.QueryRow(v, query, id)
})
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultStudentModel) FindOneByClassName(class, name string) (*Student, error) {
studentClassNameKey := fmt.Sprintf("%s%v%v", cacheStudentClassNamePrefix, class, name)
var resp Student
err := m.QueryRowIndex(&resp, studentClassNameKey, m.formatPrimary, func(conn sqlx.SqlConn, v any) (i any, e error) {
query := fmt.Sprintf("select %s from %s where `class` = ? and `name` = ? limit 1", studentRows, m.table)
if err := conn.QueryRow(&resp, query, class, name); err != nil {
return nil, err
}
return resp.Id, nil
}, m.queryPrimary)
switch err {
case nil:
return &resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}
func (m *defaultStudentModel) Update(data Student) error {
studentIdKey := fmt.Sprintf("%s%v", cacheStudentIdPrefix, data.Id)
_, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, studentRowsWithPlaceHolder)
return conn.Exec(query, data.Class, data.Name, data.Age, data.Score, data.Id)
}, studentIdKey)
return err
}
func (m *defaultStudentModel) Delete(id int64, className, studentName string) error {
studentIdKey := fmt.Sprintf("%s%v", cacheStudentIdPrefix, id)
studentClassNameKey := fmt.Sprintf("%s%v%v", cacheStudentClassNamePrefix, className, studentName)
_, err := m.Exec(func(conn sqlx.SqlConn) (result sql.Result, err error) {
query := fmt.Sprintf("delete from %s where `id` = ?", m.table)
return conn.Exec(query, id)
}, studentIdKey, studentClassNameKey)
return err
}
func (m *defaultStudentModel) formatPrimary(primary any) string {
return fmt.Sprintf("%s%v", cacheStudentIdPrefix, primary)
}
func (m *defaultStudentModel) queryPrimary(conn sqlx.SqlConn, v, primary any) error {
query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", studentRows, m.table)
return conn.QueryRow(v, query, primary)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.