Struct App 

pub struct App;

Application container facade

Provides static methods for service registration and resolution. Uses a global container with thread-local test overrides.

Example

use kit::{App, bind, singleton};

// Register services at startup using macros
singleton!(DatabaseConnection::new(&url));
bind!(dyn HttpClient, RealHttpClient::new());

// Resolve anywhere
let db: DatabaseConnection = App::get().unwrap();
let client: Arc<dyn HttpClient> = App::make::<dyn HttpClient>().unwrap();

Implementations

impl App

pub fn init()

Initialize the application container

Should be called once at application startup. This is automatically called by Server::from_config().

pub fn singleton<T: Any + Send + Sync + 'static>(instance: T)

Register a singleton instance (shared across all resolutions)

Example

App::singleton(DatabaseConnection::new(&url));

pub fn factory<T, F>(factory: F)

where T: Any + Send + Sync + 'static, F: Fn() -> T + Send + Sync + 'static,

Register a factory binding (new instance per resolution)

Example

App::factory(|| RequestLogger::new());

pub fn bind<T: ?Sized + Send + Sync + 'static>(instance: Arc<T>)

Bind a trait object to a concrete implementation (as singleton)

Example

App::bind::<dyn HttpClient>(Arc::new(RealHttpClient::new()));

pub fn bind_factory<T: ?Sized + Send + Sync + 'static, F>(factory: F)

where F: Fn() -> Arc<T> + Send + Sync + 'static,

Bind a trait object to a factory

Example

App::bind_factory::<dyn HttpClient>(|| Arc::new(RealHttpClient::new()));

pub fn get<T: Any + Send + Sync + Clone + 'static>() -> Option<T>

Resolve a concrete type

Checks test overrides first, then falls back to global container.

Example

let db: DatabaseConnection = App::get().unwrap();

pub fn make<T: ?Sized + Send + Sync + 'static>() -> Option<Arc<T>>

Resolve a trait binding - returns Arc

Checks test overrides first, then falls back to global container.

Example

let client: Arc<dyn HttpClient> = App::make::<dyn HttpClient>().unwrap();

pub fn resolve<T: Any + Send + Sync + Clone + 'static>() -> Result<T, FrameworkError>

Resolve a concrete type, returning an error if not found

This allows using the ? operator in controllers and services for automatic error propagation with proper HTTP responses.

Example

pub async fn index(_req: Request) -> Response {
    let service = App::resolve::<MyService>()?;
    // ...
}

pub fn resolve_make<T: ?Sized + Send + Sync + 'static>() -> Result<Arc<T>, FrameworkError>

Resolve a trait binding, returning an error if not found

This allows using the ? operator for trait object resolution.

Example

let client: Arc<dyn HttpClient> = App::resolve_make::<dyn HttpClient>()?;

pub fn has<T: Any + 'static>() -> bool

Check if a concrete type is registered

pub fn has_binding<T: ?Sized + 'static>() -> bool

Check if a trait binding is registered

pub fn boot_services()

Boot all auto-registered services

This registers all services marked with #[service(ConcreteType)]. Called automatically by Server::from_config().