Cruxi Middleware

Generic middleware chaining for Cruxi handlers.

This crate provides utilities for composing middleware that wrap and decorate Cruxi handlers with cross-cutting concerns.

Features

• Generic middleware chaining - Compose any number of middleware
• Handler middleware - Middleware specifically for Cruxi handlers
• Tower integration - Optional Tower Service adapter (requires tower feature)

Example

use cruxi_middleware::chain::MiddlewareChain;

// Build a middleware chain that transforms strings
let result = MiddlewareChain::new()
    .add(|s: String| format!("[prefix] {}", s))
    .add(|s: String| format!("{} [suffix]", s))
    .apply("hello".to_string());

assert_eq!(result, "[prefix] hello [suffix]");

Handler Middleware

use cruxi::{Context, Handler, HandlerFn};
use cruxi_middleware::handler::{map_request, map_response};

let handler = HandlerFn::new(|_ctx: &Context, req: i32| -> Result<i32, std::convert::Infallible> {
    Ok(req)
});

// Apply middleware by nesting (map_request outer, map_response inner)
let with_request = map_request(|req: i32| req + 1)(handler);
let wrapped = map_response(|resp: i32| resp * 2)(with_request);

let result = wrapped.handle(&Context::new(), 20);
assert_eq!(result.ok(), Some(42)); // (20 + 1) * 2 = 42

Tower Integration

Enable the tower feature to use Cruxi handlers as Tower services:

[dependencies]
cruxi-middleware = { version = "0.1", features = ["tower"] }

use cruxi_middleware::tower::HandlerService;
use tower::Service;

let handler = /* ... */;
let mut service = HandlerService::new(handler, Context::new());
let response = service.call(request).await;

cruxi-middleware

Composable middleware utilities for generic pipelines and Cruxi handlers.

Purpose

cruxi-middleware provides:

• generic MiddlewareChain composition
• handler-focused wrappers (map_request, map_response)
• optional Tower adapter (tower feature)

Usage

Apply cross-cutting logic (normalization, mapping, instrumentation) without coupling to transport frameworks.

Example

use cruxi_middleware::chain::MiddlewareChain;

let value = MiddlewareChain::new()
    .add(|v: i32| v + 1)
    .add(|v: i32| v * 2)
    .apply(20);

assert_eq!(value, 42);