@ngxtm/devkit 3.4.0 → 3.4.1

package/rules/golang/ent-orm/SKILL.md

@@ -0,0 +1,239 @@
+---
+name: Ent ORM
+description: Facebook's entity framework for Go with code generation.
+metadata:
+  labels: [golang, ent, orm, database]
+  triggers:
+    files: ['ent/schema/*.go', 'ent/generate.go']
+    keywords: [ent, entgo, schema, Field, Edge]
+---
+
+# Ent ORM Standards
+
+## Schema Definition
+
+```go
+// ent/schema/user.go
+package schema
+
+import (
+    "entgo.io/ent"
+    "entgo.io/ent/schema/field"
+    "entgo.io/ent/schema/edge"
+)
+
+type User struct {
+    ent.Schema
+}
+
+func (User) Fields() []ent.Field {
+    return []ent.Field{
+        field.String("name").NotEmpty(),
+        field.String("email").Unique(),
+        field.Int("age").Positive().Optional(),
+        field.Time("created_at").Default(time.Now),
+        field.Enum("role").Values("admin", "user").Default("user"),
+    }
+}
+
+func (User) Edges() []ent.Edge {
+    return []ent.Edge{
+        edge.To("posts", Post.Type),
+        edge.To("groups", Group.Type),
+    }
+}
+```
+
+## Code Generation
+
+```bash
+# Install
+go install entgo.io/ent/cmd/ent@latest
+
+# Generate
+go generate ./ent
+
+# New schema
+ent new User
+ent new Post
+```
+
+```go
+// ent/generate.go
+//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate ./schema
+package ent
+```
+
+## CRUD Operations
+
+```go
+// Create
+user, err := client.User.
+    Create().
+    SetName("John").
+    SetEmail("john@example.com").
+    Save(ctx)
+
+// Create bulk
+users, err := client.User.
+    CreateBulk(
+        client.User.Create().SetName("A").SetEmail("a@x.com"),
+        client.User.Create().SetName("B").SetEmail("b@x.com"),
+    ).
+    Save(ctx)
+
+// Read
+user, err := client.User.Get(ctx, id)
+user, err := client.User.Query().
+    Where(user.Email("john@example.com")).
+    Only(ctx)
+
+// Update
+user, err := client.User.
+    UpdateOneID(id).
+    SetName("Jane").
+    Save(ctx)
+
+// Delete
+err := client.User.DeleteOneID(id).Exec(ctx)
+```
+
+## Queries
+
+```go
+// Filter
+users, err := client.User.Query().
+    Where(
+        user.AgeGT(18),
+        user.RoleEQ(user.RoleAdmin),
+    ).
+    All(ctx)
+
+// Or conditions
+users, err := client.User.Query().
+    Where(
+        user.Or(
+            user.RoleEQ(user.RoleAdmin),
+            user.AgeGT(30),
+        ),
+    ).
+    All(ctx)
+
+// Order and limit
+users, err := client.User.Query().
+    Order(ent.Desc(user.FieldCreatedAt)).
+    Limit(10).
+    Offset(20).
+    All(ctx)
+
+// Select specific fields
+names, err := client.User.Query().
+    Select(user.FieldName).
+    Strings(ctx)
+```
+
+## Edges (Relations)
+
+```go
+// Schema with edges
+func (Post) Edges() []ent.Edge {
+    return []ent.Edge{
+        edge.From("author", User.Type).
+            Ref("posts").
+            Unique().
+            Required(),
+    }
+}
+
+// Query with edges
+posts, err := client.User.Query().
+    Where(user.ID(id)).
+    QueryPosts().
+    All(ctx)
+
+// Eager loading
+users, err := client.User.Query().
+    WithPosts().
+    WithGroups().
+    All(ctx)
+
+for _, u := range users {
+    for _, p := range u.Edges.Posts {
+        fmt.Println(p.Title)
+    }
+}
+```
+
+## Transactions
+
+```go
+tx, err := client.Tx(ctx)
+if err != nil {
+    return err
+}
+defer tx.Rollback()
+
+user, err := tx.User.Create().
+    SetName("John").
+    Save(ctx)
+if err != nil {
+    return err
+}
+
+_, err = tx.Post.Create().
+    SetTitle("First Post").
+    SetAuthor(user).
+    Save(ctx)
+if err != nil {
+    return err
+}
+
+return tx.Commit()
+```
+
+## Hooks
+
+```go
+func (User) Hooks() []ent.Hook {
+    return []ent.Hook{
+        hook.On(
+            func(next ent.Mutator) ent.Mutator {
+                return hook.UserFunc(func(ctx context.Context, m *ent.UserMutation) (ent.Value, error) {
+                    // Before create/update
+                    if name, ok := m.Name(); ok {
+                        m.SetName(strings.TrimSpace(name))
+                    }
+                    return next.Mutate(ctx, m)
+                })
+            },
+            ent.OpCreate|ent.OpUpdate,
+        ),
+    }
+}
+```
+
+## Migrations
+
+```go
+// Auto migration (development)
+if err := client.Schema.Create(ctx); err != nil {
+    log.Fatalf("failed creating schema: %v", err)
+}
+
+// With options
+err := client.Schema.Create(ctx,
+    migrate.WithDropIndex(true),
+    migrate.WithDropColumn(true),
+)
+
+// Versioned migrations (production)
+// Use Atlas: https://atlasgo.io/
+```
+
+## Best Practices
+
+1. **Code generation**: Run `go generate` after schema changes
+2. **Edges**: Define both sides of relationships
+3. **Transactions**: Use for related operations
+4. **Hooks**: For validation, normalization
+5. **Migrations**: Use Atlas for production

