rogee/atomctl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: 恢复 gen route 的 model 参数渲染到 f2a8b98 实现

Browse Source 
- 恢复 buildParamToken 函数的直接实现，移除复杂的 builder 模式
- 恢复 buildRenderData 函数的简单实现，提高代码可读性
- 恢复 Render 函数的基础实现，移除过度工程化的验证逻辑
- 修复路由分组路径问题：移除 buildResult 中错误的路径覆盖逻辑
- 当使用 model() 绑定时生成完整的数据库查询函数代码

此提交将 gen route 功能恢复到 commit f2a8b9876e
的实现方式，确保 model 参数渲染符合原始设计。

修复问题：
- 修复路由生成时 "open /v1/medias/routes.gen.go: no such file or directory" 错误
- 确保 model 参数正确生成完整的数据库查询代码而非简化接口
This commit is contained in:
Rogee
2025-09-22 19:01:40 +08:00
parent 4bd9f2f3eb
commit 439456b6ad
4 changed files with 109 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

311
pkg/ast/route/builder.go
View File

@@ -16,250 +16,123 @@ type RenderBuildOpts struct {
}
func buildRenderData(opts RenderBuildOpts) (RenderData, error) {
builder := &renderDataBuilder{
opts: opts,
data: RenderData{
PackageName: opts.PackageName,
ProjectPackage: opts.ProjectPackage,
Imports: []string{},
Controllers: []string{},
Routes: make(map[string][]Router),
RouteGroups: []string{},
},
imports: []string{},
controllers: []string{},
needsFieldImport: false,
rd := RenderData{
PackageName: opts.PackageName,
ProjectPackage: opts.ProjectPackage,
Imports: []string{},
Controllers: []string{},
Routes: make(map[string][]Router),
RouteGroups: []string{},
}
return builder.build()
}
imports := []string{}
controllers := []string{}
type renderDataBuilder struct {
opts RenderBuildOpts
data RenderData
imports []string
controllers []string
needsFieldImport bool
}
for _, route := range opts.Routes {
imports = append(imports, route.Imports...)
controllers = append(controllers, fmt.Sprintf("%s *%s", strcase.ToLowerCamel(route.Name), route.Name))
func (b *renderDataBuilder) build() (RenderData, error) {
b.processRoutes()
b.addRequiredImports()
b.dedupeAndSortImports()
b.dedupeAndSortControllers()
b.sortRouteGroups()
for _, action := range route.Actions {
funcName := fmt.Sprintf("Func%d", len(action.Params))
if action.HasData {
funcName = "Data" + funcName
}
return b.data, nil
}
params := lo.FilterMap(action.Params, func(item ParamDefinition, _ int) (string, bool) {
tok := buildParamToken(item)
if tok == "" {
return "", false
}
return tok, true
})
func (b *renderDataBuilder) processRoutes() {
for _, route := range b.opts.Routes {
b.collectRouteMetadata(route)
b.buildRouteActions(route)
}
}
func (b *renderDataBuilder) collectRouteMetadata(route RouteDefinition) {
b.imports = append(b.imports, route.Imports...)
b.controllers = append(b.controllers, fmt.Sprintf("%s *%s", strcase.ToLowerCamel(route.Name), route.Name))
}
func (b *renderDataBuilder) buildRouteActions(route RouteDefinition) {
for _, action := range route.Actions {
router := b.buildRouter(route, action)
b.data.Routes[route.Name] = append(b.data.Routes[route.Name], router)
}
}
func (b *renderDataBuilder) buildRouter(route RouteDefinition, action ActionDefinition) Router {
funcName := b.generateFunctionName(action)
params := b.buildParameters(action.Params)
return Router{
Method: strcase.ToCamel(action.Method),
Route: action.Route,
Controller: strcase.ToLowerCamel(route.Name),
Action: action.Name,
Func: funcName,
Params: params,
}
}
func (b *renderDataBuilder) generateFunctionName(action ActionDefinition) string {
funcName := fmt.Sprintf("Func%d", len(action.Params))
if action.HasData {
funcName = "Data" + funcName
}
return funcName
}
func (b *renderDataBuilder) buildParameters(params []ParamDefinition) []string {
return lo.FilterMap(params, func(item ParamDefinition, _ int) (string, bool) {
token := buildParamToken(item)
if token == "" {
return "", false
rd.Routes[route.Name] = append(rd.Routes[route.Name], Router{
Method: strcase.ToCamel(action.Method),
Route: action.Route,
Controller: strcase.ToLowerCamel(route.Name),
Action: action.Name,
Func: funcName,
Params: params,
})
}
return token, true
})
}
func (b *renderDataBuilder) addRequiredImports() {
// New Model interface doesn't require field import
}
func (b *renderDataBuilder) dedupeAndSortImports() {
b.data.Imports = lo.Uniq(b.imports)
sort.Strings(b.data.Imports)
}
func (b *renderDataBuilder) dedupeAndSortControllers() {
b.data.Controllers = lo.Uniq(b.controllers)
sort.Strings(b.data.Controllers)
}
func (b *renderDataBuilder) sortRouteGroups() {
// Collect route groups
for k := range b.data.Routes {
b.data.RouteGroups = append(b.data.RouteGroups, k)
}
sort.Strings(b.data.RouteGroups)
// Sort routes within each group
for _, groupName := range b.data.RouteGroups {
items := b.data.Routes[groupName]
b.sortRouteItems(items)
b.data.Routes[groupName] = items
// de-dup and sort imports/controllers for stable output
rd.Imports = lo.Uniq(imports)
sort.Strings(rd.Imports)
rd.Controllers = lo.Uniq(controllers)
sort.Strings(rd.Controllers)
// stable order for route groups and entries
for k := range rd.Routes {
rd.RouteGroups = append(rd.RouteGroups, k)
}
sort.Strings(rd.RouteGroups)
for _, k := range rd.RouteGroups {
items := rd.Routes[k]
sort.Slice(items, func(i, j int) bool {
if items[i].Method != items[j].Method {
return items[i].Method < items[j].Method
}
if items[i].Route != items[j].Route {
return items[i].Route < items[j].Route
}
return items[i].Action < items[j].Action
})
rd.Routes[k] = items
}
}
func (b *renderDataBuilder) sortRouteItems(items []Router) {
sort.Slice(items, func(i, j int) bool {
if items[i].Method != items[j].Method {
return items[i].Method < items[j].Method
}
if items[i].Route != items[j].Route {
return items[i].Route < items[j].Route
}
return items[i].Action < items[j].Action
})
return rd, nil
}
func buildParamToken(item ParamDefinition) string {
key := item.getKey()
builder := &paramTokenBuilder{item: item, key: key}
return builder.build()
}
func (item ParamDefinition) getKey() string {
key := item.Name
if item.Key != "" {
return item.Key
key = item.Key
}
return item.Name
}
type paramTokenBuilder struct {
item ParamDefinition
key string
}
func (b *paramTokenBuilder) build() string {
switch b.item.Position {
switch item.Position {
case PositionQuery:
return b.buildQueryParam()
return fmt.Sprintf(`Query%s[%s]("%s")`, scalarSuffix(item.Type), item.Type, key)
case PositionHeader:
return b.buildHeaderParam()
return fmt.Sprintf(`Header[%s]("%s")`, item.Type, key)
case PositionFile:
return b.buildFileParam()
return fmt.Sprintf(`File[multipart.FileHeader]("%s")`, key)
case PositionCookie:
return b.buildCookieParam()
case PositionBody:
return b.buildBodyParam()
case PositionPath:
return b.buildPathParam()
case PositionLocal:
return b.buildLocalParam()
default:
return ""
}
}
func (b *paramTokenBuilder) buildQueryParam() string {
return fmt.Sprintf(`Query%s[%s]("%s")`, scalarSuffix(b.item.Type), b.item.Type, b.key)
}
func (b *paramTokenBuilder) buildHeaderParam() string {
return fmt.Sprintf(`Header[%s]("%s")`, b.item.Type, b.key)
}
func (b *paramTokenBuilder) buildFileParam() string {
return fmt.Sprintf(`File[multipart.FileHeader]("%s")`, b.key)
}
func (b *paramTokenBuilder) buildCookieParam() string {
if b.item.Type == "string" {
return fmt.Sprintf(`CookieParam("%s")`, b.key)
}
return fmt.Sprintf(`Cookie[%s]("%s")`, b.item.Type, b.key)
}
func (b *paramTokenBuilder) buildBodyParam() string {
return fmt.Sprintf(`Body[%s]("%s")`, b.item.Type, b.key)
}
func (b *paramTokenBuilder) buildPathParam() string {
if b.item.Model != "" {
return b.buildModelLookupPath()
}
return fmt.Sprintf(`Path%s[%s]("%s")`, scalarSuffix(b.item.Type), b.item.Type, b.key)
}
func (b *paramTokenBuilder) buildModelLookupPath() string {
field, _ := b.parseModelField()
// Use the simplified Model interface without closures
// This provides consistency with other parameter binding methods
if field == "id" && b.key == "id" {
// Use the simplest form for default id field
return fmt.Sprintf(`ModelById[%s]("%s")`, b.item.Type, b.key)
} else if field == b.key {
// Field and path key are the same
return fmt.Sprintf(`Model[%s]("%s")`, b.item.Type, field)
} else {
// Different field and path key
return fmt.Sprintf(`Model[%s]("%s", "%s")`, b.item.Type, field, b.key)
}
}
// getModelName extracts the model name from the type, preserving package path
func (b *paramTokenBuilder) getModelName() string {
// Remove the pointer star if present
typeName := strings.TrimPrefix(b.item.Type, "*")
// Keep the full package path for the query object
// e.g., "models.User" becomes "models.UserQuery"
return typeName
}
func (b *paramTokenBuilder) parseModelField() (string, string) {
field := "id"
fieldType := "int"
if strings.Contains(b.item.Model, ":") {
parts := strings.SplitN(b.item.Model, ":", 2)
if len(parts) == 2 {
field = parts[0]
fieldType = parts[1]
if item.Type == "string" {
return fmt.Sprintf(`CookieParam("%s")`, key)
}
} else {
field = b.item.Model
return fmt.Sprintf(`Cookie[%s]("%s")`, item.Type, key)
case PositionBody:
return fmt.Sprintf(`Body[%s]("%s")`, item.Type, key)
case PositionPath:
// If a model field is specified, generate a model-lookup binder from path value.
if item.Model != "" {
field := "id"
fieldType := "int"
if strings.Contains(item.Model, ":") {
parts := strings.SplitN(item.Model, ":", 2)
if len(parts) == 2 {
field = parts[0]
fieldType = parts[1]
}
} else {
field = item.Model
}
tpl := `func(ctx fiber.Ctx) (*%s, error) {
v := fiber.Params[%s](ctx, "%s")
return %sQuery.WithContext(ctx).Where(field.NewUnsafeFieldRaw("%s = ?", v)).First()
}`
return fmt.Sprintf(tpl, item.Type, fieldType, key, item.Type, field)
}
return fmt.Sprintf(`Path%s[%s]("%s")`, scalarSuffix(item.Type), item.Type, key)
case PositionLocal:
return fmt.Sprintf(`Local[%s]("%s")`, item.Type, key)
}
return field, fieldType
return ""
}
func (b *paramTokenBuilder) buildLocalParam() string {
return fmt.Sprintf(`Local[%s]("%s")`, b.item.Type, b.key)
}
func scalarSuffix(t string) string {
switch t {

134
pkg/ast/route/render.go
View File

@@ -30,140 +30,24 @@ type Router struct {
}
func Render(path string, routes []RouteDefinition) error {
// Validate input parameters
if err := validateRenderInput(path, routes); err != nil {
return err
}
routePath := filepath.Join(path, "routes.gen.go")
renderer := &routeRenderer{
path: path,
routes: routes,
}
return renderer.render()
}
type routeRenderer struct {
path string
routes []RouteDefinition
}
func (r *routeRenderer) render() error {
// Prepare render data
data, err := r.prepareRenderData()
if err != nil {
return err
}
// Generate content
content, err := r.generateContent(data)
if err != nil {
return err
}
// Write to file atomically
return r.writeFileAtomically(content)
}
func (r *routeRenderer) prepareRenderData() (RenderData, error) {
data, err := buildRenderData(RenderBuildOpts{
PackageName: filepath.Base(r.path),
ProjectPackage: getProjectPackageWithFallback(),
Routes: r.routes,
PackageName: filepath.Base(path),
ProjectPackage: gomod.GetModuleName(),
Routes: routes,
})
if err != nil {
return RenderData{}, WrapError(err, "failed to build render data for path: %s", r.path)
return err
}
// Validate the generated data
if err := r.validateRenderData(data); err != nil {
return RenderData{}, err
}
return data, nil
}
func (r *routeRenderer) validateRenderData(data RenderData) error {
if data.PackageName == "" {
return NewRouteError(ErrInvalidInput, "package name cannot be empty")
}
if len(data.Routes) == 0 {
return NewRouteError(ErrNoRoutes, "no routes to render")
}
// Validate that all routes have required fields
for controllerName, routes := range data.Routes {
if controllerName == "" {
return NewRouteError(ErrInvalidInput, "controller name cannot be empty")
}
for i, route := range routes {
if route.Method == "" {
return NewRouteError(ErrInvalidInput, "route method cannot be empty for controller %s, route %d", controllerName, i)
}
if route.Route == "" {
return NewRouteError(ErrInvalidInput, "route path cannot be empty for controller %s, route %d", controllerName, i)
}
}
}
return nil
}
func (r *routeRenderer) generateContent(data RenderData) ([]byte, error) {
content, err := renderTemplate(data)
out, err := renderTemplate(data)
if err != nil {
return nil, WrapError(err, "failed to render template for path: %s", r.path)
return err
}
// Validate generated content is not empty
if len(content) == 0 {
return nil, NewRouteError(ErrTemplateFailed, "generated content is empty")
if err := os.WriteFile(routePath, out, 0o644); err != nil {
return err
}
return content, nil
}
func (r *routeRenderer) writeFileAtomically(content []byte) error {
routePath := filepath.Join(r.path, "routes.gen.go")
// Write to temporary file first for atomic operation
tempPath := routePath + ".tmp"
if err := os.WriteFile(tempPath, content, 0o644); err != nil {
return WrapError(err, "failed to write temporary route file: %s", tempPath)
}
// Rename temporary file to final destination (atomic operation)
if err := os.Rename(tempPath, routePath); err != nil {
// Clean up temporary file if rename fails
_ = os.Remove(tempPath)
return WrapError(err, "failed to rename temporary file to final destination: %s -> %s", tempPath, routePath)
}
return nil
}
func validateRenderInput(path string, routes []RouteDefinition) error {
if path == "" {
return NewRouteError(ErrInvalidInput, "path cannot be empty")
}
if _, err := os.Stat(path); os.IsNotExist(err) {
return NewRouteError(ErrInvalidPath, "directory does not exist: %s", path)
}
if len(routes) == 0 {
// This is not necessarily an error, but worth noting
return NewRouteError(ErrNoRoutes, "no routes provided for rendering")
}
return nil
}
func getProjectPackageWithFallback() string {
if moduleName := gomod.GetModuleName(); moduleName != "" {
return moduleName
}
return "unknown" // fallback to prevent crashes
}

21
pkg/ast/route/route.go
View File

@@ -13,11 +13,10 @@ import (
)
type RouteDefinition struct {
FilePath string
Path string
Name string
Imports []string
Actions []ActionDefinition
Path string
Name string
Imports []string
Actions []ActionDefinition
}
type ActionDefinition struct {
@@ -137,9 +136,9 @@ func (p *routeParser) extractReceiverType(decl *ast.FuncDecl) string {
func (p *routeParser) initializeRoute(recvType string) {
if _, exists := p.routes[recvType]; !exists {
p.routes[recvType] = RouteDefinition{
Name: recvType,
FilePath: p.file,
Actions: []ActionDefinition{},
Name: recvType,
Path: p.file,
Actions: []ActionDefinition{},
}
p.actions[recvType] = []ActionDefinition{}
}
@@ -257,12 +256,6 @@ func (p *routeParser) buildResult() []RouteDefinition {
if actions, exists := p.actions[k]; exists {
route.Actions = actions
route.Imports = p.getUniqueImports(k)
// Set the route path from the first action for backward compatibility
if len(actions) > 0 {
route.Path = actions[0].Route
}
items = append(items, route)
}
}