astralis/examples/HeadersAndCookies.vala

using Astralis;
using Invercargill;
using Invercargill.DataStructures;

/**
 * HeadersAndCookies Example
 * 
 * Demonstrates how to access and manipulate HTTP headers and cookies.
 * Uses Invercargill Dictionary and Enumerable for header/cookie processing.
 */

// Display all request headers
class HeadersHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var parts = new Series<string>();
        parts.add("Request Headers:\n");
        parts.add("================\n\n");
        
        http_context.request.headers.to_immutable_buffer()
            .iterate((grouping) => {
                grouping.iterate((value) => {
                    parts.add(@"$(grouping.key): $value\n");
                });
            });
        
        var result = parts.to_immutable_buffer()
            .aggregate<string>("", (acc, s) => acc + s);
        
        return new BufferedHttpResult.from_string(result);
    }
}

// Check for user-agent header
class UserAgentHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var user_agent = http_context.request.user_agent ?? "Unknown";
        
        return new BufferedHttpResult.from_string(
            @"Your User-Agent is: $user_agent"
        );
    }
}

// Check content type and content length
class ContentInfoHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var parts = new Series<string>();
        parts.add("Content Information:\n");
        parts.add("===================\n\n");
        parts.add(@"Content-Type: $(http_context.request.content_type)\n");
        parts.add(@"Content-Length: $(http_context.request.content_length)\n");
        parts.add(@"Content-Encoding: $(http_context.request.content_encoding ?? "none")\n");
        
        var result = parts.to_immutable_buffer()
            .aggregate<string>("", (acc, s) => acc + s);
        
        return new BufferedHttpResult.from_string(result);
    }
}

// Check if header exists
class CheckHeaderHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var header_name = http_context.request.get_query_or_default("name", "Accept");
        var exists = http_context.request.has_header(header_name);
        var value = http_context.request.get_header(header_name);
        
        return new BufferedHttpResult.from_string(
            @"Header '$header_name': $(exists ? "EXISTS" : "NOT FOUND")\nValue: $(value ?? "N/A")"
        );
    }
}

// Set custom response headers
class CustomHeadersHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var headers = new Catalogue<string, string>();
        headers.add("X-Custom-Header", "Custom-Value");
        headers.add("X-Request-Id", generate_request_id());
        headers.add("X-Powered-By", "Astralis");
        headers.add("X-Server-Time", new DateTime.now_local().format_iso8601());
        
        return new BufferedHttpResult.from_string(
            "Response with custom headers!",
            StatusCode.OK,
            headers
        );
    }
}

// Display all cookies
class CookiesHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var parts = new Series<string>();
        parts.add("Request Cookies:\n");
        parts.add("================\n\n");
        
        if (http_context.request.cookies.to_immutable_buffer().count() == 0) {
            parts.add("(No cookies sent)\n");
            parts.add("\nTry setting a cookie first: /set-cookie?name=test&value=123\n");
        } else {
            http_context.request.cookies.to_immutable_buffer()
                .iterate((grouping) => {
                    grouping.iterate((value) => {
                        parts.add(@"$(grouping.key): $value\n");
                    });
                });
        }
        
        var result = parts.to_immutable_buffer()
            .aggregate<string>("", (acc, s) => acc + s);
        
        return new BufferedHttpResult.from_string(result);
    }
}

// Get specific cookie
class GetCookieHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var name = http_context.request.get_query_or_default("name", "session");
        var value = http_context.request.get_cookie(name);
        
        if (value == null) {
            return new BufferedHttpResult.from_string(
                @"Cookie '$name' not found",
                StatusCode.NOT_FOUND
            );
        }
        
        return new BufferedHttpResult.from_string(
            @"Cookie '$name' = '$value'"
        );
    }
}

// Set a cookie (via Set-Cookie header)
class SetCookieHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var name = http_context.request.get_query_or_default("name", "test");
        var value = http_context.request.get_query_or_default("value", "123");
        var max_age = http_context.request.get_query_or_default("max_age", "3600");
        
        var headers = new Catalogue<string, string>();
        headers.add("Set-Cookie", @"$name=$value; Max-Age=$max_age; Path=/");
        
        return new BufferedHttpResult.from_string(
            @"Cookie '$name' set to '$value'",
            StatusCode.OK,
            headers
        );
    }
}

// Set multiple cookies
class SetCookiesHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var headers = new Catalogue<string, string>();
        headers.add("Set-Cookie", "user=john; Max-Age=3600; Path=/");
        headers.add("Set-Cookie", "theme=dark; Max-Age=86400; Path=/");
        headers.add("Set-Cookie", "lang=en; Max-Age=31536000; Path=/");
        
        return new BufferedHttpResult.from_string(
            "Multiple cookies set!",
            StatusCode.OK,
            headers
        );
    }
}

// Delete a cookie
class DeleteCookieHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var name = http_context.request.get_query_or_default("name", "test");
        
        var headers = new Catalogue<string, string>();
        headers.add("Set-Cookie", @"$name=; Max-Age=0; Path=/");
        
        return new BufferedHttpResult.from_string(
            @"Cookie '$name' deleted",
            StatusCode.OK,
            headers
        );
    }
}

// Check if cookie exists
class HasCookieHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var name = http_context.request.get_query_or_default("name", "session");
        var exists = http_context.request.has_cookie(name);
        
        return new BufferedHttpResult.from_string(
            @"Cookie '$name': $(exists ? "EXISTS" : "NOT FOUND")"
        );
    }
}

