package main

import (
    "context"
    "log"
    "github.com/imlargo/medusa/cmd/api/bootstrap"
)

func main() {
    // Bootstrap handles all dependency wiring
    app, err := bootstrap.New("medusa-api")
    if err != nil {
        log.Fatal(err)
    }
    defer app.Container.Cleanup()

    // Run with graceful shutdown and error handling
    if err := app.Run(context.Background()); err != nil {
        log.Fatal(err)
    }
}

import "github.com/imlargo/medusa/pkg/medusa"

func GetUsers(c *gin.Context) {
    ctx := medusa.NewContext(c)
    
    // Type-safe parameter extraction with validation
    userID, err := ctx.ParamUUID("id")
    if err != nil {
        // Automatically returns 400 with validation error
        return
    }
    
    // Built-in pagination
    page := ctx.GetPage()      // Defaults to 1
    pageSize := ctx.GetPageSize() // Defaults to 20, max 100
    
    // Authentication helpers
    if !ctx.IsAuthenticated() {
        ctx.Error(medusa.ErrUnauthorized("Login required"))
        return
    }
    
    currentUserID, _ := ctx.UserID()
    
    // Query with context propagation
    users, err := userService.List(c.Request.Context(), page, pageSize)
    if err != nil {
        ctx.Error(medusa.Wrap(err, "Failed to fetch users"))
        return
    }
    
    // Paginated response with request ID tracking
    ctx.Paged(users, page, pageSize, totalCount)
}

package main

import (
    "context"
    "github.com/gin-gonic/gin"
    "github.com/imlargo/medusa/pkg/medusa/core/app"
    "github.com/imlargo/medusa/pkg/medusa/core/logger"
    "github.com/imlargo/medusa/pkg/medusa/core/responses"
    "github.com/imlargo/medusa/pkg/medusa/core/server/http"
)

func main() {
    log := logger.NewLogger()
    defer log.Sync()

    router := gin.Default()
    srv := http.NewServer(router, log,
        http.WithServerHost("localhost"),
        http.WithServerPort("8080"),
    )

    app := app.NewApp(
        app. WithName("my-api"),
        app.WithServer(srv),
    )

    // Define your routes
    router.GET("/ping", func(c *gin.Context) {
        responses.SuccessOK(c, gin. H{"message": "pong"})
    })

    // Run with graceful shutdown
    app.Run(context.Background())
}

import "github.com/imlargo/medusa/pkg/medusa/services/cache"

redisClient := database.NewRedisClient("redis://localhost:6379")
cache := cache.NewRedisCache(redisClient)

// Set value with expiration
cache.Set(ctx, "user:123", userData, 1*time.Hour)

// Get value
var user User
cache.Get(ctx, "user:123", &user)

import "github.com/imlargo/medusa/pkg/medusa/services/storage"

storage, _ := storage.NewFileStorage(storage.StorageProviderR2, config)

// Upload file
file, _ := storage.Upload("avatars/user-123.jpg", fileReader, "image/jpeg", fileSize)
fmt. Println(file. Url) // Public URL

// Generate presigned URL for secure downloads
url, _ := storage.GetPresignedURL("documents/secret.pdf", 15*time.Minute)

import "github.com/imlargo/medusa/pkg/medusa/services/sse"

sseManager := sse. NewSSEManager()

// Client connects
router.GET("/stream", func(c *gin.Context) {
    userID := getUserID(c)
    deviceID := c.Query("device_id")
    
    client, _ := sseManager.Subscribe(c. Request.Context(), userID, deviceID)
    
    c.Header("Content-Type", "text/event-stream")
    c.Header("Cache-Control", "no-cache")
    
    for {
        select {
        case msg := <-client. GetChannel():
            c.SSEvent("message", msg)
            c.Writer. Flush()
        case <-c.Request.Context().Done():
            return
        }
    }
})

// Send event to user (from anywhere in your app)
sseManager.Send(userID, &sse. Message{
    Event: "notification",
    Data:  gin.H{"title": "New message", "body": "You have a new message"},
})

import "github.com/imlargo/medusa/pkg/medusa/services/pubsub"

// Publisher
publisher := pubsub.NewRabbitMQPublisher(config)
publisher.Publish(ctx, "user.registered", UserRegisteredEvent{
    UserID:  123,
    Email:  "user@example.com",
})

// Subscriber
subscriber := pubsub.NewRabbitMQSubscriber(config)
subscriber.Subscribe(ctx, "user.registered", func(msg []byte) error {
    var event UserRegisteredEvent
    json.Unmarshal(msg, &event)
    
    // Send welcome email
    sendWelcomeEmail(event. Email)
    return nil
})

import "github.com/imlargo/medusa/pkg/medusa/services/email"

emailService := email.NewResendClient(apiKey)
emailService.SendEmail(&email.SendEmailParams{
    From:    "noreply@myapp.com",
    To:      []string{"user@example.com"},
    Subject: "Welcome to MyApp",
    Html:    "<h1>Welcome! </h1><p>Thanks for joining. </p>",
})

