Crate lambda_lw_http_router

Lambda LightWeight HTTP Router (lambda-lw-http-router) is a lightweight routing library for AWS Lambda HTTP events.

It provides a simple and efficient way to define routes and handlers for AWS Lambda functions that process HTTP events from API Gateway, Application Load Balancer, and WebSocket APIs.

Features

• Support for multiple AWS event types (API Gateway v2, v1, ALB, WebSocket)
• Path parameter extraction
• Type-safe route handlers
• Compile-time route registration
• Minimal runtime overhead

Quick Start

// Define your application state
#[derive(Clone)]
struct AppState {
    // your state fields here
}

// Set up the router
define_router!(event = ApiGatewayV2httpRequest, state = AppState);

// Define a route handler
#[route(path = "/hello/{name}")]
async fn handle_hello(ctx: RouteContext) -> Result<Value, Error> {
    let name = ctx.params.get("name").map(|s| s.as_str()).unwrap_or("World");
    Ok(json!({
        "message": format!("Hello, {}!", name)
    }))
}

Examples

Basic usage with default module name:

#[derive(Clone)]
struct AppState {
    // your state fields here
}

define_router!(event = ApiGatewayV2httpRequest, state = AppState);

// This creates a module with the following types:
// Router - Router<AppState, ApiGatewayV2httpRequest>
// RouterBuilder - RouterBuilder<AppState, ApiGatewayV2httpRequest>
// RouteContext - RouteContext<AppState, ApiGatewayV2httpRequest>

Custom module name for better readability or multiple routers:

#[derive(Clone)]
struct AppState {
    // your state fields here
}

// Define an API Gateway router
define_router!(event = ApiGatewayV2httpRequest, module = api_router, state = AppState);

// Define an ALB router in the same application
define_router!(event = AlbTargetGroupRequest, module = alb_router, state = AppState);

// Now you can use specific types for each router:
// api_router::Router
// api_router::RouterBuilder
// api_router::RouteContext
//
// alb_router::Router
// alb_router::RouterBuilder
// alb_router::RouteContext

Usage with Route Handlers

The module name defined here should match the module parameter in your route handlers:

define_router!(event = ApiGatewayV2httpRequest, module = api_router, state = AppState);

#[route(path = "/hello", module = "api_router")]
async fn handle_hello(ctx: api_router::RouteContext) -> Result<Value, Error> {
    Ok(json!({ "message": "Hello, World!" }))
}

Modules

ctor

Procedural macro for defining global constructor/destructor functions.

Macros

define_router

Defines a router module with the necessary type aliases for your Lambda application.

Structs

RouteContext

Context passed to route handlers containing request information and application state.

Router

The main router type that handles HTTP requests and dispatches them to handlers.

RouterBuilder

A builder for constructing routers with a fluent API.

Traits

RoutableHttpEvent

A trait for HTTP events that can be routed by the router.

Functions

register_route

Attribute Macros

route

Defines a route handler for Lambda HTTP events.