pembaruan generete tool

internal/handlers/employee/employee.go

@@ -1,125 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-
-	"api-service/internal/models"
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-)
-
-// EmployeeHandler handles employee services
-type EmployeeHandler struct{}
-
-// NewEmployeeHandler creates a new EmployeeHandler
-func NewEmployeeHandler() *EmployeeHandler {
-	// return &%!s(MISSING)Handler{}
-	return &EmployeeHandler{}
-}
-
-// GetEmployee godoc
-// @Summary Get employee
-// @Description Returns a list of employees
-// @Tags employee
-// @Accept json
-// @Produce json
-// @Success 200 {object} models.EmployeeGetResponse "Employee GET response"
-// @Router /api/v1/employees [get]
-func (h *EmployeeHandler) GetEmployee(c *gin.Context) {
-	response := models.EmployeeGetResponse{
-		Message: "List of employees",
-		Data:    []string{"Employee 1", "Employee 2"},
-	}
-	c.JSON(http.StatusOK, response)
-}
-
-// GetEmployeeByID godoc
-// @Summary Get employee by ID
-// @Description Returns a single employee by ID
-// @Tags employee
-// @Accept json
-// @Produce json
-// @Param id path string true "Employee ID"
-// @Success 200 {object} models.EmployeeGetByIDResponse "Employee GET by ID response"
-// @Failure 404 {object} models.ErrorResponse "employee not found"
-// @Router /api/v1/Employee/{id} [get]
-func (h *EmployeeHandler) GetEmployeeByID(c *gin.Context) {
-	id := c.Param("id")
-	response := models.EmployeeGetByIDResponse{
-		ID:      id,
-		Message: "employee details",
-	}
-	c.JSON(http.StatusOK, response)
-}%!(EXTRA string=Employee)
-
-// CreateEmployee godoc
-// @Summary Create employee
-// @Description Creates a new employee
-// @Tags employee
-// @Accept json
-// @Produce json
-// @Param request body models.EmployeeCreateRequest true "Employee creation request"
-// @Success 201 {object} models.EmployeeCreateResponse "Employee created successfully"
-// @Failure 400 {object} models.ErrorResponse "Bad request"
-// @Router /api/v1/employees [post]
-func (h *EmployeeHandler) CreateEmployee(c *gin.Context) {
-	var req models.EmployeeCreateRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	response := models.EmployeeCreateResponse{
-		ID:      uuid.NewString(),
-		Message: "Employee created successfully",
-		Data:    req,
-	}
-	c.JSON(http.StatusCreated, response)
-}
-
-// UpdateEmployee godoc
-// @Summary Update employee
-// @Description Updates an existing employee
-// @Tags employee
-// @Accept json
-// @Produce json
-// @Param id path string true "Employee ID"
-// @Param request body models.employeeUpdateRequest true "Employee update request"
-// @Success 200 {object} models.EmployeeUpdateResponse "Employee updated successfully"
-// @Failure 400 {object} models.ErrorResponse "Bad request"
-// @Failure 404 {object} models.ErrorResponse "employee not found"
-// @Router /api/v1/Employee/{id} [put]
-func (h *EmployeeHandler) UpdateEmployee(c *gin.Context) {
-	id := c.Param("id")
-	var req models.employeeUpdateRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	response := models.EmployeeUpdateResponse{
-		ID:      id,
-		Message: "Employee updated successfully",
-		Data:    req,
-	}
-	c.JSON(http.StatusOK, response)
-}%!(EXTRA string=Employee, string=Employee)
-
-// DeleteEmployee godoc
-// @Summary Delete employee
-// @Description Deletes a employee by ID
-// @Tags employee
-// @Accept json
-// @Produce json
-// @Param id path string true "Employee ID"
-// @Success 200 {object} models.employeeDeleteResponse "Employee deleted successfully"
-// @Failure 404 {object} models.ErrorResponse "Employee not found"
-// @Router /api/v1/employee/{id} [delete]
-func (h *EmployeeHandler) DeleteEmployee(c *gin.Context) {
-	id := c.Param("id")
-	response := models.EmployeeDeleteResponse{
-		ID:      id,
-		Message: "Employee deleted successfully",
-	}
-	c.JSON(http.StatusOK, response)
-}

