autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/echo.md

@@ -0,0 +1,321 @@
+# Echo Framework Skill
+
+## Application Setup
+\`\`\`go
+package main
+
+import (
+    "net/http"
+    "os"
+
+    "github.com/labstack/echo/v4"
+    "github.com/labstack/echo/v4/middleware"
+)
+
+func main() {
+    e := echo.New()
+
+    // Hide banner in production
+    e.HideBanner = os.Getenv("ENV") == "production"
+
+    // Global middleware
+    e.Use(middleware.Logger())
+    e.Use(middleware.Recover())
+    e.Use(middleware.RequestID())
+    e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
+        AllowOrigins: []string{"*"},
+        AllowMethods: []string{http.MethodGet, http.MethodPost, http.MethodPut, http.MethodDelete},
+        AllowHeaders: []string{echo.HeaderAuthorization, echo.HeaderContentType},
+    }))
+
+    // Custom error handler
+    e.HTTPErrorHandler = customErrorHandler
+
+    // Health check
+    e.GET("/health", func(c echo.Context) error {
+        return c.JSON(http.StatusOK, map[string]string{"status": "ok"})
+    })
+
+    setupRoutes(e)
+
+    e.Logger.Fatal(e.Start(":8080"))
+}
+\`\`\`
+
+## Route Groups
+\`\`\`go
+func setupRoutes(e *echo.Echo) {
+    api := e.Group("/api/v1")
+
+    // Public routes
+    auth := api.Group("/auth")
+    auth.POST("/login", loginHandler)
+    auth.POST("/register", registerHandler)
+
+    // Protected routes
+    protected := api.Group("")
+    protected.Use(AuthMiddleware)
+
+    // Users
+    users := protected.Group("/users")
+    users.GET("", listUsersHandler)
+    users.GET("/:id", getUserHandler)
+    users.PUT("/:id", updateUserHandler)
+    users.DELETE("/:id", deleteUserHandler)
+
+    // Posts with rate limiting
+    posts := protected.Group("/posts")
+    posts.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(10)))
+    posts.GET("", listPostsHandler)
+    posts.POST("", createPostHandler)
+}
+\`\`\`
+
+## Request Binding and Validation
+\`\`\`go
+import "github.com/go-playground/validator/v10"
+
+// Custom validator
+type CustomValidator struct {
+    validator *validator.Validate
+}
+
+func (cv *CustomValidator) Validate(i interface{}) error {
+    if err := cv.validator.Struct(i); err != nil {
+        return echo.NewHTTPError(http.StatusBadRequest, formatValidationErrors(err))
+    }
+    return nil
+}
+
+// Register validator
+func main() {
+    e := echo.New()
+    e.Validator = &CustomValidator{validator: validator.New()}
+    // ...
+}
+
+// Request DTOs
+type CreateUserRequest struct {
+    Email    string \`json:"email" validate:"required,email"\`
+    Name     string \`json:"name" validate:"required,min=2,max=100"\`
+    Password string \`json:"password" validate:"required,min=8"\`
+}
+
+type QueryParams struct {
+    Page    int    \`query:"page" validate:"omitempty,min=1"\`
+    PerPage int    \`query:"per_page" validate:"omitempty,min=1,max=100"\`
+    Sort    string \`query:"sort" validate:"omitempty,oneof=asc desc"\`
+}
+
+func createUserHandler(c echo.Context) error {
+    var req CreateUserRequest
+    if err := c.Bind(&req); err != nil {
+        return echo.NewHTTPError(http.StatusBadRequest, "invalid request body")
+    }
+    if err := c.Validate(&req); err != nil {
+        return err  // Already formatted by custom validator
+    }
+
+    user, err := userService.Create(c.Request().Context(), req)
+    if err != nil {
+        return err
+    }
+
+    return c.JSON(http.StatusCreated, user)
+}
+
+func listUsersHandler(c echo.Context) error {
+    var query QueryParams
+    if err := c.Bind(&query); err != nil {
+        return echo.NewHTTPError(http.StatusBadRequest, "invalid query parameters")
+    }
+
+    // Defaults
+    if query.Page == 0 {
+        query.Page = 1
+    }
+    if query.PerPage == 0 {
+        query.PerPage = 20
+    }
+
+    users, total, err := userService.List(c.Request().Context(), query)
+    if err != nil {
+        return err
+    }
+
+    return c.JSON(http.StatusOK, map[string]interface{}{
+        "data":     users,
+        "total":    total,
+        "page":     query.Page,
+        "per_page": query.PerPage,
+    })
+}
+\`\`\`
+
+## Custom Middleware
+\`\`\`go
+// Auth Middleware
+func AuthMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
+    return func(c echo.Context) error {
+        authHeader := c.Request().Header.Get("Authorization")
+        if authHeader == "" {
+            return echo.NewHTTPError(http.StatusUnauthorized, "missing authorization header")
+        }
+
+        tokenString := strings.TrimPrefix(authHeader, "Bearer ")
+        claims, err := validateToken(tokenString)
+        if err != nil {
+            return echo.NewHTTPError(http.StatusUnauthorized, "invalid token")
+        }
+
+        // Store in context
+        c.Set("userID", claims.UserID)
+        c.Set("userRole", claims.Role)
+
+        return next(c)
+    }
+}
+
+// Using Echo's JWT middleware
+import "github.com/labstack/echo-jwt/v4"
+
+func setupJWTMiddleware() echo.MiddlewareFunc {
+    return echojwt.WithConfig(echojwt.Config{
+        SigningKey: []byte(os.Getenv("JWT_SECRET")),
+        NewClaimsFunc: func(c echo.Context) jwt.Claims {
+            return new(CustomClaims)
+        },
+        SuccessHandler: func(c echo.Context) {
+            token := c.Get("user").(*jwt.Token)
+            claims := token.Claims.(*CustomClaims)
+            c.Set("userID", claims.UserID)
+        },
+    })
+}
+
+// Skipper for selective middleware
+func AuthSkipper(c echo.Context) bool {
+    // Skip auth for public routes
+    return strings.HasPrefix(c.Path(), "/api/v1/auth")
+}
+\`\`\`
+
+## Error Handling
+\`\`\`go
+func customErrorHandler(err error, c echo.Context) {
+    var (
+        code    = http.StatusInternalServerError
+        message = "internal server error"
+    )
+
+    // Check for echo.HTTPError
+    var he *echo.HTTPError
+    if errors.As(err, &he) {
+        code = he.Code
+        if m, ok := he.Message.(string); ok {
+            message = m
+        }
+    }
+
+    // Check for custom errors
+    switch {
+    case errors.Is(err, ErrNotFound):
+        code = http.StatusNotFound
+        message = "resource not found"
+    case errors.Is(err, ErrUnauthorized):
+        code = http.StatusUnauthorized
+        message = "unauthorized"
+    case errors.Is(err, ErrForbidden):
+        code = http.StatusForbidden
+        message = "forbidden"
+    }
+
+    // Log internal errors
+    if code == http.StatusInternalServerError {
+        c.Logger().Error(err)
+    }
+
+    // Send response (check if already committed)
+    if !c.Response().Committed {
+        c.JSON(code, map[string]string{"error": message})
+    }
+}
+\`\`\`
+
+## Testing
+\`\`\`go
+package handler_test
+
+import (
+    "bytes"
+    "encoding/json"
+    "net/http"
+    "net/http/httptest"
+    "testing"
+
+    "github.com/labstack/echo/v4"
+    "github.com/stretchr/testify/assert"
+)
+
+func setupTestEcho() *echo.Echo {
+    e := echo.New()
+    e.Validator = &CustomValidator{validator: validator.New()}
+    e.HTTPErrorHandler = customErrorHandler
+    setupRoutes(e)
+    return e
+}
+
+func TestCreateUser(t *testing.T) {
+    e := setupTestEcho()
+
+    tests := []struct {
+        name       string
+        body       map[string]interface{}
+        wantStatus int
+    }{
+        {
+            name: "valid user",
+            body: map[string]interface{}{
+                "email":    "test@example.com",
+                "name":     "Test User",
+                "password": "password123",
+            },
+            wantStatus: http.StatusCreated,
+        },
+        {
+            name: "missing email",
+            body: map[string]interface{}{
+                "name":     "Test User",
+                "password": "password123",
+            },
+            wantStatus: http.StatusBadRequest,
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            body, _ := json.Marshal(tt.body)
+            req := httptest.NewRequest(http.MethodPost, "/api/v1/users", bytes.NewBuffer(body))
+            req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+            rec := httptest.NewRecorder()
+
+            e.ServeHTTP(rec, req)
+
+            assert.Equal(t, tt.wantStatus, rec.Code)
+        })
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Register a custom validator with \`e.Validator\`
+- Use \`c.Request().Context()\` for passing context to services
+- Use built-in middleware (Logger, Recover, RequestID, CORS)
+- Implement custom HTTPErrorHandler for consistent error responses
+- Use \`echo.NewHTTPError\` for HTTP errors
+
+## ❌ DON'T
+- Don't forget to register validator before using \`c.Validate()\`
+- Don't write response after calling \`next(c)\` in middleware
+- Don't ignore \`c.Response().Committed\` in error handler
+- Don't use \`c.String()\` for JSON responses - use \`c.JSON()\`

package/.claude/skills/eloquent.md

@@ -0,0 +1,256 @@
+# Eloquent ORM Skill
+
+## Model Definition
+\`\`\`php
+<?php
+
+namespace App\\Models;
+
+use Illuminate\\Database\\Eloquent\\{Model, SoftDeletes, Factories\\HasFactory};
+use Illuminate\\Database\\Eloquent\\Casts\\Attribute;
+use Illuminate\\Database\\Eloquent\\Relations\\{HasMany, BelongsTo, BelongsToMany};
+
+class User extends Model
+{
+    use HasFactory, SoftDeletes;
+
+    protected $fillable = ['email', 'name', 'status'];
+    protected $hidden = ['password', 'remember_token'];
+    protected $casts = [
+        'email_verified_at' => 'datetime',
+        'settings' => 'array',
+        'is_admin' => 'boolean',
+    ];
+
+    // Relationships
+    public function posts(): HasMany
+    {
+        return $this->hasMany(Post::class);
+    }
+
+    public function team(): BelongsTo
+    {
+        return $this->belongsTo(Team::class);
+    }
+
+    public function roles(): BelongsToMany
+    {
+        return $this->belongsToMany(Role::class)->withTimestamps();
+    }
+}
+\`\`\`
+
+## Accessors & Mutators (Laravel 9+)
+\`\`\`php
+class User extends Model
+{
+    // Accessor: $user->full_name
+    protected function fullName(): Attribute
+    {
+        return Attribute::make(
+            get: fn () => "{$this->first_name} {$this->last_name}",
+        );
+    }
+
+    // Mutator: $user->password = 'secret'
+    protected function password(): Attribute
+    {
+        return Attribute::make(
+            set: fn (string $value) => bcrypt($value),
+        );
+    }
+
+    // Accessor with caching
+    protected function postsCount(): Attribute
+    {
+        return Attribute::make(
+            get: fn () => $this->posts()->count(),
+        )->shouldCache();
+    }
+}
+\`\`\`
+
+## Query Scopes
+\`\`\`php
+class User extends Model
+{
+    // Local scope: User::active()->get()
+    public function scopeActive(Builder $query): Builder
+    {
+        return $query->where('status', 'active');
+    }
+
+    // Dynamic scope: User::ofType('admin')->get()
+    public function scopeOfType(Builder $query, string $type): Builder
+    {
+        return $query->where('type', $type);
+    }
+
+    // Chainable: User::active()->ofType('admin')->recent()->get()
+    public function scopeRecent(Builder $query): Builder
+    {
+        return $query->orderBy('created_at', 'desc');
+    }
+}
+
+// Global Scope (always applied)
+class ActiveScope implements Scope
+{
+    public function apply(Builder $builder, Model $model): void
+    {
+        $builder->where('deleted_at', null);
+    }
+}
+
+// In model boot method
+protected static function booted(): void
+{
+    static::addGlobalScope(new ActiveScope);
+
+    // Or inline
+    static::addGlobalScope('active', fn (Builder $builder) =>
+        $builder->where('is_active', true)
+    );
+}
+\`\`\`
+
+## Query Patterns
+\`\`\`php
+// Eager loading (prevent N+1)
+$users = User::with(['posts', 'team'])->get();
+
+// Nested eager loading
+$users = User::with(['posts.comments', 'posts.tags'])->get();
+
+// Conditional eager loading
+$users = User::with(['posts' => fn ($query) =>
+    $query->where('published', true)->latest()
+])->get();
+
+// Lazy eager loading
+$users = User::all();
+$users->load('posts'); // Load after initial query
+
+// Chunk for large datasets
+User::chunk(100, function ($users) {
+    foreach ($users as $user) {
+        // Process each user
+    }
+});
+
+// Cursor for memory efficiency
+foreach (User::cursor() as $user) {
+    // One model at a time in memory
+}
+
+// Aggregations
+$count = User::where('status', 'active')->count();
+$avg = Order::where('user_id', $id)->avg('total');
+$exists = User::where('email', $email)->exists();
+\`\`\`
+
+## Eloquent Collections
+\`\`\`php
+$users = User::all();
+
+// Filter
+$active = $users->where('status', 'active');
+$admins = $users->filter(fn ($user) => $user->isAdmin());
+
+// Transform
+$emails = $users->pluck('email');
+$grouped = $users->groupBy('team_id');
+$keyed = $users->keyBy('id');
+
+// Aggregate
+$first = $users->first();
+$unique = $users->unique('email');
+$sorted = $users->sortBy('name');
+\`\`\`
+
+## Model Events & Observers
+\`\`\`php
+// Using closures in boot
+protected static function booted(): void
+{
+    static::creating(function (User $user) {
+        $user->uuid = Str::uuid();
+    });
+
+    static::deleting(function (User $user) {
+        $user->posts()->delete();
+    });
+}
+
+// Observer class (php artisan make:observer UserObserver --model=User)
+class UserObserver
+{
+    public function created(User $user): void
+    {
+        Mail::to($user)->send(new WelcomeEmail($user));
+    }
+
+    public function updating(User $user): void
+    {
+        if ($user->isDirty('email')) {
+            $user->email_verified_at = null;
+        }
+    }
+}
+
+// Register in AppServiceProvider
+User::observe(UserObserver::class);
+\`\`\`
+
+## Factories & Seeders
+\`\`\`php
+// database/factories/UserFactory.php
+class UserFactory extends Factory
+{
+    public function definition(): array
+    {
+        return [
+            'name' => fake()->name(),
+            'email' => fake()->unique()->safeEmail(),
+            'password' => bcrypt('password'),
+        ];
+    }
+
+    // States for variations
+    public function admin(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'is_admin' => true,
+        ]);
+    }
+
+    public function withPosts(int $count = 3): static
+    {
+        return $this->has(Post::factory()->count($count));
+    }
+}
+
+// Usage
+$user = User::factory()->create();
+$admin = User::factory()->admin()->create();
+$userWithPosts = User::factory()->withPosts(5)->create();
+User::factory()->count(50)->create();
+\`\`\`
+
+## ❌ DON'T
+- Use \`User::all()\` without limits on large tables
+- Forget to eager load relations (N+1 problem)
+- Put business logic in Eloquent models
+- Use \`$model->save()\` without checking return value
+- Store sensitive data without encryption
+- Use raw queries without parameter binding
+
+## ✅ DO
+- Always eager load known relations
+- Use chunks or cursors for large datasets
+- Implement soft deletes for important data
+- Use casts for automatic type conversion
+- Define inverse relationships
+- Use scopes for reusable query logic
+- Use observers for side effects
+- Use factories for testing