HTTP_ENHANCED

Enhanced HTTP Module - Full Backend Development Support

The Vint HTTP module has been significantly enhanced to support full-fledged backend development with enterprise-grade features.

🚀 New Features

1. Enhanced Request Object

JSON Body Parsing: Automatic parsing of application/json content
Form Data Parsing: Support for application/x-www-form-urlencoded data
Cookie Handling: Easy access to request cookies
Query Parameters: Enhanced query parameter utilities
Path Parameters: Extract parameters from routes like /users/:id
Headers: Improved header access methods

http.get("/users/:id", func(req, res) {
    let userId = req.param("id")          // Path parameter
    let sort = req.query("sort")          // Query parameter
    let session = req.cookie("session")   // Cookie value
    let auth = req.get("Authorization")   // Header value
    let body = req.body()                 // Raw body
    let json = req.json()                 // Parsed JSON
    let form = req.form("username")       // Form field
})

2. Enhanced Response Object

Method Chaining: Chain response methods for cleaner code
Redirect Support: Easy redirects with custom status codes
Cookie Setting: Set response cookies with options
JSON Responses: Improved JSON response handling
Status Helpers: Easy status code management

http.post("/login", func(req, res) {
    res.status(200)
       .cookie("session", "abc123")
       .header("X-Custom", "value")
       .json({"success": true})
    
    // Or redirect
    res.redirect("/dashboard", 302)
})

3. Interceptors

Request and response interceptors for cross-cutting concerns:

// Request interceptor - runs before route handlers
http.interceptor("request", func(req) {
    print("Processing request:", req.path())
    // Add request timestamp, validate format, etc.
})

// Response interceptor - runs after route handlers
http.interceptor("response", func(res) {
    print("Processing response")
    // Add security headers, log response time, etc.
})

4. Guards

Security guards for authentication, authorization, and rate limiting:

// Authentication guard
http.guard(func(req) {
    print("Checking authentication")
    // Verify JWT token, session, etc.
})

// Rate limiting guard
http.guard(func(req) {
    print("Checking rate limits")
    // Track requests per IP, enforce limits
})

// Custom validation guard
http.guard(func(req) {
    print("Custom security checks")
    // SQL injection detection, XSS prevention, etc.
})

5. Enhanced Middleware

Built-in middleware for common backend needs:

// CORS support
http.cors()

// Body parsing
http.bodyParser()

// Authentication middleware
http.auth(func(req, res, next) {
    print("Processing authentication")
})

// Global error handler
http.errorHandler(func(err, req, res) {
    print("Handling error:", err)
})

6. Route Parameters

Support for parameterized routes:

// Single parameter
http.get("/users/:id", func(req, res) {
    let id = req.param("id")
})

// Multiple parameters
http.get("/users/:userId/posts/:postId", func(req, res) {
    let userId = req.param("userId")
    let postId = req.param("postId")
})

7. Security Features

Automatic CORS: CORS headers added automatically
OPTIONS Handling: Preflight requests handled automatically
Security Headers: Enhanced security header management
Error Sanitization: Safe error responses

📖 Complete Example

import http

// Create application
http.app()

// Add interceptors
http.interceptor("request", func(req) {
    print("Request interceptor")
})

http.interceptor("response", func(res) {
    print("Response interceptor")
})

// Add guards
http.guard(func(req) {
    print("Auth guard")
})

http.guard(func(req) {
    print("Rate limit guard")
})

// Add middleware
http.cors()
http.bodyParser()
http.auth(func(req, res, next) {
    print("Auth middleware")
})

// Set error handler
http.errorHandler(func(err, req, res) {
    print("Error handler")
})

// Define routes
http.get("/", func(req, res) {
    res.send("Welcome to enhanced HTTP server!")
})

http.get("/users/:id", func(req, res) {
    let id = req.param("id")
    res.json({"user": id})
})

http.post("/api/data", func(req, res) {
    let data = req.json()
    res.status(201).json({"created": true})
})

// Start server
http.listen(3000, "Enhanced server running on port 3000!")

🧪 Testing

Comprehensive test files are included:

examples/enhanced_http_test.vint - Feature demonstrations
examples/backend_demo.vint - Backend application demo
examples/complete_backend_app.vint - Full production-ready example
examples/live_server_test.vint - Live server testing
module/http_enhanced_test.go - Go unit tests
object/http_enhanced_test.go - Object method tests

🏗️ Architecture

The enhanced HTTP module follows a layered architecture:

Interceptors → Process all requests/responses
Guards → Security and validation checks
Middleware → Cross-cutting concerns (CORS, auth, etc.)
Route Handlers → Business logic
Error Handlers → Error processing

🎯 Backend Capabilities

The enhanced HTTP module now supports:

✅ User Management - Complete CRUD operations
✅ Authentication - JWT, sessions, cookies
✅ Authorization - Role-based access control
✅ File Uploads - Multi-part form data
✅ API Development - RESTful endpoints
✅ Security - Guards, validation, sanitization
✅ Analytics - Request logging, metrics
✅ Admin Panels - Administrative interfaces
✅ Health Monitoring - System health checks
✅ Error Handling - Comprehensive error management
✅ Rate Limiting - Request throttling
✅ CORS Support - Cross-origin requests
✅ Content Types - JSON, forms, files

🚀 Production Ready

The enhanced HTTP module provides all the essential features needed for production backend applications:

Scalability: Efficient request processing
Security: Multi-layer protection
Monitoring: Built-in health checks and metrics
Flexibility: Extensible middleware and guard system
Standards: RESTful API support with proper HTTP semantics

This makes Vint suitable for building everything from simple APIs to complex enterprise applications.