Struct AuthenticationMiddleware 

pub struct AuthenticationMiddleware<S, A>
where
    S: SessionStore,
    A: AuthenticationBackend,
{ /* private fields */ }

Available on crate feature sessions and crate feature middleware and native only.

Authentication middleware Extracts user information from session and attaches it to request extensions

This middleware integrates with tower/hyper to provide Django-style authentication for Reinhardt applications. It automatically:

• Extracts session ID from cookies
• Loads user information from the session store
• Attaches user authentication state to request extensions
• Supports any authentication backend implementing AuthenticationBackend

Examples

Basic usage with in-memory session store:

use std::sync::Arc;
use reinhardt_middleware::AuthenticationMiddleware;
use reinhardt_auth::session::InMemorySessionStore;
use reinhardt_http::MiddlewareChain;

// Create session store and authentication backend
let session_store = Arc::new(InMemorySessionStore::new());
let auth_backend = Arc::new(TestAuthBackend);

// Create authentication middleware
let auth_middleware = AuthenticationMiddleware::new(session_store, auth_backend);

// Wrap your handler with the middleware using MiddlewareChain
let app = MiddlewareChain::new(handler)
    .with_middleware(Arc::new(auth_middleware));

Accessing authentication state in handlers:

struct ProtectedHandler;

#[async_trait]
impl Handler for ProtectedHandler {
    async fn handle(&self, request: Request) -> Result<Response> {
        // Extract authentication state from request extensions
        let is_authenticated: Option<bool> = request.extensions.get();
        let user_id: Option<String> = request.extensions.get();
        let is_admin: Option<bool> = request.extensions.get();

        if !is_authenticated.unwrap_or(false) {
            return Ok(Response::new(hyper::StatusCode::UNAUTHORIZED));
        }

        Ok(Response::ok().with_body(format!("Welcome user: {:?}", user_id)))
    }
}

Implementations

impl<S, A> AuthenticationMiddleware<S, A>

where S: SessionStore, A: AuthenticationBackend,

pub fn new( session_store: Arc<S>, auth_backend: Arc<A>, ) -> AuthenticationMiddleware<S, A>

Available on crate features standard or middleware only.

Create a new authentication middleware

Arguments

• session_store - Session storage backend
• auth_backend - Authentication backend for user lookup

Examples

use std::sync::Arc;
use reinhardt_middleware::AuthenticationMiddleware;
use reinhardt_auth::session::InMemorySessionStore;

let session_store = Arc::new(InMemorySessionStore::new());
let auth_backend = Arc::new(TestAuthBackend);
let middleware = AuthenticationMiddleware::new(session_store, auth_backend);

Trait Implementations

impl<S, A> Middleware for AuthenticationMiddleware<S, A>

where S: SessionStore + 'static, A: AuthenticationBackend + 'static,

fn process<'life0, 'async_trait>( &'life0 self, request: Request, next: Arc<dyn Handler>, ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, AuthenticationMiddleware<S, A>: 'async_trait,

Processes a request through this middleware.

fn should_continue(&self, _request: &Request) -> bool

Determines whether this middleware should be executed for the given request.

fn di_registrations(&self) -> Vec<(TypeId, Arc<dyn Any + Send + Sync>)>

Returns DI singleton registrations contributed by this middleware.