// Cookie-based session simulation
class SessionHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var session_id = http_context.request.get_cookie("session_id");
        
        if (session_id == null) {
            // Create new session
            var new_session_id = generate_session_id();
            
            var headers = new Catalogue<string, string>();
            headers.add("Set-Cookie", @"session_id=$new_session_id; Max-Age=3600; Path=/; HttpOnly");
            
            return new BufferedHttpResult.from_string(
                @"New session created!
Session ID: $new_session_id

Your session will expire in 1 hour.",
                StatusCode.OK,
                headers
            );
        }
        
        // Existing session
        return new BufferedHttpResult.from_string(
            @"Welcome back!
Session ID: $session_id

Your session is active."
        );
    }
}

// CORS headers example
class CorsHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var origin = http_context.request.get_header("Origin") ?? "*";
        
        var headers = new Catalogue<string, string>();
        headers.add("Access-Control-Allow-Origin", origin);
        headers.add("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
        headers.add("Access-Control-Allow-Headers", "Content-Type, Authorization");
        headers.add("Access-Control-Max-Age", "86400");
        
        return new BufferedHttpResult.from_string(
            @"CORS enabled for origin: $origin",
            StatusCode.OK,
            headers
        );
    }
}

// Cache control headers
class CacheHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var cache_type = http_context.request.get_query_or_default("type", "public");
        
        var headers = new Catalogue<string, string>();
        headers.add("Cache-Control", @"$cache_type, max-age=3600");
        headers.add("Expires", get_expires_header(3600));
        headers.add("ETag", generate_etag());
        
        return new BufferedHttpResult.from_string(
            @"This response is cached ($cache_type cache, 1 hour)",
            StatusCode.OK,
            headers
        );
    }
}

// Content negotiation
class NegotiateHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var accept = http_context.request.get_header("Accept") ?? "*/*";
        
        var headers = new Catalogue<string, string>();
        
        if (accept.contains("application/json")) {
            headers.add("Content-Type", "application/json");
            return new BufferedHttpResult.from_string(
                @"{ \"message\": \"JSON response\", \"format\": \"json\" }",
                StatusCode.OK,
                headers
            );
        } else if (accept.contains("text/xml")) {
            headers.add("Content-Type", "text/xml");
            return new BufferedHttpResult.from_string(
                @"<?xml version=\"1.0\"?><response><message>XML response</message><format>xml</format></response>",
                StatusCode.OK,
                headers
            );
        } else {
            headers.add("Content-Type", "text/plain");
            return new BufferedHttpResult.from_string(
                "Plain text response",
                StatusCode.OK,
                headers
            );
        }
    }
}

// Security headers
class SecureHandler : Object, RouteHandler {
    public async HttpResult handle_route(HttpContext http_context, RouteContext route_context) throws Error {
        var headers = new Catalogue<string, string>();
        headers.add("X-Content-Type-Options", "nosniff");
        headers.add("X-Frame-Options", "DENY");
        headers.add("X-XSS-Protection", "1; mode=block");
        headers.add("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
        headers.add("Content-Security-Policy", "default-src 'self'");
        headers.add("Referrer-Policy", "strict-origin-when-cross-origin");
        
        return new BufferedHttpResult.from_string(
            "Response with security headers!",
            StatusCode.OK,
            headers
        );
    }
}

void main() {
    var router = new Router();
    var server = new Server(8083, router);
    
    // Register routes
    router.get("/headers", new HeadersHandler());
    router.get("/user-agent", new UserAgentHandler());
    router.get("/content-info", new ContentInfoHandler());
    router.get("/check-header", new CheckHeaderHandler());
    router.get("/custom-headers", new CustomHeadersHandler());
    router.get("/cookies", new CookiesHandler());
    router.get("/get-cookie", new GetCookieHandler());
    router.get("/set-cookie", new SetCookieHandler());
    router.get("/set-cookies", new SetCookiesHandler());
    router.get("/delete-cookie", new DeleteCookieHandler());
    router.get("/has-cookie", new HasCookieHandler());
    router.get("/session", new SessionHandler());
    router.get("/cors", new CorsHandler());
    router.get("/cache", new CacheHandler());
    router.get("/negotiate", new NegotiateHandler());
    router.get("/secure", new SecureHandler());
    
    print("Headers and Cookies Example Server running on port 8083\n");
    print("Try these endpoints:\n");
    print("  - http://localhost:8083/headers\n");
    print("  - http://localhost:8083/user-agent\n");
    print("  - http://localhost:8083/cookies\n");
    print("  - http://localhost:8083/set-cookie?name=test&value=hello\n");
    print("  - http://localhost:8083/set-cookies\n");
    print("  - http://localhost:8083/session\n");
    print("  - http://localhost:8083/cors\n");
    print("  - http://localhost:8083/cache\n");
    print("  - http://localhost:8083/negotiate\n");
    print("  - http://localhost:8083/secure\n");
    
    server.run();
}

// Helper functions
string generate_request_id() {
    var timestamp = new DateTime.now_local().to_unix();
    var random = Random.next_int();
    return @"req-$timestamp-$random";
}

string generate_session_id() {
    var timestamp = new DateTime.now_local().to_unix();
    var random = Random.next_int();
    return @"sess-$timestamp-$random";
}

string generate_etag() {
    var timestamp = new DateTime.now_local().to_unix();
    return @"\"$timestamp\"";
}

string get_expires_header(int seconds) {
    var now = new DateTime.now_local();
    var expires = now.add_seconds(seconds);
    return expires.format("%a, %d %b %Y %H:%M:%S GMT");
}