package/rules/golang/ent-orm/references/REFERENCE.md

@@ -0,0 +1,13 @@
+# Ent ORM References
+
+## References
+
+- [**Schema Patterns**](schema-patterns.md) - Entity definitions, edges, hooks
+
+## Quick Checks
+
+- [ ] Code-generated type-safe API
+- [ ] Define schemas with ent CLI
+- [ ] Edges for relationships
+- [ ] Privacy policies for access control
+- [ ] Hooks for side effects

package/rules/golang/ent-orm/references/schema-patterns.md

@@ -0,0 +1,255 @@
+# Ent Schema Patterns
+
+## Schema Definition
+
+```go
+// ent/schema/user.go
+package schema
+
+import (
+    "time"
+    "entgo.io/ent"
+    "entgo.io/ent/schema/field"
+    "entgo.io/ent/schema/edge"
+    "entgo.io/ent/schema/index"
+)
+
+type User struct {
+    ent.Schema
+}
+
+func (User) Fields() []ent.Field {
+    return []ent.Field{
+        field.String("name").
+            NotEmpty().
+            MaxLen(100),
+        field.String("email").
+            Unique(),
+        field.Int("age").
+            Positive().
+            Optional(),
+        field.Bool("active").
+            Default(true),
+        field.Enum("role").
+            Values("admin", "user", "guest").
+            Default("user"),
+        field.Time("created_at").
+            Default(time.Now).
+            Immutable(),
+        field.Time("updated_at").
+            Default(time.Now).
+            UpdateDefault(time.Now),
+    }
+}
+
+func (User) Edges() []ent.Edge {
+    return []ent.Edge{
+        // One-to-many: User has many Posts
+        edge.To("posts", Post.Type),
+        // Many-to-many: User has many Groups
+        edge.To("groups", Group.Type),
+        // Inverse edge: User belongs to a Company
+        edge.From("company", Company.Type).
+            Ref("employees").
+            Unique(),
+    }
+}
+
+func (User) Indexes() []ent.Index {
+    return []ent.Index{
+        index.Fields("email").Unique(),
+        index.Fields("name", "created_at"),
+    }
+}
+```
+
+## Edge Definitions
+
+```go
+// Post schema
+type Post struct {
+    ent.Schema
+}
+
+func (Post) Fields() []ent.Field {
+    return []ent.Field{
+        field.String("title"),
+        field.Text("content"),
+    }
+}
+
+func (Post) Edges() []ent.Edge {
+    return []ent.Edge{
+        // Inverse of User.posts
+        edge.From("author", User.Type).
+            Ref("posts").
+            Unique().
+            Required(),
+        // Self-referential: parent comment
+        edge.To("children", Post.Type).
+            From("parent").
+            Unique(),
+    }
+}
+```
+
+## CRUD Operations
+
+```go
+import "myapp/ent"
+
+func main() {
+    client, _ := ent.Open("postgres", "...")
+    defer client.Close()
+    ctx := context.Background()
+
+    // Create
+    user, err := client.User.
+        Create().
+        SetName("John").
+        SetEmail("john@example.com").
+        SetAge(30).
+        Save(ctx)
+
+    // Create with edges
+    post, _ := client.Post.
+        Create().
+        SetTitle("Hello").
+        SetContent("World").
+        SetAuthor(user).
+        Save(ctx)
+
+    // Read
+    user, _ = client.User.Get(ctx, 1)
+    user, _ = client.User.
+        Query().
+        Where(user.EmailEQ("john@example.com")).
+        Only(ctx)
+
+    // Update
+    user, _ = client.User.
+        UpdateOne(user).
+        SetAge(31).
+        Save(ctx)
+
+    // Bulk update
+    affected, _ := client.User.
+        Update().
+        Where(user.AgeGT(18)).
+        SetActive(true).
+        Save(ctx)
+
+    // Delete
+    client.User.DeleteOne(user).Exec(ctx)
+}
+```
+
+## Queries
+
+```go
+// Eager loading edges
+users, _ := client.User.
+    Query().
+    WithPosts().
+    WithGroups().
+    All(ctx)
+
+for _, u := range users {
+    for _, p := range u.Edges.Posts {
+        fmt.Println(p.Title)
+    }
+}
+
+// Complex queries
+users, _ := client.User.
+    Query().
+    Where(
+        user.And(
+            user.AgeGTE(18),
+            user.ActiveEQ(true),
+        ),
+    ).
+    Order(ent.Desc(user.FieldCreatedAt)).
+    Limit(10).
+    Offset(0).
+    All(ctx)
+
+// Aggregations
+count, _ := client.User.
+    Query().
+    Where(user.ActiveEQ(true)).
+    Count(ctx)
+
+// Select specific fields
+var v []struct {
+    Name  string `json:"name"`
+    Email string `json:"email"`
+}
+client.User.
+    Query().
+    Select(user.FieldName, user.FieldEmail).
+    Scan(ctx, &v)
+```
+
+## Hooks
+
+```go
+func (User) Hooks() []ent.Hook {
+    return []ent.Hook{
+        // Before create/update
+        hook.On(
+            func(next ent.Mutator) ent.Mutator {
+                return hook.UserFunc(func(ctx context.Context, m *ent.UserMutation) (ent.Value, error) {
+                    // Validate or modify
+                    if name, ok := m.Name(); ok && name == "" {
+                        return nil, errors.New("name cannot be empty")
+                    }
+                    return next.Mutate(ctx, m)
+                })
+            },
+            ent.OpCreate|ent.OpUpdate,
+        ),
+    }
+}
+```
+
+## Transactions
+
+```go
+tx, err := client.Tx(ctx)
+if err != nil {
+    return err
+}
+
+user, err := tx.User.Create().
+    SetName("John").
+    Save(ctx)
+if err != nil {
+    tx.Rollback()
+    return err
+}
+
+_, err = tx.Post.Create().
+    SetTitle("First Post").
+    SetAuthor(user).
+    Save(ctx)
+if err != nil {
+    tx.Rollback()
+    return err
+}
+
+return tx.Commit()
+```
+
+## Generate Commands
+
+```bash
+# Initialize ent
+go run -mod=mod entgo.io/ent/cmd/ent new User
+
+# Generate code
+go generate ./ent
+
+# With features
+go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/upsert ./ent/schema
+```

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

