Struct Request 

pub struct Request { /* private fields */ }

HTTP request.

Implementations

impl Request

pub fn new(method: Method, path: impl Into<String>) -> Request

Create a new request.

pub fn with_version( method: Method, path: impl Into<String>, version: HttpVersion, ) -> Request

Create a new request with a specific HTTP version.

pub fn version(&self) -> HttpVersion

Get the HTTP version.

pub fn set_version(&mut self, version: HttpVersion)

Set the HTTP version.

pub fn method(&self) -> Method

Get the HTTP method.

pub fn path(&self) -> &str

Get the request path.

Examples found in repository

examples/crud_api.rs (line 111)

fn extract_user_id(req: &Request) -> Result<u64, Response> {
    let path = req.path();
    let segments: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
    segments
        .get(1)
        .and_then(|s| s.parse::<u64>().ok())
        .ok_or_else(|| json_error(StatusCode::BAD_REQUEST, "Invalid user ID"))
}

pub fn set_path(&mut self, path: String)

Set the request path.

This is used internally for mounted sub-applications, where the mount prefix is stripped from the path before forwarding.

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

Get the query string.

pub fn headers(&self) -> &Headers

Get the headers.

Examples found in repository

examples/crud_api.rs (line 92)

fn parse_json_body<T: serde::de::DeserializeOwned>(req: &mut Request) -> Result<T, Response> {
    let is_json = req
        .headers()
        .get("content-type")
        .is_some_and(|ct| ct.starts_with(b"application/json"));

    if !is_json {
        return Err(json_error(
            StatusCode::UNSUPPORTED_MEDIA_TYPE,
            "Content-Type must be application/json",
        ));
    }

    let Body::Bytes(body) = req.take_body() else {
        return Err(json_error(StatusCode::BAD_REQUEST, "Missing request body"));
    };
    serde_json::from_slice(&body)
        .map_err(|e| json_error(StatusCode::BAD_REQUEST, &format!("Invalid JSON: {e}")))
}

examples/auth_example.rs (line 113)

fn login_handler(_ctx: &RequestContext, req: &mut Request) -> std::future::Ready<Response> {
    // In a real app, we would parse the JSON body and validate credentials.
    // For this demo, we just check that it's a POST with some body.

    // Check Content-Type
    let is_json = req
        .headers()
        .get("content-type")
        .is_some_and(|ct| ct.starts_with(b"application/json"));

    if !is_json {
        let error = serde_json::json!({
            "detail": "Content-Type must be application/json"
        });
        return std::future::ready(
            Response::with_status(StatusCode::UNSUPPORTED_MEDIA_TYPE)
                .header("content-type", b"application/json".to_vec())
                .body(ResponseBody::Bytes(error.to_string().into_bytes())),
        );
    }

    // For demo purposes, we don't validate credentials - just return the token
    // In production, you would:
    // 1. Parse the request body as LoginRequest
    // 2. Verify username/password against your database
    // 3. Generate a unique, cryptographically secure token
    // 4. Store token -> user_id mapping (with expiration)

    let response = LoginResponse {
        access_token: SECRET_TOKEN.to_string(),
        token_type: "bearer",
    };

    std::future::ready(
        Response::ok()
            .header("content-type", b"application/json".to_vec())
            .body(ResponseBody::Bytes(
                serde_json::to_string(&response).unwrap().into_bytes(),
            )),
    )
}