internal/models/employee/employee.go

@@ -1,46 +0,0 @@
-package employee
-
-// EmployeeGetResponse represents the response for GET employees
-type EmployeeGetResponse struct {
-	Message string      `json:"message"`
-	Data    interface{} `json:"data"`
-}
-
-// EmployeeGetByIDResponse represents the response for GET employee by ID
-type EmployeeGetByIDResponse struct {
-	ID      string `json:"id"`
-	Message string `json:"message"`
-}
-// EmployeeCreateRequest represents the request for creating employee
-type EmployeeCreateRequest struct {
-	Name string `json:"name" binding:"required"`
-	// Add more fields as needed
-}
-
-// EmployeeCreateResponse represents the response for creating employee
-type EmployeeCreateResponse struct {
-	ID      string      `json:"id"`
-	Message string      `json:"message"`
-	Data    interface{} `json:"data"`
-}
-// EmployeeUpdateRequest represents the request for updating employee
-type EmployeeUpdateRequest struct {
-	Name string `json:"name" binding:"required"`
-	// Add more fields as needed
-}
-
-// EmployeeUpdateResponse represents the response for updating employee
-type EmployeeUpdateResponse struct {
-	ID      string      `json:"id"`
-	Message string      `json:"message"`
-	Data    interface{} `json:"data"`
-}
-// EmployeeDeleteResponse represents the response for deleting employee
-type EmployeeDeleteResponse struct {
-	ID      string `json:"id"`
-	Message string `json:"message"`
-}
-// ErrorResponse represents an error response
-type ErrorResponse struct {
-	Error string `json:"error"`
-}

internal/routes/v1/routes.go

@@ -13,7 +13,6 @@ import (
 
 	authHandlers "api-service/internal/handlers/auth"
 	componentHandlers "api-service/internal/handlers/component"
-	employeeHandlers "api-service/internal/handlers/employee"
 )
 
 // RegisterRoutes registers all API routes for version 1