@@ -0,0 +1,196 @@
+---
+name: Fiber Framework
+description: Express-inspired Go web framework built on fasthttp.
+metadata:
+  labels: [golang, fiber, web, framework, fasthttp]
+  triggers:
+    files: ['**/main.go']
+    keywords: [fiber, fiber.New, fiber.Ctx, app.Listen]
+---
+
+# Fiber Framework Standards
+
+## Application Setup
+
+```go
+package main
+
+import (
+    "github.com/gofiber/fiber/v2"
+    "github.com/gofiber/fiber/v2/middleware/logger"
+    "github.com/gofiber/fiber/v2/middleware/recover"
+)
+
+func main() {
+    app := fiber.New(fiber.Config{
+        ErrorHandler: customErrorHandler,
+        ReadTimeout:  10 * time.Second,
+        WriteTimeout: 10 * time.Second,
+    })
+
+    // Middleware
+    app.Use(logger.New())
+    app.Use(recover.New())
+
+    // Routes
+    app.Get("/", homeHandler)
+    app.Get("/users/:id", getUser)
+    app.Post("/users", createUser)
+
+    // Route groups
+    api := app.Group("/api/v1")
+    api.Get("/items", listItems)
+
+    app.Listen(":3000")
+}
+```
+
+## Handlers
+
+```go
+// Path parameters
+func getUser(c *fiber.Ctx) error {
+    id := c.Params("id")
+    user, err := findUser(id)
+    if err != nil {
+        return c.Status(404).JSON(fiber.Map{"error": "Not found"})
+    }
+    return c.JSON(user)
+}
+
+// Query parameters
+func listUsers(c *fiber.Ctx) error {
+    page := c.QueryInt("page", 1)
+    limit := c.QueryInt("limit", 10)
+    users := fetchUsers(page, limit)
+    return c.JSON(users)
+}
+
+// JSON body
+type CreateUserRequest struct {
+    Name  string `json:"name"`
+    Email string `json:"email"`
+}
+
+func createUser(c *fiber.Ctx) error {
+    var req CreateUserRequest
+    if err := c.BodyParser(&req); err != nil {
+        return c.Status(400).JSON(fiber.Map{"error": "Invalid request"})
+    }
+    user := insertUser(req)
+    return c.Status(201).JSON(user)
+}
+```
+
+## Middleware
+
+```go
+// Built-in middleware
+app.Use(logger.New())
+app.Use(recover.New())
+app.Use(cors.New())
+app.Use(compress.New())
+app.Use(limiter.New(limiter.Config{
+    Max:        100,
+    Expiration: 1 * time.Minute,
+}))
+
+// Custom middleware
+func authMiddleware(c *fiber.Ctx) error {
+    token := c.Get("Authorization")
+    if token == "" {
+        return c.Status(401).JSON(fiber.Map{"error": "Unauthorized"})
+    }
+
+    user, err := validateToken(token)
+    if err != nil {
+        return c.Status(401).JSON(fiber.Map{"error": "Invalid token"})
+    }
+
+    c.Locals("user", user)
+    return c.Next()
+}
+
+// Apply middleware
+api := app.Group("/api", authMiddleware)
+```
+
+## Error Handling
+
+```go
+// Custom error handler
+func customErrorHandler(c *fiber.Ctx, err error) error {
+    code := fiber.StatusInternalServerError
+    message := "Internal Server Error"
+
+    if e, ok := err.(*fiber.Error); ok {
+        code = e.Code
+        message = e.Message
+    }
+
+    return c.Status(code).JSON(fiber.Map{
+        "error": message,
+    })
+}
+
+// In handlers, return fiber.Error
+func handler(c *fiber.Ctx) error {
+    if notFound {
+        return fiber.NewError(404, "Resource not found")
+    }
+    return c.JSON(data)
+}
+```
+
+## Validation
+
+```go
+import "github.com/go-playground/validator/v10"
+
+var validate = validator.New()
+
+type CreateItemRequest struct {
+    Name  string `json:"name" validate:"required,min=1,max=100"`
+    Price int    `json:"price" validate:"required,min=0"`
+}
+
+func createItem(c *fiber.Ctx) error {
+    var req CreateItemRequest
+    if err := c.BodyParser(&req); err != nil {
+        return c.Status(400).JSON(fiber.Map{"error": "Invalid JSON"})
+    }
+
+    if err := validate.Struct(&req); err != nil {
+        return c.Status(400).JSON(fiber.Map{"error": err.Error()})
+    }
+
+    item := insertItem(req)
+    return c.Status(201).JSON(item)
+}
+```
+
+## WebSocket Support
+
+```go
+import "github.com/gofiber/websocket/v2"
+
+app.Get("/ws", websocket.New(func(c *websocket.Conn) {
+    for {
+        mt, msg, err := c.ReadMessage()
+        if err != nil {
+            break
+        }
+        if err := c.WriteMessage(mt, msg); err != nil {
+            break
+        }
+    }
+}))
+```
+
+## Best Practices
+
+1. **fasthttp awareness**: Fiber uses fasthttp, not net/http - some incompatibilities
+2. **Context reuse**: Don't store `*fiber.Ctx` - it's reused across requests
+3. **Prefork**: Use `app.Listen(":3000", fiber.Config{Prefork: true})` for multi-core
+4. **Graceful shutdown**: Use `app.ShutdownWithTimeout(30 * time.Second)`
+5. **Memory**: fasthttp is optimized for low memory, high concurrency

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

@@ -0,0 +1,13 @@
+# Fiber Framework References
+
+## References
+
+- [**Routing Patterns**](routing-patterns.md) - Routes, middleware, groups
+
+## Quick Checks
+
+- [ ] Use route groups for organization
+- [ ] Built-in middleware for common tasks
+- [ ] fiber.Ctx for request/response handling
+- [ ] Prefork for multi-process mode
+- [ ] Zero allocation router