/// Handler for protected endpoint - requires valid bearer token.
///
/// This handler manually extracts and validates the bearer token:
/// 1. Gets the Authorization header
/// 2. Verifies it uses the Bearer scheme
/// 3. Validates the token against our secret using constant-time comparison
///
/// Returns appropriate error responses for each failure mode.
fn protected_handler(_ctx: &RequestContext, req: &mut Request) -> std::future::Ready<Response> {
    // Step 1: Get the Authorization header
    let Some(auth_header) = req.headers().get("authorization") else {
        // Missing header -> 401 Unauthorized
        let body = serde_json::json!({
            "detail": "Not authenticated"
        });
        return std::future::ready(
            Response::with_status(StatusCode::UNAUTHORIZED)
                .header("www-authenticate", b"Bearer".to_vec())
                .header("content-type", b"application/json".to_vec())
                .body(ResponseBody::Bytes(body.to_string().into_bytes())),
        );
    };

    // Step 2: Parse the Authorization header
    let Ok(auth_str) = std::str::from_utf8(auth_header) else {
        // Invalid UTF-8 -> 401 Unauthorized
        let body = serde_json::json!({
            "detail": "Invalid authentication credentials"
        });
        return std::future::ready(
            Response::with_status(StatusCode::UNAUTHORIZED)
                .header("www-authenticate", b"Bearer".to_vec())
                .header("content-type", b"application/json".to_vec())
                .body(ResponseBody::Bytes(body.to_string().into_bytes())),
        );
    };

    // Step 3: Check for "Bearer " prefix (case-insensitive for the scheme)
    let Some(token) = auth_str
        .strip_prefix("Bearer ")
        .or_else(|| auth_str.strip_prefix("bearer "))
    else {
        // Wrong scheme -> 401 Unauthorized
        let body = serde_json::json!({
            "detail": "Invalid authentication credentials"
        });
        return std::future::ready(
            Response::with_status(StatusCode::UNAUTHORIZED)
                .header("www-authenticate", b"Bearer".to_vec())
                .header("content-type", b"application/json".to_vec())
                .body(ResponseBody::Bytes(body.to_string().into_bytes())),
        );
    };

    let token = token.trim();
    if token.is_empty() {
        // Empty token -> 401 Unauthorized
        let body = serde_json::json!({
            "detail": "Invalid authentication credentials"
        });
        return std::future::ready(
            Response::with_status(StatusCode::UNAUTHORIZED)
                .header("www-authenticate", b"Bearer".to_vec())
                .header("content-type", b"application/json".to_vec())
                .body(ResponseBody::Bytes(body.to_string().into_bytes())),
        );
    }

    // Step 4: Validate the token using constant-time comparison
    // Create a BearerToken for secure comparison
    let bearer_token = BearerToken::new(token);
    if !bearer_token.secure_eq(SECRET_TOKEN) {
        // Invalid token -> 403 Forbidden
        let body = serde_json::json!({
            "detail": "Invalid token"
        });
        return std::future::ready(
            Response::with_status(StatusCode::FORBIDDEN)
                .header("content-type", b"application/json".to_vec())
                .body(ResponseBody::Bytes(body.to_string().into_bytes())),
        );
    }

    // Token is valid - return protected data
    let user_info = UserInfo {
        username: "demo_user".to_string(),
        message: "You have accessed a protected resource!".to_string(),
    };

    std::future::ready(
        Response::ok()
            .header("content-type", b"application/json".to_vec())
            .body(ResponseBody::Bytes(
                serde_json::to_string(&user_info).unwrap().into_bytes(),
            )),
    )
}

pub fn headers_mut(&mut self) -> &mut Headers

Get mutable headers.

pub fn body(&self) -> &Body

Get the body.

pub fn take_body(&mut self) -> Body

Take the body, replacing with Empty.

Examples found in repository

examples/crud_api.rs (line 103)

fn parse_json_body<T: serde::de::DeserializeOwned>(req: &mut Request) -> Result<T, Response> {
    let is_json = req
        .headers()
        .get("content-type")
        .is_some_and(|ct| ct.starts_with(b"application/json"));

    if !is_json {
        return Err(json_error(
            StatusCode::UNSUPPORTED_MEDIA_TYPE,
            "Content-Type must be application/json",
        ));
    }

    let Body::Bytes(body) = req.take_body() else {
        return Err(json_error(StatusCode::BAD_REQUEST, "Missing request body"));
    };
    serde_json::from_slice(&body)
        .map_err(|e| json_error(StatusCode::BAD_REQUEST, &format!("Invalid JSON: {e}")))
}

pub fn set_body(&mut self, body: Body)

Set the body.

pub fn set_query(&mut self, query: Option<String>)

Set the query string.

pub fn insert_extension<T>(&mut self, value: T)

where T: Any + Send + Sync,

Insert a typed extension value.

pub fn get_extension<T>(&self) -> Option<&T>

where T: Any + Send + Sync,

Get a typed extension value.

pub fn get_extension_mut<T>(&mut self) -> Option<&mut T>

where T: Any + Send + Sync,

Get a mutable typed extension value.

Trait Implementations

impl Debug for Request

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

Formats the value using the given formatter.