Struct ProviderRegistry

Source

pub struct ProviderRegistry { /* private fields */ }

Implementations§

Source §

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

NestJS useValue: register a pre-built singleton without an Injectable impl.

Lifecycle hooks do not run for this registration (any T is accepted, so there is no hook impl to call). If T implements ProviderLifecycle, use Self::register_use_value_with_lifecycle to have the framework drive its hooks.

Source

pub fn register_use_factory<T, F>(&mut self, scope: ProviderScope, factory: F)
where T: Send + Sync + 'static, F: Fn(&ProviderRegistry) -> Arc<T> + Send + Sync + 'static,

NestJS useFactory: register a provider from a synchronous closure Fn(&ProviderRegistry) -> Arc<T>.

The closure may call Self::get for dependencies. For async initialization of T, keep construct/factory cheap and use Injectable::on_module_init on T, or load module options with ConfigurableModuleBuilder::for_root_async. Do not block the async runtime inside the factory.

Prefer Self::register when the provider is a normal #[injectable] type.

Lifecycle hooks do not run for this registration (any T is accepted, so there is no hook impl to call). If T implements ProviderLifecycle, use Self::register_use_factory_with_lifecycle to have the framework drive its hooks.

Source

pub fn register_use_value_with_lifecycle<T>(&mut self, value: Arc<T>)
where T: ProviderLifecycle + Send + Sync + 'static,

NestJS useValue with lifecycle hooks: like Self::register_use_value, but the singleton’s ProviderLifecycle hooks are driven by the framework (module init/destroy, application bootstrap/shutdown) in the same order as Injectable hooks.

Source

pub fn register_use_factory_with_lifecycle<T, F>( &mut self, scope: ProviderScope, factory: F, )
where T: ProviderLifecycle + Send + Sync + 'static, F: Fn(&ProviderRegistry) -> Arc<T> + Send + Sync + 'static,

NestJS useFactory with lifecycle hooks: like Self::register_use_factory, but T’s ProviderLifecycle hooks are driven by the framework. Hooks run only while T is singleton-scoped (matching Injectable providers: request/transient instances have no framework-driven lifecycle).

Source

pub fn register_use_class<T>(&mut self)
where T: Injectable + Send + Sync + 'static,

NestJS useClass: equivalent to Self::register for a normal injectable type.

Source

pub fn override_provider<T>(&mut self, instance: Arc<T>)
where T: Injectable + Send + Sync + 'static,

Override a provider with a concrete instance (testing utility).

This is primarily intended for TestingModule-style overrides where you want to replace an injectable with a mock instance.

The override preserves the provider’s declared scope (T::scope()): a request- or transient-scoped provider keeps its per-request / per-resolution semantics, and every resolution hands out the given instance — an override explicitly targets one concrete object, so request-scoped overrides share that instance across requests.

Source

pub fn get<T>(&self) -> Arc<T> ⓘ
where T: Send + Sync + 'static,

Resolves a provider, panicking when it cannot be resolved. Prefer Self::try_get at call sites that can handle absence.

Panics with a distinct, actionable message when a Request-scoped provider is resolved outside a request scope (e.g. from a background task spawned with bare tokio::spawn) — run such work through spawn_with_request_scope instead.

When called during another provider’s construction (inside construct or a useFactory closure), the edge constructor -> requested is recorded so lifecycle hooks can run in dependency order (see Self::run_on_module_init).

Source

pub fn try_get<T>(&self) -> Option<Arc<T>>
where T: Send + Sync + 'static,

Fallible resolution: returns None instead of panicking when the provider cannot be resolved — either it is not registered, or it is Request-scoped and this task has no request scope (a bare tokio::spawn background task, a standalone runtime context). Use spawn_with_request_scope to give background work a scope.

Source

pub fn registered_type_ids(&self) -> Vec<TypeId>

All registered provider TypeId keys (NestJS discovery-style introspection), in registration order.

Source

pub fn registered_type_names(&self) -> Vec<&'static str>

Human-readable type names for registered providers (debug / tooling), in registration order.

Source

pub fn provider_summaries(&self) -> Vec<ProviderSummary>

Pair of (type_name, scope) for every registered provider, in registration order. Powers the nestrs::admin sidecar’s GET /__nestrs/providers endpoint and nestrs-mcp’s get_app_providers tool.

Source

pub fn absorb(&mut self, other: ProviderRegistry)

Source

pub fn absorb_exported(&mut self, other: ProviderRegistry, exported: &[TypeId])

Source

pub fn absorb_exported_from( &mut self, other: &ProviderRegistry, exported: &[TypeId], )

Like Self::absorb_exported, but clones bindings from other so the source registry is kept intact (used for lazy modules and shared provider cells).

Source

pub fn eager_init_singletons(&self)

Construct all singleton providers (so their lifecycle hooks can run deterministically), in registration order.

Source

pub async fn run_on_module_init(&self)

Source

pub async fn run_on_module_destroy(&self)

Destroy hooks run in reverse initialization order (dependencies torn down after dependents).

Source

pub async fn run_on_application_bootstrap(&self)

Source

pub async fn run_on_before_application_shutdown(&self)

NestJS beforeApplicationShutdown mirror: fires BEFORE run_on_application_shutdown and run_on_module_destroy during graceful shutdown. Reverse initialization order so that providers holding resources release them after their dependents have shut down.

Source