@ngxtm/devkit 3.3.0 → 3.4.1

package/rules/golang/fiber-framework/references/routing-patterns.md

@@ -0,0 +1,191 @@
+# Fiber Routing Patterns
+
+## Basic Setup
+
+```go
+import "github.com/gofiber/fiber/v2"
+
+func main() {
+    app := fiber.New(fiber.Config{
+        Prefork:       false,
+        CaseSensitive: true,
+        StrictRouting: true,
+        ServerHeader:  "MyApp",
+        AppName:       "My App v1.0.0",
+    })
+
+    // Basic routes
+    app.Get("/", func(c *fiber.Ctx) error {
+        return c.SendString("Hello, World!")
+    })
+
+    app.Post("/users", createUser)
+    app.Get("/users/:id", getUser)
+    app.Put("/users/:id", updateUser)
+    app.Delete("/users/:id", deleteUser)
+
+    app.Listen(":3000")
+}
+```
+
+## Handlers
+
+```go
+// Path parameters
+func getUser(c *fiber.Ctx) error {
+    id := c.Params("id")
+    return c.JSON(fiber.Map{"id": id})
+}
+
+// Query parameters
+func listUsers(c *fiber.Ctx) error {
+    page := c.QueryInt("page", 1)
+    limit := c.QueryInt("limit", 10)
+    search := c.Query("search", "")
+    
+    return c.JSON(fiber.Map{
+        "page":   page,
+        "limit":  limit,
+        "search": search,
+    })
+}
+
+// Request body
+type CreateUserRequest struct {
+    Name  string `json:"name" validate:"required"`
+    Email string `json:"email" validate:"required,email"`
+}
+
+func createUser(c *fiber.Ctx) error {
+    req := new(CreateUserRequest)
+    if err := c.BodyParser(req); err != nil {
+        return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+            "error": err.Error(),
+        })
+    }
+    
+    return c.Status(fiber.StatusCreated).JSON(req)
+}
+
+// Headers
+func handler(c *fiber.Ctx) error {
+    auth := c.Get("Authorization")
+    c.Set("X-Custom-Header", "value")
+    return c.SendString("OK")
+}
+```
+
+## Route Groups
+
+```go
+func main() {
+    app := fiber.New()
+
+    // API group
+    api := app.Group("/api")
+    
+    // Version groups
+    v1 := api.Group("/v1")
+    v1.Get("/users", listUsersV1)
+    
+    v2 := api.Group("/v2")
+    v2.Get("/users", listUsersV2)
+
+    // Group with middleware
+    admin := api.Group("/admin", authMiddleware)
+    admin.Get("/stats", getStats)
+    admin.Post("/config", updateConfig)
+
+    app.Listen(":3000")
+}
+```
+
+## Middleware
+
+```go
+import (
+    "github.com/gofiber/fiber/v2"
+    "github.com/gofiber/fiber/v2/middleware/logger"
+    "github.com/gofiber/fiber/v2/middleware/recover"
+    "github.com/gofiber/fiber/v2/middleware/cors"
+    "github.com/gofiber/fiber/v2/middleware/limiter"
+)
+
+func main() {
+    app := fiber.New()
+
+    // Built-in middleware
+    app.Use(recover.New())
+    app.Use(logger.New())
+    app.Use(cors.New(cors.Config{
+        AllowOrigins: "https://example.com",
+        AllowMethods: "GET,POST,PUT,DELETE",
+    }))
+    
+    // Rate limiter
+    app.Use(limiter.New(limiter.Config{
+        Max:        100,
+        Expiration: 1 * time.Minute,
+    }))
+
+    // Custom middleware
+    app.Use(func(c *fiber.Ctx) error {
+        start := time.Now()
+        
+        err := c.Next()
+        
+        duration := time.Since(start)
+        c.Set("X-Response-Time", duration.String())
+        
+        return err
+    })
+}
+```
+
+## Error Handling
+
+```go
+func main() {
+    app := fiber.New(fiber.Config{
+        ErrorHandler: func(c *fiber.Ctx, err error) error {
+            code := fiber.StatusInternalServerError
+            
+            if e, ok := err.(*fiber.Error); ok {
+                code = e.Code
+            }
+            
+            return c.Status(code).JSON(fiber.Map{
+                "error": err.Error(),
+            })
+        },
+    })
+
+    app.Get("/user/:id", func(c *fiber.Ctx) error {
+        id := c.Params("id")
+        user, err := findUser(id)
+        if err != nil {
+            return fiber.NewError(fiber.StatusNotFound, "User not found")
+        }
+        return c.JSON(user)
+    })
+}
+```
+
+## Static Files and Templates
+
+```go
+// Static files
+app.Static("/", "./public")
+app.Static("/static", "./assets")
+
+// Templates
+app := fiber.New(fiber.Config{
+    Views: html.New("./views", ".html"),
+})
+
+app.Get("/", func(c *fiber.Ctx) error {
+    return c.Render("index", fiber.Map{
+        "Title": "Hello, World!",
+    })
+})
+```

