Fork HTTP Framework

package main

import (
    "go.fork.vn/fork"
)

func main() {
    // Tạo WebApp instance
    app := fork.New()
    
    // Định nghĩa basic routes
    app.Get("/", func(c fork.Context) error {
        return c.String(200, "Hello, Fork HTTP Framework!")
    })
    
    app.Get("/health", func(c fork.Context) error {
        return c.JSON(200, map[string]interface{}{
            "status": "ok",
            "framework": "Fork HTTP",
        })
    })
    
    // Route với parameters
    app.Get("/user/:id", func(c fork.Context) error {
        userID := c.Param("id")
        return c.JSON(200, map[string]string{
            "user_id": userID,
            "message": "User profile",
        })
    })
    
    // Khởi động server
    app.Listen(":3000")
}

package main

import (
    "log"
    "go.fork.vn/fork"
    "go.fork.vn/fork/adapter"
)

func main() {
    // Load configuration từ YAML
    config, err := fork.LoadConfigFromFile("configs/app.yaml")
    if err != nil {
        log.Fatal("Failed to load config:", err)
    }
    
    // Tạo application với config
    app := fork.NewWithConfig(config)
    
    // Sử dụng FastHTTP adapter cho high performance
    fastAdapter := adapter.NewFastHTTPAdapter()
    app.SetAdapter(fastAdapter)
    
    // API routes group
    api := app.Group("/api/v1")
    {
        api.Get("/health", healthHandler)
        api.Post("/users", createUserHandler)
        api.Get("/users/:id", getUserHandler)
        api.Put("/users/:id", updateUserHandler)
    }
    
    // Khởi động với graceful shutdown
    app.ListenWithGracefulShutdown(":8080")
}

type User struct {
    ID    int    `json:"id" validate:"required"`
    Name  string `json:"name" validate:"required,min=2,max=50"`
    Email string `json:"email" validate:"required,email"`
    Age   int    `json:"age" validate:"min=18,max=120"`
}

func createUserHandler(c fork.Context) error {
    var user User
    
    // Parse JSON request body
    if err := c.BodyParser(&user); err != nil {
        return c.Status(400).JSON(map[string]interface{}{
            "error": "Invalid JSON format",
            "details": err.Error(),
        })
    }
    
    // Validate struct data với tags
    if err := c.Validate(&user); err != nil {
        return c.Status(422).JSON(map[string]interface{}{
            "error": "Validation failed",
            "details": err.Error(),
        })
    }
    
    // Access route parameters
    userID := c.Param("id")
    
    // Access query parameters với default values
    page := c.QueryInt("page", 1)
    limit := c.QueryInt("limit", 10)
    filter := c.Query("filter", "active")
    
    // Set response headers
    c.Set("X-User-ID", userID)
    c.Set("X-Request-ID", c.Get("request_id"))
    
    // Return JSON response
    return c.Status(201).JSON(map[string]interface{}{
        "user": user,
        "meta": map[string]interface{}{
            "page": page,
            "limit": limit,
            "filter": filter,
        },
    })
}

app := fork.New()

// Basic HTTP methods
app.Get("/", homeHandler)
app.Post("/users", createUserHandler)
app.Put("/users/:id", updateUserHandler)
app.Delete("/users/:id", deleteUserHandler)
app.Patch("/users/:id", patchUserHandler)

// Route parameters với patterns
app.Get("/users/:id", getUserHandler)                    // Named parameter
app.Get("/users/:id/posts/:postId", getPostHandler)     // Multiple parameters
app.Get("/files/*filepath", fileHandler)                // Wildcard parameter

// Optional parameters
app.Get("/search/:query?", searchHandler)               // Optional query

// Regex constraints (nếu supported)
app.Get("/users/:id([0-9]+)", getUserByIDHandler)       // Numeric ID only

// Route groups với middleware
api := app.Group("/api/v1")
{
    // Public endpoints
    api.Get("/health", healthHandler)
    api.Post("/auth/login", loginHandler)
    
    // Protected endpoints group
    protected := api.Group("/", authMiddleware)
    {
        protected.Get("/profile", getProfileHandler)
        protected.Put("/profile", updateProfileHandler)
        
        // Admin endpoints
        admin := protected.Group("/admin", adminMiddleware)
        {
            admin.Get("/users", listUsersHandler)
            admin.Delete("/users/:id", deleteUserHandler)
            admin.Get("/stats", getStatsHandler)
        }
    }
}

// Static file serving
app.Static("/static", "./public")
app.Static("/uploads", "./uploads")

// Framework sử dụng trie structure cho fast route matching
// Zero-allocation patterns cho high-performance routing
// O(log n) lookup time với memory optimization

// Custom middleware function
func customAuthMiddleware(c fork.Context) error {
    token := c.Get("Authorization")
    if token == "" {
        return c.Status(401).JSON(map[string]string{
            "error": "Missing authorization token",
        })
    }
    
    // Validate token logic...
    // Set user context...
    
    return c.Next() // Continue to next middleware/handler
}

// Apply middleware
app.Use(customAuthMiddleware)

// Route-specific middleware
app.Get("/protected", authMiddleware, protectedHandler)

type WebAppConfig struct {
    GracefulShutdown GracefulShutdownConfig `yaml:"graceful_shutdown"`
}

type GracefulShutdownConfig struct {
    Enabled            bool `yaml:"enabled"`
    Timeout            int  `yaml:"timeout"`
    WaitForConnections bool `yaml:"wait_for_connections"`
    SignalBufferSize   int  `yaml:"signal_buffer_size"`
    
    // Callback functions
    OnShutdownStart    func()
    OnShutdownComplete func()
    OnShutdownError    func(error)
}

