Struct ArclyPluginContext 

pub struct ArclyPluginContext { /* private fields */ }

Implementations

impl ArclyPluginContext

pub fn provide<T: Send + Sync + 'static>(&mut self, value: T)

Inject a singleton of type T into the DI container. Resolves later via Inject<T> in any controller / service / interceptor.

Order: every plugin’s on_init runs first, then all provide<T> closures are applied in declaration order, then the container freezes. So one plugin can read another’s provision in on_start but not in on_init.

If T already has an #[Injectable] provider, launch fails loudly — use override_provider to replace it intentionally.

pub fn override_provider<T: Send + Sync + 'static>(&mut self, value: T)

Replace a core #[Injectable] provider with this instance. The descriptor is discarded; every Inject<T> in the app resolves to the plugin’s value. Happens before the container freezes, so the swap is race-free and the hot path stays lock-free.

pub fn add_interceptor(&mut self, ic: impl Interceptor)

Attach a boundary filter that runs on every request before the body is read — the cheap early-reject point for signature checks, IP allowlists, and rate limits. Returning Break(resp) short-circuits without paying for body buffering or context assembly. Ergonomic twin of Self::register_global_interceptor: takes ownership and leaks internally (interceptors are process-lifetime objects) — no Box::leak ceremony in plugin code.

pub fn add_boundary_filter(&mut self, f: impl BoundaryFilter)

Ergonomic twin of Self::register_boundary_filter: takes ownership and leaks internally.

pub fn register_boundary_filter(&mut self, f: &'static dyn BoundaryFilter)

pub fn add_route<F, Fut>( &mut self, method: HttpMethod, path: impl Into<String>, handler: F, )

where F: Fn(RequestContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register a route. The handler receives a fully-built RequestContext — including DI access via ctx.inject::<T>() — and returns a Response. The path is mounted verbatim under the application root.

The path may be built at runtime (e.g. a config-driven prefix); it is leaked to &'static str, which is fine because routes live for the whole process anyway.

pub fn add_get<F, Fut>(&mut self, path: impl Into<String>, handler: F)

where F: Fn(RequestContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Shortcut: register a GET.

pub fn modify_openapi<F>(&mut self, f: F)

where F: FnOnce(&mut Value) + Send + Sync + 'static,

Mutate the assembled OpenAPI document at launch time.

pub fn require_env(&self, key: &str) -> Result<String, PluginError>

Read a required environment variable.

Returns Err(PluginError) with stage Init if the variable is absent or contains non-UTF-8 bytes, so callers can propagate it cleanly with ?.

pub fn env_or(&self, key: &str, default: impl Into<String>) -> String

Read an environment variable with a fallback default.

pub fn register_global_interceptor(&mut self, ic: &'static dyn Interceptor)

Attach an interceptor that fires on every mounted route — macro routes and plugin-registered routes alike. Global interceptors compose as the outermost layers, in registration order (first registered = outermost), around any per-route #[UseInterceptors] chain.

Trait Implementations

impl Default for ArclyPluginContext

fn default() -> Self

Returns the “default value” for a type.