@@ -57,15 +56,6 @@ func RegisterRoutes(cfg *config.Config) *gin.Engine {
 		// Protected routes (require authentication)
 
 
-
-		// Employee endpoints
-		employeeHandler := employeeHandlers.NewEmployeeHandler()
-		v1.GET("/employees", employeeHandler.GetEmployee)
-		v1.GET("/employees/:id", employeeHandler.GetEmployeeByID)
-		v1.POST("/employees", employeeHandler.CreateEmployee)
-		v1.PUT("/employees/:id", employeeHandler.UpdateEmployee)
-		v1.DELETE("/employees/:id", employeeHandler.DeleteEmployee)
-
 		protected := v1.Group("/")
 		protected.Use(middleware.JWTAuthMiddleware(authService))
 		{

tools/generate-handler.go

@@ -26,33 +26,30 @@ type HandlerData struct {
 
 func main() {
 	if len(os.Args) < 2 {
-		fmt.Println("Usage: go run generate-handler.go <nama-handler> [methods]")
+		fmt.Println("Usage: go run generate-handler.go entity [methods]")
-		fmt.Println("Example: go run generate-handler.go user get post put delete")
-		fmt.Println("Example: go run generate-handler.go product get post")
 		os.Exit(1)
 	}
 
-	handlerName := strings.Title(os.Args[1])
+	handlerName := strings.Title(os.Args[1]) // PascalCase entity name
-	methods := []string{"get", "post"}
+	methods := []string{}
 	if len(os.Args) > 2 {
 		methods = os.Args[2:]
 	}
 
-	// Convert to lowercase for file names
 	handlerLower := strings.ToLower(handlerName)
 	handlerPlural := handlerLower + "s"
 
 	data := HandlerData{
-		Name:       handlerName,
+		Name:        handlerName,
-		NameLower:  handlerLower,
+		NameLower:   handlerLower,
-		NamePlural: handlerPlural,
+		NamePlural:  handlerPlural,
-		ModuleName: "api-service",
+		ModuleName:  "api-service",
-		Timestamp:  time.Now().Format("2006-01-02 15:04:05"),
+		Timestamp:   time.Now().Format("2006-01-02 15:04:05"),
+		HasResponse: true,
 	}
 
-	// Check which methods are requested
+	for _, m := range methods {
-	for _, method := range methods {
+		switch strings.ToLower(m) {
-		switch strings.ToLower(method) {
 		case "get":
 			data.HasGet = true
 		case "post":
@@ -63,51 +60,31 @@ func main() {
 			data.HasDelete = true
 		}
 	}
-
-	// Check if we need request/response models
 	data.HasRequest = data.HasPost || data.HasPut
-	data.HasResponse = true
 	data.HasParam = data.HasGet || data.HasPut || data.HasDelete
 
-	fmt.Printf("Generating handler: %s with methods: %v\n", handlerName, methods)
-
-	// Create directories with proper structure
 	handlerDir := filepath.Join("internal", "handlers", handlerLower)
 	modelDir := filepath.Join("internal", "models", handlerLower)
-
+	for _, d := range []string{handlerDir, modelDir} {
-	// Create directories if they don't exist
+		if err := os.MkdirAll(d, 0755); err != nil {
-	dirs := []string{
+			panic(err)
-		handlerDir,
-		modelDir,
-	}
-
-	for _, dir := range dirs {
-		if err := os.MkdirAll(dir, 0755); err != nil {
-			fmt.Printf("Error creating directory %s: %v\n", dir, err)
-			os.Exit(1)
 		}
-		fmt.Printf("Created directory: %s\n", dir)
 	}
 
-	// Generate files
 	generateHandlerFile(data, handlerDir)
 	generateModelFile(data, modelDir)
 	updateRoutesFile(data)
 
-	fmt.Printf("Successfully generated handler: %s\n", handlerName)
+	fmt.Printf("✅ Successfully generated handler: %s\n", handlerName)
-	fmt.Println("Don't forget to:")
-	fmt.Println("1. Run: swag init -g cmd/api/main.go")
-	fmt.Println("2. Update your service layer if needed")
-	fmt.Println("3. Add repository layer if required")
 }
 
+// ================= HANDLER =====================
 func generateHandlerFile(data HandlerData, handlerDir string) {
 	handlerContent := fmt.Sprintf(`package handlers
 
 import (
+	models "%s/internal/models/%s"
 	"net/http"
-
-	"api-service/internal/models"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
 )
@@ -118,14 +95,18 @@ type %sHandler struct{}
 // New%sHandler creates a new %sHandler
 func New%sHandler() *%sHandler {
 	return &%sHandler{}
-}`, data.Name, data.NameLower, data.Name, data.Name, data.Name, data.Name, data.Name)
+}
+`, data.ModuleName, data.NameLower,
+		data.Name, data.NameLower,
+		data.Name,
+		data.Name, data.Name,
+		data.Name, data.Name, data.Name)
 
-	// Add methods based on requested operations
 	var methodsContent string
 
+	// GET
 	if data.HasGet {
 		methodsContent += fmt.Sprintf(`
-
 // Get%s godoc
 // @Summary Get %s
 // @Description Returns a list of %s
@@ -137,7 +118,7 @@ func New%sHandler() *%sHandler {
 func (h *%sHandler) Get%s(c *gin.Context) {
 	response := models.%sGetResponse{
 		Message: "List of %s",
-		Data:    []string{"%s 1", "%s 2"},
+		Data: []string{"%s 1", "%s 2"},
 	}
 	c.JSON(http.StatusOK, response)
 }
@@ -155,22 +136,24 @@ func (h *%sHandler) Get%s(c *gin.Context) {
 func (h *%sHandler) Get%sByID(c *gin.Context) {
 	id := c.Param("id")
 	response := models.%sGetByIDResponse{
-		ID:      id,
+		ID: id,
 		Message: "%s details",
 	}
 	c.JSON(http.StatusOK, response)
-}`,
+}
-			data.Name, data.NameLower, data.NamePlural, data.NameLower,
+`, data.Name, data.NameLower, data.NamePlural, data.NameLower,
 			data.Name, data.Name, data.NamePlural,
-			data.Name, data.Name, data.Name, data.NamePlural, data.Name, data.Name,
+			data.Name, data.Name,
+			data.Name, data.NamePlural, data.Name, data.Name,
+			data.Name,
 			data.Name, data.NameLower, data.NameLower, data.NameLower,
-			data.Name, data.Name, data.Name, data.NameLower, data.Name,
+			data.Name, data.Name, data.Name, data.NameLower,
-			data.Name, data.Name, data.Name, data.NameLower, data.Name)
+			data.Name, data.Name, data.Name)
 	}
 
+	// POST
 	if data.HasPost {
 		methodsContent += fmt.Sprintf(`
-
 // Create%s godoc
 // @Summary Create %s
 // @Description Creates a new %s
@@ -187,22 +170,22 @@ func (h *%sHandler) Create%s(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
-
 	response := models.%sCreateResponse{
-		ID:      uuid.NewString(),
+		ID: uuid.NewString(),
 		Message: "%s created successfully",
-		Data:    req,
+		Data: req,
 	}
 	c.JSON(http.StatusCreated, response)
-}`,
+}
-			data.Name, data.NameLower, data.NameLower, data.NameLower,
+`, data.Name, data.NameLower, data.NameLower, data.NameLower,
 			data.Name, data.Name, data.Name, data.Name, data.NamePlural,
-			data.Name, data.Name, data.Name, data.Name, data.Name)
+			data.Name, data.Name, data.Name,
+			data.Name, data.Name)
 	}
 
+	// PUT
 	if data.HasPut {
 		methodsContent += fmt.Sprintf(`
-
 // Update%s godoc
 // @Summary Update %s
 // @Description Updates an existing %s
@@ -222,23 +205,23 @@ func (h *%sHandler) Update%s(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
-
 	response := models.%sUpdateResponse{
-		ID:      id,
+		ID: id,
 		Message: "%s updated successfully",
-		Data:    req,
+		Data: req,
 	}
 	c.JSON(http.StatusOK, response)
-}`,
+}
-			data.Name, data.NameLower, data.NameLower, data.NameLower,
+`, data.Name, data.NameLower, data.NameLower, data.NameLower,
-			data.Name, data.NameLower, data.Name, data.Name, data.Name,
+			data.Name, data.Name, data.Name, data.Name, data.Name,
-			data.NameLower, data.Name, data.Name, data.Name, data.NameLower,
+			data.Name, data.Name, data.NameLower,
-			data.Name, data.Name, data.Name, data.Name)
+			data.Name, data.Name, data.Name,
+			data.Name)
 	}
 
+	// DELETE
 	if data.HasDelete {
 		methodsContent += fmt.Sprintf(`
-
 // Delete%s godoc
 // @Summary Delete %s
 // @Description Deletes a %s by ID
@@ -252,73 +235,73 @@ func (h *%sHandler) Update%s(c *gin.Context) {
 func (h *%sHandler) Delete%s(c *gin.Context) {
 	id := c.Param("id")
 	response := models.%sDeleteResponse{
-		ID:      id,
+		ID: id,
 		Message: "%s deleted successfully",
 	}
 	c.JSON(http.StatusOK, response)
-}`,
+}
-			data.Name, data.NameLower, data.NameLower, data.NameLower,
+`, data.Name, data.NameLower, data.NameLower, data.NameLower,
-			data.Name, data.NameLower, data.Name, data.Name, data.NameLower,
+			data.Name, data.Name, data.Name, data.Name, data.NameLower,
-			data.Name, data.Name, data.Name, data.Name)
+			data.Name, data.Name, data.Name)
 	}
 
-	fullContent := handlerContent + methodsContent
+	writeFile(filepath.Join(handlerDir, data.NameLower+".go"), handlerContent+methodsContent)
-	handlerFile := filepath.Join(handlerDir, data.NameLower+".go")
-	writeFile(handlerFile, fullContent)
 }
 
+// ================= MODELS =====================
 func generateModelFile(data HandlerData, modelDir string) {
-	modelContent := fmt.Sprintf("package %s\n\n", data.NameLower)
+	modelContent := "package models\n\n"
 
 	if data.HasGet {
-		modelContent += fmt.Sprintf(`// %sGetResponse represents the response for GET %s
+		modelContent += fmt.Sprintf(`// %sGetResponse response for GET %s
 type %sGetResponse struct {
-	Message string      `+"`json:\"message\"`"+`
+	Message string `+"`json:\"message\"`"+`
 	Data    interface{} `+"`json:\"data\"`"+`
 }
 
-// %sGetByIDResponse represents the response for GET %s by ID
+// %sGetByIDResponse response for GET %s by ID
 type %sGetByIDResponse struct {
 	ID      string `+"`json:\"id\"`"+`
 	Message string `+"`json:\"message\"`"+`
 }
-`, data.Name, data.NamePlural, data.Name, data.Name, data.NameLower, data.Name)
+`, data.Name, data.NamePlural, data.Name,
+			data.Name, data.NameLower, data.Name)
 	}
 
 	if data.HasPost {
-		modelContent += fmt.Sprintf(`// %sCreateRequest represents the request for creating %s
+		modelContent += fmt.Sprintf(`// %sCreateRequest request for creating %s
 type %sCreateRequest struct {
 	Name string `+"`json:\"name\" binding:\"required\"`"+`
-	// Add more fields as needed
 }
 
-// %sCreateResponse represents the response for creating %s
+// %sCreateResponse response for creating %s
 type %sCreateResponse struct {
-	ID      string      `+"`json:\"id\"`"+`
+	ID      string `+"`json:\"id\"`"+`
-	Message string      `+"`json:\"message\"`"+`
+	Message string `+"`json:\"message\"`"+`
 	Data    interface{} `+"`json:\"data\"`"+`
 }
-`, data.Name, data.NameLower, data.Name, data.Name, data.NameLower, data.Name)
+`, data.Name, data.NameLower, data.Name,
+			data.Name, data.NameLower, data.Name)
 	}
 
 	if data.HasPut {
-		modelContent += fmt.Sprintf(`// %sUpdateRequest represents the request for updating %s
+		modelContent += fmt.Sprintf(`// %sUpdateRequest request for updating %s
 type %sUpdateRequest struct {
 	Name string `+"`json:\"name\" binding:\"required\"`"+`
-	// Add more fields as needed
 }
 
-// %sUpdateResponse represents the response for updating %s
+// %sUpdateResponse response for updating %s
 type %sUpdateResponse struct {
-	ID      string      `+"`json:\"id\"`"+`
+	ID      string `+"`json:\"id\"`"+`
-	Message string      `+"`json:\"message\"`"+`
+	Message string `+"`json:\"message\"`"+`
 	Data    interface{} `+"`json:\"data\"`"+`
 }
-`, data.Name, data.NameLower, data.Name, data.Name, data.NameLower, data.Name)
+`, data.Name, data.NameLower, data.Name,
+			data.Name, data.NameLower, data.Name)
 	}
 
 	if data.HasDelete {
-		modelContent += fmt.Sprintf(`// %sDeleteResponse represents the response for deleting %s
+		modelContent += fmt.Sprintf(`// %sDeleteResponse response for deleting %s
 type %sDeleteResponse struct {
 	ID      string `+"`json:\"id\"`"+`
 	Message string `+"`json:\"message\"`"+`
@@ -326,124 +309,81 @@ type %sDeleteResponse struct {
 `, data.Name, data.NameLower, data.Name)
 	}
 
-	modelContent += `// ErrorResponse represents an error response
+	modelContent += `// ErrorResponse common error response
 type ErrorResponse struct {
 	Error string ` + "`json:\"error\"`" + `
 }
 `
-
+	writeFile(filepath.Join(modelDir, data.NameLower+".go"), modelContent)
-	modelFile := filepath.Join(modelDir, data.NameLower+".go")
-	writeFile(modelFile, modelContent)
 }
 
+// ================= ROUTES =====================
 func updateRoutesFile(data HandlerData) {
-	fmt.Println("Updating routes file...") // Debug statement
 	routesFile := "internal/routes/v1/routes.go"
-
-	// Read existing routes file
 	content, err := os.ReadFile(routesFile)
 	if err != nil {
-		fmt.Printf("Error reading routes file: %v\n", err)
+		fmt.Printf("Error reading routes.go: %v\n", err)
 		return
 	}
-
 	routesContent := string(content)
 
-	// Check if import already exists
+	// import
-	importPattern := fmt.Sprintf(`%sHandlers "api-service/internal/handlers/%s"`, data.NameLower, data.NameLower)
+	importPattern := fmt.Sprintf("%sHandlers \"%s/internal/handlers/%s\"",
+		data.NameLower, data.ModuleName, data.NameLower)
 	if !strings.Contains(routesContent, importPattern) {
-		// Find the import block and insert the new import
+		importToAdd := fmt.Sprintf("\t%sHandlers \"%s/internal/handlers/%s\"",
-		importToAdd := fmt.Sprintf("\t%sHandlers \"api-service/internal/handlers/%s\"", data.NameLower, data.NameLower)
+			data.NameLower, data.ModuleName, data.NameLower)
-
+		if strings.Contains(routesContent, "import (") {
-		// Find the import block end
+			routesContent = strings.Replace(routesContent, "import (",
-		importEndMarker := "\n)\n\n// RegisterRoutes"
+				"import (\n"+importToAdd, 1)
-		if !strings.Contains(routesContent, importEndMarker) {
-			importEndMarker = "\n)\n\nfunc RegisterRoutes"
-		}
-
-		// Find the line before the closing parenthesis
-		lines := strings.Split(routesContent, "\n")
-		var newLines []string
-		importBlockFound := false
-		importAdded := false
-
-		for _, line := range lines {
-			newLines = append(newLines, line)
-
-			// Check if we're in the import block
-			if strings.Contains(line, "import (") {
-				importBlockFound = true
-				continue
-			}
-
-			// Check if we're at the end of import block
-			if importBlockFound && strings.TrimSpace(line) == ")" && !importAdded {
-				// Insert the new import before the closing parenthesis
-				newLines = newLines[:len(newLines)-1] // Remove the last line (closing parenthesis)
-				newLines = append(newLines, importToAdd)
-				newLines = append(newLines, line) // Add back the closing parenthesis
-				importAdded = true
-			}
-		}
-
-		if importAdded {
-			routesContent = strings.Join(newLines, "\n")
-		} else {
-			// Fallback to simple string replacement
-			if strings.Contains(routesContent, importEndMarker) {
-				routesContent = strings.Replace(routesContent, importEndMarker, "\n"+importToAdd+importEndMarker, 1)
-			}
 		}
 	}
 
-	// Generate new routes
+	// routes
 	newRoutes := fmt.Sprintf("\t\t// %s endpoints\n", data.Name)
-	newRoutes += fmt.Sprintf("\t\t%sHandler := %sHandlers.New%sHandler()\n", data.NameLower, data.NameLower, data.Name)
+	newRoutes += fmt.Sprintf("\t\t%sHandler := %sHandlers.New%sHandler()\n",
+		data.NameLower, data.NameLower, data.Name)
 
 	if data.HasGet {
-		newRoutes += fmt.Sprintf("\t\tv1.GET(\"/%s\", %sHandler.Get%s)\n", data.NamePlural, data.NameLower, data.Name)
+		newRoutes += fmt.Sprintf("\t\tv1.GET(\"/%s\", %sHandler.Get%s)\n",
-		newRoutes += fmt.Sprintf("\t\tv1.GET(\"/%s/:id\", %sHandler.Get%sByID)\n", data.NamePlural, data.NameLower, data.Name)
+			data.NamePlural, data.NameLower, data.Name)
+		newRoutes += fmt.Sprintf("\t\tv1.GET(\"/%s/:id\", %sHandler.Get%sByID)\n",
+			data.NameLower, data.NameLower, data.Name)
 	}
-
 	if data.HasPost {
-		newRoutes += fmt.Sprintf("\t\tv1.POST(\"/%s\", %sHandler.Create%s)\n", data.NamePlural, data.NameLower, data.Name)
+		newRoutes += fmt.Sprintf("\t\tv1.POST(\"/%s\", %sHandler.Create%s)\n",
+			data.NamePlural, data.NameLower, data.Name)
 	}
-
 	if data.HasPut {
-		newRoutes += fmt.Sprintf("\t\tv1.PUT(\"/%s/:id\", %sHandler.Update%s)\n", data.NamePlural, data.NameLower, data.Name)
+		newRoutes += fmt.Sprintf("\t\tv1.PUT(\"/%s/:id\", %sHandler.Update%s)\n",
+			data.NameLower, data.NameLower, data.Name)
 	}
-
 	if data.HasDelete {
-		newRoutes += fmt.Sprintf("\t\tv1.DELETE(\"/%s/:id\", %sHandler.Delete%s)\n", data.NamePlural, data.NameLower, data.Name)
+		newRoutes += fmt.Sprintf("\t\tv1.DELETE(\"/%s/:id\", %sHandler.Delete%s)\n",
+			data.NameLower, data.NameLower, data.Name)
 	}
-
 	newRoutes += "\n"
 
-	// Find the place to insert new routes (after the protected group)
 	insertMarker := "\t\tprotected := v1.Group(\"/\")"
-
+	if strings.Contains(routesContent, insertMarker) {
-	// Check if routes already exist
+		if !strings.Contains(routesContent, fmt.Sprintf("New%sHandler", data.Name)) {
-	if strings.Contains(routesContent, fmt.Sprintf("New%sHandler", data.Name)) {
+			routesContent = strings.Replace(routesContent, insertMarker,
-		fmt.Printf("Routes for %s already exist, skipping...\n", data.Name)
+				newRoutes+insertMarker, 1)
-		return
+		} else {
+			fmt.Printf("⚠️ Routes for %s already exist, skipping...\n", data.Name)
+		}
 	}
 
-	// Insert new routes before the protected group
+	if err := os.WriteFile(routesFile, []byte(routesContent), 0644); err != nil {
-	newContent := strings.Replace(routesContent, insertMarker, newRoutes+insertMarker, 1)
+		fmt.Printf("Error writing routes.go: %v\n", err)
-
-	// Write back to file
-	err = os.WriteFile(routesFile, []byte(newContent), 0644)
-	if err != nil {
-		fmt.Printf("Error writing routes file: %v\n", err)
 		return
 	}
-
+	fmt.Printf("✅ Updated routes.go with %s endpoints\n", data.Name)
-	fmt.Printf("Updated routes file with %s endpoints\n", data.Name)
 }
 
+// ================= UTIL =====================
 func writeFile(filename, content string) {
-	err := os.WriteFile(filename, []byte(content), 0644)
+	if err := os.WriteFile(filename, []byte(content), 0644); err != nil {
-	if err != nil {
 		fmt.Printf("Error creating file %s: %v\n", filename, err)
 		return
 	}