Struct Container 

pub struct Container { /* private fields */ }

The dependency injection container.

The container holds the typed singleton store, the provider registry, and registered destructors for #[injectable(pre_destruct)] hooks. It is constructed via Container::builder().

Resolution Strategy

• Types implementing Injectable are resolved via static providers
• Types registered via ContainerBuilder::register() are resolved via the dynamic provider registry
• All other types return MissingDependency errors

Lifecycle

• Use Container::resolve to obtain instances
• Use Container::shutdown to run #[injectable(pre_destruct)] hooks in reverse construction order

Example

// Types you own: derive Injectable
#[injectable]
#[derive(Default)]
pub struct UserService { ... }

// Types you don't own: register a provider
let container = Container::builder()
    .register(DynProvider::new(|| {
        Ok(reqwest::Client::new())
    }))
    .build()
    .await?;

let service = container.resolve::<UserService>().await?;
let client = container.resolve_external::<reqwest::Client>().await?;

// On shutdown, call pre_destruct hooks
container.shutdown().await;

Implementations

impl Container

pub fn builder() -> ContainerBuilder

Create a new container builder.

pub async fn resolve<T: Injectable>(&self) -> InjectableResult<T>

Resolve a type that implements Injectable.

This is the primary resolution method for types you own that use #[injectable].

Example

let service = app.resolve::<UserService>().await?;

pub async fn resolve_external<T: Send + Sync + 'static>( &self, ) -> InjectableResult<T>

Resolve an external type from the provider registry.

Use this for types that don’t implement Injectable but have been registered via ContainerBuilder::register.

Example

let client = app.resolve_external::<reqwest::Client>().await?;

pub async fn resolve_external_with_token<T: Send + Sync + 'static>( &self, token: &str, ) -> InjectableResult<T>

Resolve a named external type by token.

Use this when multiple providers of the same type were registered with different tokens via ContainerBuilder::register("token", DynProvider::…).

Example

let primary: Pool = container.resolve_external_with_token("primary").await?;
let replica:  Pool = container.resolve_external_with_token("replica").await?;

pub async fn try_resolve_external_with_token<T: Send + Sync + 'static>( &self, token: &str, ) -> InjectableResult<Option<T>>

Resolve a named external type by token, returning None if not registered.

pub fn context(&self) -> &ResolveContext

Get a reference to the internal resolve context.

Useful for manual extraction in advanced scenarios.

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

Returns the names of all #[injectable] types registered in the container.

This includes every type that was annotated with #[injectable] and linked into the binary — useful for debugging MissingDependency errors and asserting DI registration in tests.

Example

let container = Container::builder().build().await?;
assert!(container.registered_types().contains(&"Database"));

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

Resolve a type, returning None instead of an error if it is not registered.

Maps MissingDependency → Ok(None) and propagates all other errors.

pub async fn try_resolve_external<T: Send + Sync + 'static>( &self, ) -> InjectableResult<Option<T>>

Resolve an external type, returning None instead of an error if not registered.

pub async fn shutdown(&self) -> InjectableResult<()>

Shut down the container, running all #[injectable(pre_destruct)] hooks.

Hooks are called in reverse construction order — the most recently constructed instance is destroyed first. This ensures that dependencies are not destroyed before the types that depend on them.

All destructors are called even if some fail (best-effort cleanup). If any hooks fail, returns InjectableError::ShutdownFailed containing all accumulated errors.

Example

let container = Container::builder()
    .build()
    .await?;

let service = container.resolve::<Database>().await?;

// On application shutdown:
container.shutdown().await?;

pub async fn destructor_count(&self) -> usize

Returns the number of registered destructors.

This counts instances that have #[injectable(has_pre_destruct)] and have been resolved through this container.

Trait Implementations

impl Clone for Container

fn clone(&self) -> Container

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Container

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.