Middleware

Middleware is an async function that receives the request plus next, the rest of the pipeline:

#![allow(unused)]
fn main() {
use std::time::Instant;
use zapline::prelude::*;

async fn timing(req: Request, next: Next) -> Response {
    let start = Instant::now();
    let mut res = next.run(req).await;
    let ms = start.elapsed().as_secs_f64() * 1000.0;
    res.headers_mut().insert("server-timing", HeaderValue::from_str(&format!("app;dur={ms:.2}")).unwrap());
    res
}

App::new().wrap(timing);
}

Middleware can short-circuit by returning a response without calling next.run. It can also modify the request (headers, extensions, URI) before passing it on, and modify the response afterwards. For configurable middleware, implement the Middleware trait on a struct.

Where middleware runs

request ─▶ global (App::wrap) ─▶ routing ─▶ route (App::wrap_route) ─▶ group (Routes::wrap) ─▶ handler

Middleware runs in the order it was added (the first wrap is the outermost layer).

Passing data to handlers

Insert typed values into the request extensions and read them with Extension<T>:

#![allow(unused)]
fn main() {
#[derive(Clone)]
struct Tenant(String);

async fn tenant(mut req: Request, next: Next) -> Response {
    let t = req.headers().get("x-tenant").and_then(|v| v.to_str().ok()).unwrap_or("default").to_owned();
    req.extensions_mut().insert(Tenant(t));
    next.run(req).await
}

async fn handler(Extension(Tenant(t)): Extension<Tenant>) -> String { t }
}

Built-in middleware

See Hardening middleware for configuration details.