fix: route issues

pkg/ast/route/builder.go

@@ -7,10 +7,12 @@ import (
 
 	"github.com/iancoleman/strcase"
 	"github.com/samber/lo"
+	"go.ipao.vip/atomctl/v2/pkg/utils/gomod"
 )
 
 type RenderBuildOpts struct {
 	PackageName    string
+	ModuleName     string
 	ProjectPackage string
 	Routes         []RouteDefinition
 }
@@ -19,6 +21,7 @@ func buildRenderData(opts RenderBuildOpts) (RenderData, error) {
 	rd := RenderData{
 		PackageName:    opts.PackageName,
 		ProjectPackage: opts.ProjectPackage,
+		ModuleName:     gomod.GetModuleName(),
 		Imports:        []string{},
 		Controllers:    []string{},
 		Routes:         make(map[string][]Router),
@@ -147,7 +150,6 @@ func buildParamToken(item ParamDefinition) string {
 	return ""
 }
 
-
 func scalarSuffix(t string) string {
 	switch t {
 	case "string", "int", "int8", "int16", "int32", "int64",

pkg/ast/route/manual.go.tpl

@@ -0,0 +1,9 @@
+package {{.PackageName}}
+
+func (r *Routes) Path() string {
+	return "/{{.PackageName}}"
+}
+
+func (r *Routes) Middlewares() []any{
+	return []any{}
+}

pkg/ast/route/render.go

@@ -11,8 +11,12 @@ import (
 //go:embed router.go.tpl
 var routeTpl string
 
+//go:embed manual.go.tpl
+var routeManualTpl string
+
 type RenderData struct {
 	PackageName    string
+	ModuleName     string
 	ProjectPackage string
 	Imports        []string
 	Controllers    []string
@@ -31,9 +35,11 @@ type Router struct {
 
 func Render(path string, routes []RouteDefinition) error {
 	routePath := filepath.Join(path, "routes.gen.go")
+	routeManualPath := filepath.Join(path, "routes.manual.go")
 
 	data, err := buildRenderData(RenderBuildOpts{
 		PackageName:    filepath.Base(path),
+		ModuleName:     gomod.GetModuleName(),
 		ProjectPackage: gomod.GetModuleName(),
 		Routes:         routes,
 	})
@@ -49,5 +55,15 @@ func Render(path string, routes []RouteDefinition) error {
 	if err := os.WriteFile(routePath, out, 0o644); err != nil {
 		return err
 	}
+	// if routes.manual.go not exists then create it
+	if _, err := os.Stat(routeManualPath); os.IsNotExist(err) {
+		manualOut, err := renderManualTemplate(data)
+		if err != nil {
+			return err
+		}
+		if err := os.WriteFile(routeManualPath, manualOut, 0o644); err != nil {
+			return err
+		}
+	}
 	return nil
 }

pkg/ast/route/renderer.go

@@ -26,9 +26,10 @@ type TemplateInfo struct {
 
 // RouteRenderer implements TemplateRenderer for route generation
 type RouteRenderer struct {
-	template *template.Template
-	info     TemplateInfo
-	logger   *log.Entry
+	template       *template.Template
+	manualTemplate *template.Template
+	info           TemplateInfo
+	logger         *log.Entry
 }
 
 // NewRouteRenderer creates a new RouteRenderer instance with proper initialization
@@ -54,6 +55,10 @@ func NewRouteRenderer() *RouteRenderer {
 		renderer.logger.WithError(err).Error("Failed to initialize template")
 		return nil
 	}
+	if err := renderer.initializeManualTemplate(); err != nil {
+		renderer.logger.WithError(err).Error("Failed to initialize manual template")
+		return nil
+	}
 
 	renderer.info.Size = len(routeTpl)
 	renderer.logger.WithFields(log.Fields{
@@ -64,6 +69,22 @@ func NewRouteRenderer() *RouteRenderer {
 	return renderer
 }
 
+func (r *RouteRenderer) initializeManualTemplate() error {
+	// Create template with sprig functions and custom options
+	tmpl := template.New(r.info.Name + "manual").
+		Funcs(sprig.FuncMap()).
+		Option("missingkey=error")
+
+	// Parse the template
+	parsedTmpl, err := tmpl.Parse(routeManualTpl)
+	if err != nil {
+		return WrapError(err, "failed to parse route template")
+	}
+
+	r.manualTemplate = parsedTmpl
+	return nil
+}
+
 // initializeTemplate sets up the template with proper functions and options
 func (r *RouteRenderer) initializeTemplate() error {
 	// Create template with sprig functions and custom options
@@ -81,6 +102,41 @@ func (r *RouteRenderer) initializeTemplate() error {
 	return nil
 }
 
+// Render renders the template with the provided data
+func (r *RouteRenderer) RenderManual(data RenderData) ([]byte, error) {
+	// Validate input data
+	if err := r.validateRenderData(data); err != nil {
+		return nil, err
+	}
+
+	// Create buffer for rendering
+	var buf bytes.Buffer
+	buf.Grow(estimatedBufferSize(data)) // Pre-allocate buffer for better performance
+
+	// Execute template with error handling
+	if err := r.manualTemplate.Execute(&buf, data); err != nil {
+		r.logger.WithError(err).WithFields(log.Fields{
+			"package_name": data.PackageName,
+			"routes_count": len(data.Routes),
+		}).Error("Template execution failed")
+		return nil, WrapError(err, "template execution failed for package: %s", data.PackageName)
+	}
+
+	// Validate rendered content
+	result := buf.Bytes()
+	if len(result) == 0 {
+		return nil, NewRouteError(ErrTemplateFailed, "rendered content is empty for package: %s", data.PackageName)
+	}
+
+	r.logger.WithFields(log.Fields{
+		"package_name":   data.PackageName,
+		"routes_count":   len(data.Routes),
+		"content_length": len(result),
+	}).Debug("Template rendered successfully")
+
+	return result, nil
+}
+
 // Render renders the template with the provided data
 func (r *RouteRenderer) Render(data RenderData) ([]byte, error) {
 	// Validate input data
@@ -152,10 +208,20 @@ func (r *RouteRenderer) validateRenderData(data RenderData) error {
 
 		for i, route := range routes {
 			if route.Method == "" {
-				return NewRouteError(ErrInvalidInput, "route method cannot be empty for controller %s, route %d", controllerName, i)
+				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 NewRouteError(
+					ErrInvalidInput,
+					"route path cannot be empty for controller %s, route %d",
+					controllerName,
+					i,
+				)
 			}
 		}
 	}
@@ -189,3 +255,11 @@ func renderTemplate(data RenderData) ([]byte, error) {
 	}
 	return renderer.Render(data)
 }
+
+func renderManualTemplate(data RenderData) ([]byte, error) {
+	renderer := NewRouteRenderer()
+	if renderer == nil {
+		return nil, NewRouteError(ErrTemplateFailed, "failed to create route renderer")
+	}
+	return renderer.RenderManual(data)
+}

pkg/ast/route/router.go.tpl

@@ -10,6 +10,8 @@ import (
 	{{.}}
 {{- end }}
 {{- end }}
+	"{{.ModuleName}}/app/middlewares"
+
 	. "go.ipao.vip/atom/fen"
 	_ "go.ipao.vip/atom"
 	_ "go.ipao.vip/atom/contracts"
@@ -23,6 +25,8 @@ import (
 // @provider contracts.HttpRoute atom.GroupRoutes
 type Routes struct {
 	log *log.Entry `inject:"false"`
+	middlewares *middlewares.Middlewares
+
 {{- if .Controllers }}
 	// Controller instances
 {{- range .Controllers }}
@@ -54,7 +58,7 @@ func (r *Routes) Register(router fiber.Router) {
 	{{- range $value }}
 	{{- if .Route }}
 	r.log.Debugf("Registering route: {{.Method}} {{.Route}} -> {{.Controller}}.{{.Action}}")
-	router.{{.Method}}("{{.Route}}", {{.Func}}(
+	router.{{.Method}}("{{.Route}}"[len(r.Path()):], {{.Func}}(
 		r.{{.Controller}}.{{.Action}},
 		{{- if .Params }}
 		{{- range .Params }}