package/rules/golang/gin-framework/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: Gin Framework
+description: High-performance Go web framework with martini-like API.
+metadata:
+  labels: [golang, gin, web, framework]
+  triggers:
+    files: ['**/main.go', '**/routes.go']
+    keywords: [gin, gin.Default, gin.Engine, c.JSON]
+---
+
+# Gin Framework Standards
+
+## Router Setup
+
+```go
+package main
+
+import (
+    "github.com/gin-gonic/gin"
+)
+
+func main() {
+    r := gin.Default() // Includes Logger and Recovery middleware
+
+    // Routes
+    r.GET("/ping", pingHandler)
+    r.POST("/users", createUser)
+
+    // Route groups
+    api := r.Group("/api/v1")
+    {
+        api.GET("/users", listUsers)
+        api.GET("/users/:id", getUser)
+        api.PUT("/users/:id", updateUser)
+        api.DELETE("/users/:id", deleteUser)
+    }
+
+    r.Run(":8080")
+}
+```
+
+## Handlers
+
+```go
+// Path parameters
+func getUser(c *gin.Context) {
+    id := c.Param("id")
+    user, err := findUser(id)
+    if err != nil {
+        c.JSON(404, gin.H{"error": "User not found"})
+        return
+    }
+    c.JSON(200, user)
+}
+
+// Query parameters
+func listUsers(c *gin.Context) {
+    page := c.DefaultQuery("page", "1")
+    limit := c.DefaultQuery("limit", "10")
+    users := fetchUsers(page, limit)
+    c.JSON(200, users)
+}
+
+// JSON body binding
+type CreateUserRequest struct {
+    Name  string `json:"name" binding:"required"`
+    Email string `json:"email" binding:"required,email"`
+}
+
+func createUser(c *gin.Context) {
+    var req CreateUserRequest
+    if err := c.ShouldBindJSON(&req); err != nil {
+        c.JSON(400, gin.H{"error": err.Error()})
+        return
+    }
+    user := insertUser(req)
+    c.JSON(201, user)
+}
+```
+
+## Binding & Validation
+
+```go
+type LoginRequest struct {
+    Username string `json:"username" binding:"required,min=3,max=50"`
+    Password string `json:"password" binding:"required,min=8"`
+}
+
+// Custom validation
+type BookingRequest struct {
+    CheckIn  time.Time `json:"check_in" binding:"required"`
+    CheckOut time.Time `json:"check_out" binding:"required,gtfield=CheckIn"`
+}
+
+// Bind from different sources
+c.ShouldBindJSON(&obj)    // JSON body
+c.ShouldBindQuery(&obj)   // Query string
+c.ShouldBind(&obj)        // Auto-detect
+```
+
+## Middleware
+
+```go
+// Global middleware
+r := gin.New()
+r.Use(gin.Logger())
+r.Use(gin.Recovery())
+r.Use(corsMiddleware())
+
+// Group middleware
+authorized := r.Group("/admin")
+authorized.Use(authMiddleware())
+
+// Custom middleware
+func authMiddleware() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        token := c.GetHeader("Authorization")
+        if token == "" {
+            c.AbortWithStatusJSON(401, gin.H{"error": "Unauthorized"})
+            return
+        }
+
+        user, err := validateToken(token)
+        if err != nil {
+            c.AbortWithStatusJSON(401, gin.H{"error": "Invalid token"})
+            return
+        }
+
+        c.Set("user", user)
+        c.Next()
+    }
+}
+
+// Access middleware data
+func handler(c *gin.Context) {
+    user, _ := c.Get("user")
+    // use user
+}
+```
+
+## Error Handling
+
+```go
+// Centralized error handling
+type AppError struct {
+    Code    int    `json:"code"`
+    Message string `json:"message"`
+}
+
+func errorMiddleware() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        c.Next()
+
+        if len(c.Errors) > 0 {
+            err := c.Errors.Last()
+            switch e := err.Err.(type) {
+            case *AppError:
+                c.JSON(e.Code, e)
+            default:
+                c.JSON(500, gin.H{"error": "Internal server error"})
+            }
+        }
+    }
+}
+
+// In handler
+func handler(c *gin.Context) {
+    if err := doSomething(); err != nil {
+        c.Error(&AppError{Code: 400, Message: err.Error()})
+        return
+    }
+}
+```
+
+## Dependency Injection
+
+```go
+type Handler struct {
+    db     *sql.DB
+    cache  *redis.Client
+    logger *zap.Logger
+}
+
+func NewHandler(db *sql.DB, cache *redis.Client, logger *zap.Logger) *Handler {
+    return &Handler{db: db, cache: cache, logger: logger}
+}
+
+func (h *Handler) GetUser(c *gin.Context) {
+    user, err := h.db.FindUser(c.Param("id"))
+    // ...
+}
+
+// Setup routes
+func SetupRoutes(r *gin.Engine, h *Handler) {
+    r.GET("/users/:id", h.GetUser)
+}
+```
+
+## Best Practices
+
+1. **Gin modes**: Use `gin.SetMode(gin.ReleaseMode)` in production
+2. **Graceful shutdown**: Implement with `http.Server` and context
+3. **Validation**: Use struct tags for input validation
+4. **Logging**: Replace default logger with structured logging (zap/zerolog)
+5. **Testing**: Use `httptest` with gin test mode

