# config.yaml
extensions:
  database:
    type: postgres
    dsn: "postgres://user:pass@localhost/myapp"
    max_open_conns: 25
    max_idle_conns: 5
    conn_max_lifetime: "5m"
  
  cache:
    type: redis
    addr: "localhost:6379"
    db: 0
    pool_size: 10
    dial_timeout: "5s"
  
  queue:
    type: rabbitmq
    url: "amqp://guest:guest@localhost:5672/"
    exchange: "myapp.events"
    max_retries: 3
  
  auth:
    type: jwt
    secret: "${JWT_SECRET}"
    expiry: "24h"
    refresh_expiry: "7d"
  
  storage:
    type: s3
    bucket: "myapp-storage"
    region: "us-west-2"
    access_key: "${AWS_ACCESS_KEY}"
    secret_key: "${AWS_SECRET_KEY}"

package main

import (
    "context"
    "log"

    "github.com/xraph/forge"
    "github.com/xraph/forge/extensions/database"
    "github.com/xraph/forge/extensions/cache"
    "github.com/xraph/forge/extensions/queue"
    "github.com/xraph/forge/extensions/auth"
    "github.com/xraph/forge/extensions/storage"
)

func main() {
    app := forge.New()

    // Register core extensions
    app.RegisterExtension(database.New())
    app.RegisterExtension(cache.New())
    app.RegisterExtension(queue.New())
    app.RegisterExtension(auth.New())
    app.RegisterExtension(storage.New())

    // Define routes
    app.GET("/users/:id", getUserHandler)
    app.POST("/users", createUserHandler)

    // Start the application
    if err := app.Run(); err != nil {
        log.Fatal(err)
    }
}

func getUserHandler(c forge.Context) error {
    userID := c.Param("id")
    
    // Try cache first
    cache := forge.GetCache(c)
    if userData, err := cache.Get(c.Context(), "user:"+userID); err == nil {
        return c.JSON(200, userData)
    }
    
    // Fallback to database
    db := forge.GetDatabase(c)
    var user User
    if err := db.Driver().(*sql.DB).QueryRow(
        "SELECT id, name, email FROM users WHERE id = $1", userID,
    ).Scan(&user.ID, &user.Name, &user.Email); err != nil {
        return c.JSON(404, map[string]string{"error": "User not found"})
    }
    
    // Cache the result
    cache.SetJSON(c.Context(), "user:"+userID, user, time.Hour)
    
    return c.JSON(200, user)
}

func createUserHandler(c forge.Context) error {
    var user User
    if err := c.Bind(&user); err != nil {
        return c.JSON(400, map[string]string{"error": "Invalid input"})
    }
    
    // Save to database
    db := forge.GetDatabase(c)
    if err := db.Driver().(*sql.DB).QueryRow(
        "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id",
        user.Name, user.Email,
    ).Scan(&user.ID); err != nil {
        return c.JSON(500, map[string]string{"error": "Failed to create user"})
    }
    
    // Publish event
    queue := forge.GetQueue(c)
    event := map[string]interface{}{
        "type": "user.created",
        "user_id": user.ID,
        "timestamp": time.Now(),
    }
    queue.Publish(c.Context(), "user.events", queue.Message{
        Body: event,
    })
    
    // Store profile image if provided
    if user.ProfileImage != nil {
        storage := forge.GetStorage(c)
        key := fmt.Sprintf("profiles/%d/avatar.jpg", user.ID)
        storage.Upload(c.Context(), key, user.ProfileImage)
    }
    
    return c.JSON(201, user)
}