nject Rust

Simple zero cost dependency injection library made for rust

Install

Add the following to your Cargo.toml: toml [dependencies] nject = "0.1"

Use cases

Removes the need to specify dependencies across your modules

```rust 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

```rust 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

```rust 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> { boxeddep: Box, refdep: &'a dyn Greeter, }

[provider]

[provide(Box, Box::::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

```rust use nject::{injectable, provider};

[injectable]

struct DepOne;

[injectable]

struct Facade { dep: T, }

[provider]

struct Provider;

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

```

Works with generic providers

```rust 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 devfacade: Facade = Provider(&DevGreeter).inject(); let prodfacade: Facade = Provider(&ProdGreeter).inject(); } ```

Easily inject non-injectable dependencies

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

[inject(Self { noninjectablevalue: 123 })]

struct NonInjectableWithInjectAttr { noninjectablevalue: i32, }

struct NonInjectable { noninjectablevalue: i32, }

[injectable]

struct Facade { depfrominjected: NonInjectableWithInjectAttr, #[inject(NonInjectable { noninjectablevalue: 456 })] depfrominjectattr: NonInjectable, #[inject(NonInjectableWithInjectAttr { noninjectablevalue: 789 })] depfrominjectattr_override: NonInjectableWithInjectAttr, }

[provider]

struct Provider;

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

Examples

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

Credits