Struct Request 

pub struct Request<T, C = ()> {
    pub body: T,
    pub ctx: C,
    pub headers: HeaderMap,
    pub method: Method,
    pub path: String,
    pub path_params: HashMap<String, String>,
    pub query_params: HashMap<String, String>,
    pub request_id: String,
}

HTTP request wrapper providing context alongside the deserialized body

The generic parameter T is the request body type (flatbed-generated struct). The optional parameter C is the application context type (defaults to ()).

Example

// Simple handler without context
#[route("/ping")]
async fn handle_ping(req: Request<PingRequest>) -> Result<Response<PingResponse>, FlatbedError> {
    Ok(Response::ok(PingResponse { message: Some("pong".into()), ... }))
}

// Handler with application context
#[route("/users")]
async fn handle_users(req: Request<UserRequest, AppCtx>) -> Result<Response<UserResponse>, FlatbedError> {
    let user = req.ctx.db.find_user(&req.body.id).await?;
    Ok(Response::ok(UserResponse { name: user.name, ... }))
}

Fields

body: T

The deserialized request body

ctx: C

Application context (zero-sized when C = ())

headers: HeaderMap

HTTP headers from the request

method: Method

HTTP method

path: String

Request path

path_params: HashMap<String, String>

Path parameters (e.g., /users/{id} -> {“id”: “123”})

query_params: HashMap<String, String>

Query string parameters

request_id: String

Request ID (propagated or generated)

Implementations

impl<T, C> Request<T, C>

pub fn header(&self, name: &str) -> Option<&str>

Get a header value by name (case-insensitive)

pub fn param(&self, name: &str) -> Option<&str>

Get a path parameter by name

pub fn query(&self, name: &str) -> Option<&str>

Get a query parameter by name

pub fn request_id(&self) -> &str

Get the request ID

Trait Implementations

impl<T: Debug, C: Debug> Debug for Request<T, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, C> Deref for Request<T, C>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.