auto-di

Automatic dependency injection for Rust, backed by a global inventory registry and async-safe initialization. The core API intentionally stays small: use #[component] for constructor injection and #[bean] for factory injection.

Components and constructor injection

use std::sync::Arc;
use auto_di::component;

trait Users: Send + Sync {}

#[component(name = "postgres", primary)]
fn users() -> Arc<dyn Users> {
    Arc::new(PostgresUsers)
}

#[component(eager, post_construct = "start", pre_destroy = "stop")]
impl UserService {
    fn new(#[qualifier("postgres")] users: Arc<dyn Users>) -> Self {
        Self { users }
    }

    async fn start(&self) {}
    async fn stop(&self) {}
}

#[component] supports these options:

• name = "..."
• primary
• scope = "singleton" | "prototype" | "request"
• eager
• profile = "development"
• condition = "ENV_KEY" or condition = "ENV_KEY=value"
• post_construct = "async_method"
• pre_destroy = "async_method"

Constructors accept Arc<T>, Option<Arc<T>>, Vec<Arc<T>>, Provider<T>, and Lazy<T>. Both sync and async constructors are supported.

The older #[service], #[repository], and #[singleton] names remain as compatibility aliases, but they have no separate behavior.

Configuration beans

Beans do not need a configuration block. They can be declared in any module:

#[bean]
fn database_pool() -> DatabasePool {
    DatabasePool::new()
}

Use #[configuration] only when grouping related bean factories is useful.

Any ordinary type can also own bean methods. #[beans] only marks the impl for macro expansion; the type is not required to represent configuration:

#[derive(Default)]
struct DependencyFactory;

#[beans]
impl DependencyFactory {
    #[bean]
    fn database(&self) -> Database {
        Database::new()
    }
}

Components automatically discover nested beans:

#[component]
impl UserService {
    fn new(repository: Arc<UserRepository>) -> Self {
        Self { repository }
    }

    #[bean]
    fn user_cache(&self) -> UserCache {
        UserCache::new()
    }
}

#[derive(Default)]
struct Beans;

#[configuration]
impl Beans {
    #[bean]
    fn config(&self) -> Config { Config::default() }

    #[bean(name = "main", primary)]
    async fn database(&self, config: Arc<Config>) -> Database {
        Database::connect(&config).await
    }
}

Environment properties

#[configuration_properties("database")]
struct DatabaseProperties {
    url: String,       // DATABASE_URL
    pool_size: usize,  // DATABASE_POOL_SIZE
}

Application and request scopes

#[application]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let service = auto_di::resolve::<UserService>().await?;
    Ok(())
}

let request = auto_di::global_container()?.request_context();
let bean = request.resolve::<RequestBean>().await?;

Active profiles come from comma-separated APP_PROFILES, or can be selected explicitly with Container::with_profiles(...).