nject-macro 0.1.0

Zero cost dependency injection macros
Documentation

nject Rust

Simple zero cost dependency injection library made for rust

Install

Add the following to your Cargo.toml:

[dependencies]

nject = "0.1"

Use cases

Removes the need to specify dependencies across your modules

use nject::{injectable, provider};

#[injectable]
struct DepOne;

#[injectable]
struct DepTwo {
    dep: DepOne,
}

#[injectable]
struct Facade {
    dep: DepTwo,
}

#[provider]
struct Provider;

fn main() {
    let _facade: Facade = Provider.inject();
}

Works with lifetimes - enables shared dependencies

use nject::{injectable, provide, provider};

#[injectable]
struct DepOne;

#[injectable]
struct Facade<'a> {
    dep: &'a DepOne,
}

#[provider]
#[provide(&'a DepOne, self.shared)]
struct Provider<'a> {
    shared: &'a DepOne,
}

fn main() {
    let provider = Provider { shared: &DepOne };
    let _facade: Facade = provider.inject();
}

Works with dyn traits

use nject::{injectable, provide, provider};

trait Greeter {
    fn greet(&self);
}

#[injectable]
struct GreeterOne;

impl Greeter for GreeterOne {
    fn greet(&self) {
        println!("Greeting");
    }
}

#[injectable]
struct Facade<'a> {
    boxed_dep: Box<dyn Greeter>,
    ref_dep: &'a dyn Greeter,
}

#[provider]
#[provide(Box<dyn Greeter>, Box::<GreeterOne>::new(self.inject()))]
#[provide(&'prov dyn Greeter, &self.greeter)]
struct Provider {
    greeter: GreeterOne,
}

fn main() {
    let provider = Provider { greeter: GreeterOne };
    let _facade: Facade = provider.inject();
}

Works with generics

use nject::{injectable, provider};

#[injectable]
struct DepOne;

#[injectable]
struct Facade<T> {
    dep: T,
}

#[provider]
struct Provider;

fn main() {
    let _facade: Facade<DepOne> = Provider.inject();
}

Works with generic providers

use nject::{injectable, provide, provider};

trait Greeter {
    fn greet(&self);
}

#[injectable]
struct DevGreeter;

impl Greeter for DevGreeter {
    fn greet(&self) {
        println!("Greeting Dev");
    }
}

#[injectable]
struct ProdGreeter;

impl Greeter for ProdGreeter {
    fn greet(&self) {
        println!("Greeting production");
    }
}

#[injectable]
struct Facade<'a> {
    dep: &'a dyn Greeter,
}

#[provider]
#[provide(&'a dyn Greeter, self.0)]
struct Provider<'a, T: Greeter>(&'a T);

fn main() {
    let _dev_facade: Facade = Provider(&DevGreeter).inject();
    let _prod_facade: Facade = Provider(&ProdGreeter).inject();
}

Easily inject non-injectable dependencies

use nject::{inject, injectable, provide, provider};

#[inject(Self { non_injectable_value: 123 })]
struct NonInjectableWithInjectAttr {
    non_injectable_value: i32,
}

struct NonInjectable {
    non_injectable_value: i32,
}

#[injectable]
struct Facade {
    dep_from_injected: NonInjectableWithInjectAttr,
    #[inject(NonInjectable { non_injectable_value: 456 })]
    dep_from_inject_attr: NonInjectable,
    #[inject(NonInjectableWithInjectAttr { non_injectable_value: 789 })]
    dep_from_inject_attr_override: NonInjectableWithInjectAttr,
}

#[provider]
struct Provider;

fn main() {
    let _facade = Provider.inject::<Facade>();
}

Examples

You can look into the axum example for a web API use case.

Credits