// Liveness check - Returns 200 if process is running
GET /health
Response: {
    "status": "healthy",
    "request_id": "550e8400-e29b-41d4-a716-446655440000"
}

// Readiness check - Returns detailed dependency status
GET /ready
Response: {
    "status": "healthy",
    "checks": {
        "database": "healthy",
        "redis": "healthy"
    },
    "request_id": "550e8400-e29b-41d4-a716-446655440000"
}

// Returns 503 if dependencies are unhealthy with Retry-After header

// Use only what you need
import "github.com/imlargo/medusa/pkg/medusa/services/cache"
import "github.com/imlargo/medusa/pkg/medusa/core/logger"

// No need to import the entire framework

func main() {
    log := logger.NewLogger()
    router := gin.Default()
    
    // Database
    db, _ := database.NewPostgresDatabase(os.Getenv("DATABASE_URL"))
    
    // JWT Auth
    jwtAuth := jwt.NewJwt(jwt.Config{Secret: os.Getenv("JWT_SECRET")})
    
    // Public routes
    router.POST("/auth/register", RegisterHandler)
    router.POST("/auth/login", LoginHandler)
    
    // Protected routes
    protected := router.Group("/api")
    protected.Use(middleware.AuthTokenMiddleware(jwtAuth))
    {
        protected.GET("/profile", GetProfileHandler)
        protected.PUT("/profile", UpdateProfileHandler)
    }
    
    // Rate limited routes
    limited := router.Group("/api/actions")
    limited.Use(middleware.NewRateLimiterMiddleware(rateLimiter))
    {
        limited.POST("/upload", UploadHandler)
    }
    
    srv := http.NewServer(router, log)
    app := app.NewApp(app.WithServer(srv))
    app.Run(context.Background())
}

// Run HTTP and SSE servers concurrently
func main() {
    log := logger.NewLogger()
    
    // HTTP Server
    httpRouter := gin.Default()
    httpServer := http.NewServer(httpRouter, log,
        http.WithServerPort("8080"),
    )
    
    // SSE Server
    sseRouter := gin.Default()
    sseServer := http.NewServer(sseRouter, log,
        http.WithServerPort("8081"),
    )
    
    // Application with multiple servers
    app := app. NewApp(
        app.WithName("multi-server"),
        app.WithServer(httpServer, sseServer),
    )
    
    // Both servers managed with single graceful shutdown
    app.Run(context.Background())
}

// Define repository interface
type UserRepository interface {
    Create(ctx context.Context, user *User) error
    FindByID(ctx context.Context, id uint) (*User, error)
    Update(ctx context.Context, user *User) error
}

// Implementation
type userRepository struct {
    *medusarepo.Repository
}

func NewUserRepository(repo *medusarepo.Repository) UserRepository {
    return &userRepository{Repository: repo}
}

func (r *userRepository) Create(ctx context.Context, user *User) error {
    return r. DB.WithContext(ctx).Create(user).Error
}

func (r *userRepository) FindByID(ctx context.Context, id uint) (*User, error) {
    var user User
    err := r. DB.WithContext(ctx).First(&user, id).Error
    return &user, err
}

import "github.com/imlargo/medusa/pkg/medusa/middleware"

// JWT Authentication
router.Use(middleware.AuthTokenMiddleware(jwtAuth))

// API Key Authentication (Header)
router.Use(middleware.ApiKeyMiddleware("your-api-key"))

// API Key Authentication (Bearer)
router.Use(middleware.BearerApiKeyMiddleware("your-api-key"))

// CORS
router.Use(middleware.NewCorsMiddleware("https://myapp.com", []string{
    "https://app.myapp.com",
}))

// Rate Limiting
router.Use(middleware.NewRateLimiterMiddleware(rateLimiter))

// Metrics Collection
router.Use(middleware.NewMetricsMiddleware(metricsService))

func LogRequestMiddleware(log *logger.Logger) gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        
        c.Next()
        
        duration := time.Since(start)
        log.Info("Request completed",
            zap.String("method", c.Request.Method),
            zap.String("path", c.Request.URL. Path),
            zap.Int("status", c.Writer.Status()),
            zap.Duration("duration", duration),
        )
    }
}

package handlers_test

import (
    "testing"
    "net/http/httptest"
    "github.com/gin-gonic/gin"
    "github.com/stretchr/testify/assert"
)

func TestPingHandler(t *testing.T) {
    gin.SetMode(gin.TestMode)
    
    router := gin.Default()
    router.GET("/ping", PingHandler)
    
    req := httptest.NewRequest("GET", "/ping", nil)
    w := httptest.NewRecorder()
    
    router.ServeHTTP(w, req)
    
    assert.Equal(t, 200, w.Code)
    assert.Contains(t, w.Body.String(), "pong")
}