449 lines
13 KiB
Go
449 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// HandlerData contains template data for handler generation
|
|
type HandlerData struct {
|
|
Name string
|
|
NameLower string
|
|
NamePlural string
|
|
ModuleName string
|
|
HasGet bool
|
|
HasPost bool
|
|
HasPut bool
|
|
HasDelete bool
|
|
HasParam bool
|
|
HasRequest bool
|
|
HasResponse bool
|
|
Timestamp string
|
|
}
|
|
|
|
func main() {
|
|
if len(os.Args) < 2 {
|
|
fmt.Println("Usage: go run generate-handler.go <nama-handler> [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])
|
|
methods := []string{"get", "post"}
|
|
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,
|
|
NameLower: handlerLower,
|
|
NamePlural: handlerPlural,
|
|
ModuleName: "api-service",
|
|
Timestamp: time.Now().Format("2006-01-02 15:04:05"),
|
|
}
|
|
|
|
// Check which methods are requested
|
|
for _, method := range methods {
|
|
switch strings.ToLower(method) {
|
|
case "get":
|
|
data.HasGet = true
|
|
case "post":
|
|
data.HasPost = true
|
|
case "put":
|
|
data.HasPut = true
|
|
case "delete":
|
|
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)
|
|
|
|
// Create directories if they don't exist
|
|
dirs := []string{
|
|
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.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")
|
|
}
|
|
|
|
func generateHandlerFile(data HandlerData, handlerDir string) {
|
|
handlerContent := fmt.Sprintf(`package handlers
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"api-service/internal/models/%s"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
// %sHandler handles %s services
|
|
type %sHandler struct{}
|
|
|
|
// New%sHandler creates a new %sHandler
|
|
func New%sHandler() *%sHandler {
|
|
return &%sHandler{}
|
|
}`, data.NameLower, data.Name, data.NameLower, data.Name, data.Name, data.Name, data.Name, data.Name)
|
|
|
|
// Add methods based on requested operations
|
|
var methodsContent string
|
|
|
|
if data.HasGet {
|
|
methodsContent += fmt.Sprintf(`
|
|
// Get%s godoc
|
|
// @Summary Get %s
|
|
// @Description Returns a list of %s
|
|
// @Tags %s
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Success 200 {object} %s.%sGetResponse "%s GET response"
|
|
// @Router /api/v1/%s [get]
|
|
func (h *%sHandler) Get%s(c *gin.Context) {
|
|
response := %s.%sGetResponse{
|
|
Message: "List of %s",
|
|
Data: []string{"%s 1", "%s 2"},
|
|
}
|
|
c.JSON(http.StatusOK, response)
|
|
}
|
|
|
|
// Get%sByID godoc
|
|
// @Summary Get %s by ID
|
|
// @Description Returns a single %s by ID
|
|
// @Tags %s
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path string true "%s ID"
|
|
// @Success 200 {object} %s.%sGetByIDResponse "%s GET by ID response"
|
|
// @Failure 404 {object} %s.ErrorResponse "%s not found"
|
|
// @Router /api/v1/%s/{id} [get]
|
|
func (h *%sHandler) Get%sByID(c *gin.Context) {
|
|
id := c.Param("id")
|
|
response := %s.%sGetByIDResponse{
|
|
ID: id,
|
|
Message: "%s details",
|
|
}
|
|
c.JSON(http.StatusOK, response)
|
|
}`,
|
|
data.Name, data.NameLower, data.NamePlural, data.NameLower,
|
|
data.NameLower, data.Name, data.Name, data.NamePlural,
|
|
data.Name, data.Name, data.NameLower, data.Name, data.Name, data.Name,
|
|
data.Name, data.NameLower, data.NameLower, data.NameLower,
|
|
data.Name, data.NameLower, data.Name, data.Name, data.NameLower,
|
|
data.Name, data.Name, data.NameLower, data.Name, data.NameLower, data.Name)
|
|
}
|
|
|
|
if data.HasPost {
|
|
methodsContent += fmt.Sprintf(`
|
|
// Create%s godoc
|
|
// @Summary Create %s
|
|
// @Description Creates a new %s
|
|
// @Tags %s
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param request body %s.%sCreateRequest true "%s creation request"
|
|
// @Success 201 {object} %s.%sCreateResponse "%s created successfully"
|
|
// @Failure 400 {object} %s.ErrorResponse "Bad request"
|
|
// @Router /api/v1/%s [post]
|
|
func (h *%sHandler) Create%s(c *gin.Context) {
|
|
var req %s.%sCreateRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
response := %s.%sCreateResponse{
|
|
ID: uuid.NewString(),
|
|
Message: "%s created successfully",
|
|
Data: req,
|
|
}
|
|
c.JSON(http.StatusCreated, response)
|
|
}`,
|
|
data.Name, data.NameLower, data.NameLower, data.NameLower,
|
|
data.NameLower, data.Name, data.Name, data.NameLower, data.Name,
|
|
data.Name, data.NameLower, data.Name, data.Name, data.NameLower,
|
|
data.Name, data.Name)
|
|
}
|
|
|
|
if data.HasPut {
|
|
methodsContent += fmt.Sprintf(`
|
|
// Update%s godoc
|
|
// @Summary Update %s
|
|
// @Description Updates an existing %s
|
|
// @Tags %s
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path string true "%s ID"
|
|
// @Param request body %s.%sUpdateRequest true "%s update request"
|
|
// @Success 200 {object} %s.%sUpdateResponse "%s updated successfully"
|
|
// @Failure 400 {object} %s.ErrorResponse "Bad request"
|
|
// @Failure 404 {object} %s.ErrorResponse "%s not found"
|
|
// @Router /api/v1/%s/{id} [put]
|
|
func (h *%sHandler) Update%s(c *gin.Context) {
|
|
id := c.Param("id")
|
|
var req %s.%sUpdateRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
response := %s.%sUpdateResponse{
|
|
ID: id,
|
|
Message: "%s updated successfully",
|
|
Data: req,
|
|
}
|
|
c.JSON(http.StatusOK, response)
|
|
}`,
|
|
data.Name, data.NameLower, data.NameLower, data.NameLower,
|
|
data.Name, data.NameLower, data.Name, data.Name, data.Name,
|
|
data.NameLower, data.Name, data.NameLower, data.Name, data.NameLower,
|
|
data.Name, data.Name, data.Name, data.Name)
|
|
}
|
|
|
|
if data.HasDelete {
|
|
methodsContent += fmt.Sprintf(`
|
|
// Delete%s godoc
|
|
// @Summary Delete %s
|
|
// @Description Deletes a %s by ID
|
|
// @Tags %s
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path string true "%s ID"
|
|
// @Success 200 {object} %s.%sDeleteResponse "%s deleted successfully"
|
|
// @Failure 404 {object} %s.ErrorResponse "%s not found"
|
|
// @Router /api/v1/%s/{id} [delete]
|
|
func (h *%sHandler) Delete%s(c *gin.Context) {
|
|
id := c.Param("id")
|
|
response := %s.%sDeleteResponse{
|
|
ID: id,
|
|
Message: "%s deleted successfully",
|
|
}
|
|
c.JSON(http.StatusOK, response)
|
|
}`,
|
|
data.Name, data.NameLower, data.NameLower, data.NameLower,
|
|
data.Name, data.NameLower, data.Name, data.Name, data.NameLower,
|
|
data.Name, data.Name, data.NameLower, data.Name, data.Name)
|
|
}
|
|
|
|
fullContent := handlerContent + methodsContent
|
|
handlerFile := filepath.Join(handlerDir, data.NameLower+".go")
|
|
writeFile(handlerFile, fullContent)
|
|
}
|
|
|
|
func generateModelFile(data HandlerData, modelDir string) {
|
|
modelContent := fmt.Sprintf("package %s\n\n", data.NameLower)
|
|
|
|
if data.HasGet {
|
|
modelContent += fmt.Sprintf(`// %sGetResponse represents the response for GET %s
|
|
type %sGetResponse struct {
|
|
Message string `+"`json:\"message\"`"+`
|
|
Data interface{} `+"`json:\"data\"`"+`
|
|
}
|
|
|
|
// %sGetByIDResponse represents the 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.NameLower, data.Name)
|
|
}
|
|
|
|
if data.HasPost {
|
|
modelContent += fmt.Sprintf(`// %sCreateRequest represents the 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
|
|
type %sCreateResponse struct {
|
|
ID string `+"`json:\"id\"`"+`
|
|
Message string `+"`json:\"message\"`"+`
|
|
Data interface{} `+"`json:\"data\"`"+`
|
|
}
|
|
`, data.Name, data.NameLower, data.Name, data.NameLower, data.Name, data.NameLower, data.Name)
|
|
}
|
|
|
|
if data.HasPut {
|
|
modelContent += fmt.Sprintf(`// %sUpdateRequest represents the 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
|
|
type %sUpdateResponse struct {
|
|
ID string `+"`json:\"id\"`"+`
|
|
Message string `+"`json:\"message\"`"+`
|
|
Data interface{} `+"`json:\"data\"`"+`
|
|
}
|
|
`, data.Name, data.NameLower, data.Name, data.NameLower, data.Name, data.NameLower, data.Name)
|
|
}
|
|
|
|
if data.HasDelete {
|
|
modelContent += fmt.Sprintf(`// %sDeleteResponse represents the response for deleting %s
|
|
type %sDeleteResponse struct {
|
|
ID string `+"`json:\"id\"`"+`
|
|
Message string `+"`json:\"message\"`"+`
|
|
}
|
|
`, data.Name, data.NameLower, data.Name, data.NameLower)
|
|
}
|
|
|
|
modelContent += `// ErrorResponse represents an error response
|
|
type ErrorResponse struct {
|
|
Error string ` + "`json:\"error\"`" + `
|
|
}
|
|
`
|
|
|
|
modelFile := filepath.Join(modelDir, data.NameLower+".go")
|
|
writeFile(modelFile, modelContent)
|
|
}
|
|
|
|
func updateRoutesFile(data HandlerData) {
|
|
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)
|
|
return
|
|
}
|
|
|
|
routesContent := string(content)
|
|
|
|
// Check if import already exists
|
|
importPattern := fmt.Sprintf(`%sHandlers "api-service/internal/handlers/%s"`, data.NameLower, data.NameLower)
|
|
if !strings.Contains(routesContent, importPattern) {
|
|
// Find the import block and insert the new import
|
|
importToAdd := fmt.Sprintf("\t%sHandlers \"api-service/internal/handlers/%s\"", data.NameLower, data.NameLower)
|
|
|
|
// Find the import block end
|
|
importEndMarker := "\n)\n\n// RegisterRoutes"
|
|
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
|
|
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)
|
|
|
|
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/:id\", %sHandler.Get%sByID)\n", data.NamePlural, data.NameLower, data.Name)
|
|
}
|
|
|
|
if data.HasPost {
|
|
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)
|
|
}
|
|
|
|
if data.HasDelete {
|
|
newRoutes += fmt.Sprintf("\t\tv1.DELETE(\"/%s/:id\", %sHandler.Delete%s)\n", data.NamePlural, data.NameLower, data.Name)
|
|
}
|
|
|
|
newRoutes += "\n"
|
|
|
|
// Find the place to insert new routes (after the protected group)
|
|
insertMarker := "\t\tprotected := v1.Group(\"/\")"
|
|
|
|
// Check if routes already exist
|
|
if strings.Contains(routesContent, fmt.Sprintf("New%sHandler", data.Name)) {
|
|
fmt.Printf("Routes for %s already exist, skipping...\n", data.Name)
|
|
return
|
|
}
|
|
|
|
// Insert new routes before the protected group
|
|
newContent := strings.Replace(routesContent, insertMarker, newRoutes+insertMarker, 1)
|
|
|
|
// 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 file with %s endpoints\n", data.Name)
|
|
}
|
|
|
|
func writeFile(filename, content string) {
|
|
err := os.WriteFile(filename, []byte(content), 0644)
|
|
if err != nil {
|
|
fmt.Printf("Error creating file %s: %v\n", filename, err)
|
|
return
|
|
}
|
|
fmt.Printf("Generated: %s\n", filename)
|
|
}
|