package/rules/golang/gin-framework/references/REFERENCE.md

@@ -0,0 +1,14 @@
+# Gin Framework References
+
+## References
+
+- [**Middleware Patterns**](middleware-patterns.md) - Auth, logging, recovery, CORS
+- [**Handler Patterns**](handler-patterns.md) - Request handling, validation, responses
+
+## Quick Checks
+
+- [ ] Use middleware for cross-cutting concerns
+- [ ] Validate input with binding tags
+- [ ] Consistent error response format
+- [ ] Group routes logically
+- [ ] Use gin.Context for request lifecycle

package/rules/golang/gin-framework/references/middleware-patterns.md

@@ -0,0 +1,119 @@
+# Middleware Patterns
+
+## Authentication Middleware
+
+```go
+func AuthMiddleware(jwtService *JWTService) gin.HandlerFunc {
+    return func(c *gin.Context) {
+        authHeader := c.GetHeader("Authorization")
+        if authHeader == "" {
+            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+                "error": "missing authorization header",
+            })
+            return
+        }
+
+        tokenString := strings.TrimPrefix(authHeader, "Bearer ")
+        claims, err := jwtService.ValidateToken(tokenString)
+        if err != nil {
+            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+                "error": "invalid token",
+            })
+            return
+        }
+
+        c.Set("user_id", claims.UserID)
+        c.Set("user_role", claims.Role)
+        c.Next()
+    }
+}
+
+// Usage
+api := r.Group("/api")
+api.Use(AuthMiddleware(jwtService))
+```
+
+## Logging Middleware
+
+```go
+func LoggingMiddleware(logger *zap.Logger) gin.HandlerFunc {
+    return func(c *gin.Context) {
+        start := time.Now()
+        path := c.Request.URL.Path
+        query := c.Request.URL.RawQuery
+
+        c.Next()
+
+        latency := time.Since(start)
+        status := c.Writer.Status()
+
+        logger.Info("request",
+            zap.String("method", c.Request.Method),
+            zap.String("path", path),
+            zap.String("query", query),
+            zap.Int("status", status),
+            zap.Duration("latency", latency),
+            zap.String("client_ip", c.ClientIP()),
+        )
+    }
+}
+```
+
+## Recovery Middleware
+
+```go
+func RecoveryMiddleware(logger *zap.Logger) gin.HandlerFunc {
+    return func(c *gin.Context) {
+        defer func() {
+            if err := recover(); err != nil {
+                logger.Error("panic recovered",
+                    zap.Any("error", err),
+                    zap.String("stack", string(debug.Stack())),
+                )
+                c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
+                    "error": "internal server error",
+                })
+            }
+        }()
+        c.Next()
+    }
+}
+```
+
+## CORS Middleware
+
+```go
+func CORSMiddleware() gin.HandlerFunc {
+    return func(c *gin.Context) {
+        c.Header("Access-Control-Allow-Origin", "*")
+        c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+        c.Header("Access-Control-Allow-Headers", "Origin, Content-Type, Authorization")
+        c.Header("Access-Control-Max-Age", "86400")
+
+        if c.Request.Method == "OPTIONS" {
+            c.AbortWithStatus(http.StatusNoContent)
+            return
+        }
+
+        c.Next()
+    }
+}
+```
+
+## Rate Limiting
+
+```go
+func RateLimitMiddleware(rps int) gin.HandlerFunc {
+    limiter := rate.NewLimiter(rate.Limit(rps), rps)
+
+    return func(c *gin.Context) {
+        if !limiter.Allow() {
+            c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
+                "error": "rate limit exceeded",
+            })
+            return
+        }
+        c.Next()
+    }
+}
+```