Struct ClosureHandler 

pub struct ClosureHandler<B: Send + Sync + 'static, C: Clone + Send + 'static> {
    pub backend: Arc<B>,
    pub call_fn: Box<BackendCallFn<B, C>>,
}

A JmapHandler that wraps an async closure over a shared backend and forwards CallerCtx to it.

Use this when your handler closures need per-request context — for example, an auth identity that controls which data the handler can access. Closures that don’t need the context can simply ignore the ctx parameter.

Usage

use jmap_server::{ClosureHandler, Dispatcher};
use std::sync::Arc;

#[derive(Clone)]
struct AuthCtx { user_id: String }

let handler: Arc<ClosureHandler<MyBackend, AuthCtx>> =
    Arc::new(ClosureHandler {
        backend: Arc::new(my_backend),
        call_fn: Box::new(|b, call_id, args, ctx| {
            Box::pin(async move {
                // ctx.user_id is available here
                handle_something(&*b, args, &ctx.user_id).await
            })
        }),
    });

let mut dispatcher: Dispatcher<AuthCtx> = Dispatcher::new();
dispatcher.register("MyMethod/get", handler);

Fields

backend: Arc<B>

Shared reference to the backend implementation, passed to the closure on every method call.

call_fn: Box<BackendCallFn<B, C>>

The async closure invoked for each JMAP method call this handler receives from the dispatcher.

Trait Implementations

impl<B: Send + Sync + 'static, C: Clone + Send + 'static> JmapHandler<C> for ClosureHandler<B, C>

fn call( &self, _method: String, call_id: String, args: Value, caller: C, ) -> HandlerFuture

method is the registered method name for this call. A single handler instance may be registered under multiple names (e.g. both "Foo/get" and "Bar/get"); this parameter lets the handler distinguish between them.