Struct ConsumerContext 

pub struct ConsumerContext {
    pub connection: Arc<WebSocketConnection>,
    pub headers: HashMap<String, String>,
    pub metadata: HashMap<String, String>,
    /* private fields */
}

Available on crate feature websockets and non-WebAssembly only.

Consumer context containing connection and message information

This context is passed to WebSocket consumer methods and provides access to:

• The WebSocket connection for sending messages
• HTTP handshake headers (e.g., Cookie, Origin)
• Metadata for storing request-scoped data
• Dependency injection (when the di feature is enabled)

HTTP Headers

Headers from the WebSocket HTTP handshake can be stored and retrieved:

let context = ConsumerContext::new(conn)
    .with_header("cookie".to_string(), "sessionid=abc123".to_string());

assert_eq!(context.cookie_header(), Some("sessionid=abc123"));

Fields

connection: Arc<WebSocketConnection>

The WebSocket connection

headers: HashMap<String, String>

HTTP handshake headers (e.g., Cookie, Origin)

metadata: HashMap<String, String>

Additional metadata

Implementations

impl ConsumerContext

pub fn new(connection: Arc<WebSocketConnection>) -> ConsumerContext

Create a new consumer context

Examples

use reinhardt_websockets::consumers::ConsumerContext;
use reinhardt_websockets::WebSocketConnection;
use tokio::sync::mpsc;
use std::sync::Arc;

let (tx, _rx) = mpsc::unbounded_channel();
let conn = Arc::new(WebSocketConnection::new("conn_1".to_string(), tx));
let context = ConsumerContext::new(conn);

pub fn with_di_context( connection: Arc<WebSocketConnection>, di_context: Arc<InjectionContext>, ) -> ConsumerContext

Available on crate feature di only.

Create a new consumer context with DI context

This constructor is used when dependency injection is needed in WebSocket handlers.

Examples

use reinhardt_websockets::consumers::ConsumerContext;
use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton = Arc::new(SingletonScope::new());
let di_ctx = Arc::new(InjectionContext::builder(singleton).build());
let context = ConsumerContext::with_di_context(connection, di_ctx);

pub fn with_header(self, key: String, value: String) -> ConsumerContext

Add an HTTP handshake header to the context

Header names are stored as-is. For case-insensitive lookup, callers should normalize keys to lowercase before insertion.

pub fn get_header(&self, key: &str) -> Option<&String>

Get an HTTP handshake header value

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

Get the Cookie header from the HTTP handshake

Convenience method equivalent to get_header("cookie").

pub fn with_metadata(self, key: String, value: String) -> ConsumerContext

Add metadata to the context

pub fn get_metadata(&self, key: &str) -> Option<&String>

Get metadata value

pub fn di_context(&self) -> Option<&Arc<InjectionContext>>

Available on crate feature di only.

Get the DI context if available

pub fn set_di_context(&mut self, ctx: Arc<InjectionContext>)

Available on crate feature di only.

Set the DI context

pub async fn resolve<T>(&self) -> Result<T, WebSocketError>

where T: Injectable + Clone + Send + Sync + 'static,

Available on crate feature di only.

Resolve a dependency with caching

This method extracts the dependency from the DI context. The resolved dependency is cached for the duration of the connection.

Errors

Returns an error if:

• The DI context is not set
• The dependency cannot be resolved

Examples

let db: Arc<DatabaseConnection> = ctx.resolve().await?;

pub async fn resolve_uncached<T>(&self) -> Result<T, WebSocketError>

where T: Injectable + Clone + Send + Sync + 'static,

Available on crate feature di only.

Resolve a dependency without caching

This method is similar to resolve() but creates a fresh instance of the dependency each time.

Errors

Returns an error if:

• The DI context is not set
• The dependency cannot be resolved

Examples

let fresh_service: MyService = ctx.resolve_uncached().await?;

pub async fn try_resolve<T>(&self) -> Option<T>

where T: Injectable + Clone + Send + Sync + 'static,

Available on crate feature di only.

Try to resolve a dependency, returning None if DI context is not available

This is useful for optional dependencies or when you want to gracefully handle the case where DI is not configured.

Examples

if let Some(cache) = ctx.try_resolve::<CacheService>().await {
    // Use cache
} else {
    // Fallback without cache
}