import "go.fork.vn/di"

// Define services
type UserService struct {
    db Database
}

type EmailService struct {
    apiKey string
}

func main() {
    // Create DI container
    container := di.New()
    
    // Register services
    container.Register(&UserService{db: NewDatabase()})
    container.Register(&EmailService{apiKey: "your-api-key"})
    
    // Create app với DI container
    app := fork.NewWithContainer(container)
    
    app.Post("/users", createUserWithDI)
    
    app.Listen(":8080")
}

func createUserWithDI(c fork.Context) error {
    // Resolve services từ container
    userService := di.Resolve[*UserService](c.Container())
    emailService := di.Resolve[*EmailService](c.Container())
    
    var user User
    if err := c.BodyParser(&user); err != nil {
        return c.Status(400).JSON(map[string]string{
            "error": "Invalid request",
        })
    }
    
    // Use services
    createdUser, err := userService.Create(user)
    if err != nil {
        return c.Status(500).JSON(map[string]string{
            "error": "Failed to create user",
        })
    }
    
    // Send welcome email
    go emailService.SendWelcomeEmail(createdUser.Email)
    
    return c.Status(201).JSON(createdUser)
}

import (
    "go.fork.vn/fork"
    "go.fork.vn/fork/adapter"
)

func main() {
    app := fork.New()
    
    // Sử dụng different adapters cho different use cases
    
    // 1. Standard net/http (default)
    // app.SetAdapter(adapter.NewNetHTTPAdapter())
    
    // 2. FastHTTP cho high performance
    fastAdapter := adapter.NewFastHTTPAdapter()
    app.SetAdapter(fastAdapter)
    
    // 3. HTTP/2 support
    // http2Adapter := adapter.NewHTTP2Adapter()
    // app.SetAdapter(http2Adapter)
    
    // 4. QUIC/HTTP3 support
    // quicAdapter := adapter.NewQUICAdapter()
    // app.SetAdapter(quicAdapter)
    
    app.Get("/", func(c fork.Context) error {
        return c.String(200, "Hello from " + c.Adapter().Name())
    })
    
    app.Listen(":8080")
}

// FastHTTP adapter với custom config
fastAdapter := adapter.NewFastHTTPAdapter()
fastAdapter.Configure(adapter.FastHTTPConfig{
    MaxRequestBodySize: 4 * 1024 * 1024, // 4MB
    Concurrency:        1000,
    ReduceMemoryUsage:  true,
    ReadTimeout:        30 * time.Second,
    WriteTimeout:       30 * time.Second,
})

app.SetAdapter(fastAdapter)

package main

import (
    "testing"
    "net/http/httptest"
    "strings"
    "github.com/stretchr/testify/assert"
    "go.fork.vn/fork"
)

func TestUserAPI(t *testing.T) {
    // Setup test app
    app := fork.New()
    app.Post("/users", createUserHandler)
    
    // Test successful creation
    t.Run("Create user successfully", func(t *testing.T) {
        jsonBody := `{"name":"John Doe","email":"john@example.com","age":25}`
        req := httptest.NewRequest("POST", "/users", strings.NewReader(jsonBody))
        req.Header.Set("Content-Type", "application/json")
        
        resp, err := app.Test(req)
        assert.NoError(t, err)
        assert.Equal(t, 201, resp.StatusCode)
    })
    
    // Test validation error
    t.Run("Validation error", func(t *testing.T) {
        jsonBody := `{"name":"","email":"invalid-email"}`
        req := httptest.NewRequest("POST", "/users", strings.NewReader(jsonBody))
        req.Header.Set("Content-Type", "application/json")
        
        resp, err := app.Test(req)
        assert.NoError(t, err)
        assert.Equal(t, 422, resp.StatusCode)
    })
}

func TestMiddleware(t *testing.T) {
    app := fork.New()
    
    // Add test middleware
    app.Use(func(c fork.Context) error {
        c.Set("test-header", "test-value")
        return c.Next()
    })
    
    app.Get("/test", func(c fork.Context) error {
        value := c.Get("test-header")
        return c.String(200, value)
    })
    
    req := httptest.NewRequest("GET", "/test", nil)
    resp, err := app.Test(req)
    
    assert.NoError(t, err)
    assert.Equal(t, 200, resp.StatusCode)
}

package main

import (
    "context"
    "log"
    "os"
    "os/signal"
    "syscall"
    "time"
    "go.fork.vn/fork"
)

func main() {
    app := fork.New()
    
    // Configure graceful shutdown với callbacks
    app.ConfigureGracefulShutdown(fork.GracefulShutdownConfig{
        Enabled:            true,
        Timeout:            30 * time.Second,
        WaitForConnections: true,
        SignalBufferSize:   1,
        
        OnShutdownStart: func() {
            log.Println("Starting graceful shutdown...")
        },
        OnShutdownComplete: func() {
            log.Println("Graceful shutdown completed")
        },
        OnShutdownError: func(err error) {
            log.Printf("Shutdown error: %v", err)
        },
    })
    
    // Setup routes
    app.Get("/health", func(c fork.Context) error {
        return c.JSON(200, map[string]string{"status": "ok"})
    })
    
    // Start với graceful shutdown
    go func() {
        if err := app.Listen(":8080"); err != nil {
            log.Printf("Server error: %v", err)
        }
    }()
    
    // Wait for shutdown signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    log.Println("Received shutdown signal")
    
    // Graceful shutdown với timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    if err := app.Shutdown(ctx); err != nil {
        log.Printf("Forced shutdown: %v", err)
    }
}