shaku

To use Shaku, you define interfaces using traits that inherit from shaku::Interface, implement them in structs using the #[derive(Component)] macro, and register them in a module using the module! macro.

For components that require runtime parameters (like configuration strings or numbers), you can use the .with_component_parameters::<T>(...) method on the module builder during initialization. Dependencies within components are injected using the #[shaku(inject)] attribute on fields.

use shaku::{module, Component, Interface, HasComponent};
use std::sync::Arc;

trait Logger: Interface {
    fn log(&self, content: &str);
}

trait DateLogger: Interface {
    fn log_date(&self);
}

#[derive(Component)]
#[shaku(interface = Logger)]
struct LoggerImpl;

impl Logger for LoggerImpl {
    fn log(&self, content: &str) {
        println!("{}", content);
    }
}

#[derive(Component)]
#[shaku(interface = DateLogger)]
struct DateLoggerImpl {
    #[shaku(inject)]
    logger: Arc<dyn Logger>,
    today: String,
    year: usize,
}

impl DateLogger for DateLoggerImpl {
    fn log_date(&self) {
        self.logger.log(&format!("Today is {}, {}", self.today, self.year));
    }
}

module! {
    MyModule {
        components = [LoggerImpl, DateLoggerImpl],
        providers = []
    }
}

fn main() {
    let module = MyModule::builder()
        .with_component_parameters::<DateLoggerImpl>(DateLoggerImplParameters {
            today: "Jan 26".to_string(),
            year: 2020
        })
        .build();

    let date_logger: &dyn DateLogger = module.resolve_ref();
    date_logger.log_date();
}

To use services managed by a shaku Module within a Rocket request handler, use the InjectProvided<M, I> request guard.

Requirements

1. Module Storage: The shaku Module must be stored in Rocket's managed state using .manage(). It is recommended to wrap the module in a Box (e.g., Box::new(module)) to allow for dynamic module implementations if needed.
2. Generic Parameters:
   • M: The shaku Module type (must implement ModuleInterface and HasProvider<I>).
   • I: The interface/trait of the service you want to inject (e.g., dyn MyTrait).

Behavior

• If the module is found in Rocket's state and the provider is successfully resolved, the guard succeeds.
• If the module is missing from the state or the provider cannot be provided, the request will fail with a 500 Internal Server Error and the error message from shaku.

#[macro_use] extern crate rocket;

use shaku::{module, Provider};
use shaku_rocket::InjectProvided;

trait HelloWorld {
    fn greet(&self) -> String;
}

#[derive(Provider)]
#[shaku(interface = HelloWorld)]
struct HelloWorldImpl;

impl HelloWorld for HelloWorldImpl {
    fn greet(&self) -> String {
        "Hello, world!".to_owned()
    }
}

module! {
    HelloModule {
        components = [],
        providers = [HelloWorldImpl]
    }
}

#[get("/")]
fn hello(hello_world: InjectProvided<HelloModule, dyn HelloWorld>) -> String {
    hello_world.greet()
}

#[rocket::launch]
fn rocket() -> _ {
    let module = HelloModule::builder().build();

    rocket::build()
        .manage(Box::new(module))
        .mount("/", routes![hello])
}

To use shaku components within Rocket request handlers, use the Inject request guard.

Requirements

1. Module Storage: The shaku module must be stored in Rocket's managed state as a Box<M>, where M is your module type.
2. Type Signature: The Inject guard requires two generic parameters:
   • M: The module type (must implement ModuleInterface and HasComponent<I>).
   • I: The component interface (must implement Interface).

Usage Pattern

Define your component and module using shaku macros, then include Inject<Module, dyn Interface> in your Rocket handler arguments. Because Inject implements Deref, you can call the interface methods directly on the guard.

#[macro_use] extern crate rocket;

use shaku::{module, Component, Interface};
use shaku_rocket::Inject;

trait HelloWorld: Interface {
    fn greet(&self) -> String;
}

#[derive(Component)]
#[shaku(interface = HelloWorld)]
struct HelloWorldImpl;

impl HelloWorld for HelloWorldImpl {
    fn greet(&self) -> String {
        "Hello, world!".to_owned()
    }
}

module! {
    HelloModule {
        components = [HelloWorldImpl],
        providers = []
    }
}

// The handler uses Inject as a request guard
#[get("/")]
fn hello(hello_world: Inject<HelloModule, dyn HelloWorld>) -> String {
    hello_world.greet()
}

#[rocket::launch]
fn rocket() -> _ {
    let module = HelloModule::builder().build();

    rocket::build()
        .manage(Box::new(module)) // Module must be managed as Box<M>
        .mount("/", routes![hello])
}

To use shaku components within Actix-web handlers, use the Inject<M, I> extractor.

Requirements

1. Module Storage: The shaku module (M) must be stored in Actix's app data, wrapped in an Arc.
2. Generic Parameters:
   • M: The module type that implements ModuleInterface and HasComponent<I>.
   • I: The component interface type (e.g., dyn MyInterface).

Usage Pattern

Define your component and module as usual, then include Inject<YourModule, dyn YourInterface> as an argument in your Actix handler function. The Inject struct implements Deref, so you can call interface methods directly on the extractor instance.

Example

use actix_web::{App, HttpServer, web};
use shaku::{module, Component, Interface};
use shaku_actix::Inject;
use std::sync::Arc;

trait HelloWorld: Interface {
    fn greet(&self) -> String;
}

#[derive(Component)]
#[shaku(interface = HelloWorld)]
struct HelloWorldImpl;

impl HelloWorld for HelloWorldImpl {
    fn greet(&self) -> String {
        "Hello, world!".to_owned()
    }
}

module! {
    HelloModule {
        components = [HelloWorldImpl],
        providers = []
    }
}

// The handler uses Inject to retrieve the component
async fn hello(hello_world: Inject<HelloModule, dyn HelloWorld>) -> String {
    hello_world.greet()
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // The module must be wrapped in Arc and added to app_data
    let module = Arc::new(HelloModule::builder().build());

    HttpServer::new(move || {
        App::new()
            .app_data(module.clone())
            .route("/", web::get().to(hello))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}