Struct Inject 

pub struct Inject<M: ModuleInterface + HasComponent<I> + ?Sized, I: Interface + ?Sized>(/* private fields */);

Used to retrieve a reference to a component from a shaku Module. The module should be stored in Axum state, wrapped in an Arc (Arc<MyModule>). This Arc<MyModule> must implement FromRef<S> where S is the Axum state type.

Use this struct as an extractor.

Example

use axum::{routing::get, Router};
use axum::extract::{Extension, FromRef};
use shaku::{module, Component, Interface};
use shaku_axum::Inject;
use std::net::SocketAddr;
use std::sync::Arc;
use tokio::net::TcpListener;

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 = []
    }
}

#[derive(Clone)]
struct AppState {
    module: Arc<HelloModule>,
}

impl FromRef<AppState> for Arc<HelloModule> {
    fn from_ref(app_state: &AppState) -> Arc<HelloModule> {
        app_state.module.clone()
    }
}

async fn hello(hello_world: Inject<HelloModule, dyn HelloWorld>) -> String {
    hello_world.greet()
}

#[tokio::main]
async fn main() {
    let module = Arc::new(HelloModule::builder().build());
    let state = AppState { module };

    let app = Router::new()
        .route("/", get(hello))
        .with_state(state);

    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
    axum::serve(listener, app.into_make_service())
        .await
        .unwrap();
}

Trait Implementations

impl<M: ModuleInterface + HasComponent<I> + ?Sized, I: Interface + ?Sized> Deref for Inject<M, I>

type Target = I

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S, M, I> FromRequestParts<S> for Inject<M, I>

where S: Send + Sync, M: ModuleInterface + HasComponent<I> + ?Sized, I: Interface + ?Sized, Arc<M>: FromRef<S>,

type Rejection = (StatusCode, String)

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts( _req: &mut Parts, state: &S, ) -> Result<Self, Self::Rejection>

Perform the extraction.