Module middleware 

Middleware system for request/response processing.

This module provides a flexible middleware chain system that allows you to intercept and process WebSocket messages before they reach handlers. Middleware can modify messages, perform authentication, logging, rate limiting, and more.

Overview

The middleware system is built around three core types:

• Middleware - Trait that all middleware must implement
• MiddlewareChain - Container that holds and executes middleware in order
• Next - Represents the next step in the middleware chain

Architecture

Message → Middleware 1 → Middleware 2 → ... → Handler → Response
             ↓              ↓                      ↓
          Next::run     Next::run            Handler::call

Each middleware can:

• Inspect the incoming message
• Modify the message before passing it forward
• Short-circuit the chain by not calling next.run()
• Modify the response after calling next.run()
• Handle errors and transform responses

Examples

Using Built-in Logger Middleware

use wsforge::prelude::*;

async fn echo(msg: Message) -> Result<Message> {
    Ok(msg)
}

let router = Router::new()
    .layer(LoggerMiddleware::new())
    .default_handler(handler(echo));

router.listen("127.0.0.1:8080").await?;

Creating Custom Middleware

use wsforge::prelude::*;
use async_trait::async_trait;

struct AuthMiddleware {
    secret: String,
}

#[async_trait]
impl Middleware for AuthMiddleware {
    async fn handle(
        &self,
        message: Message,
        conn: Connection,
        state: AppState,
        extensions: Extensions,
        mut next: Next,
    ) -> Result<Option<Message>> {
        // Check for auth token in message
        if let Some(text) = message.as_text() {
            if !text.contains(&self.secret) {
                return Err(Error::custom("Unauthorized"));
            }
        }

        // Continue to next middleware/handler
        next.run(message, conn, state, extensions).await
    }
}

Function-based Middleware

use wsforge::prelude::*;

let logging_middleware = from_fn(|msg, conn, state, ext, mut next| async move {
    println!("Before handler: {:?}", msg.as_text());
    let response = next.run(msg, conn, state, ext).await?;
    println!("After handler");
    Ok(response)
});

// Use in router
// router.layer(logging_middleware);

Chaining Multiple Middleware

use wsforge::prelude::*;

let router = Router::new()
    .layer(LoggerMiddleware::new())
    .layer(auth_middleware())
    .layer(rate_limit_middleware())
    .default_handler(handler(my_handler));

Re-exports

pub use logger::LoggerMiddleware;

Modules

logger

Logger middleware for request/response logging.

Structs

FnMiddleware

Function-based Middleware

MiddlewareChain

Middleware chain holds all middlewares and the final handler.

Next

Represents the next middleware or handler in the chain.

Traits

Middleware

Middleware trait that all middleware must implement.

Functions

from_fn

Helper function to create middleware from async functions.