rocket-dependency-injection 0.1.0

Small experimental crate for adding dependency injection functionalities to rocket
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::{
    any::type_name,
    sync::{Arc, RwLock},
};

#[cfg(feature = "derive")]
pub use rocket_dependency_injection_derive as derive;

use rocket::{
    fairing::{Fairing, Info, Kind},
    Build, Rocket,
};

pub struct ServiceProvider {
    inner: Rocket<Build>,
}

impl From<Rocket<Build>> for ServiceProvider {
    fn from(value: Rocket<Build>) -> Self {
        ServiceProvider { inner: value }
    }
}

impl ServiceProvider {
    pub fn unwrap<T>(&self) -> T
    where
        T: Clone + Send + Sync + 'static,
    {
        let type_name = type_name::<T>();
        match self.inner.state::<T>() {
            None => self
                .inner
                .state::<Arc<ServiceResolver<_>>>()
                .map(|resolver| resolver.resolve(&self)),
            other => other.map(|item| item.clone()),
        }
        .expect(format!("Failed to resolve service of type {}", type_name).as_str())
    }
}

struct ServiceResolver<TInjectedItem> {
    injection_function: Box<dyn Fn(&ServiceProvider) -> TInjectedItem + Send + Sync + 'static>,
    item: RwLock<Option<TInjectedItem>>,
}

impl<TInjectedItem> ServiceResolver<TInjectedItem>
where
    TInjectedItem: Clone + Send + Sync + 'static,
{
    pub fn new<
        TResolutionFunction: Fn(&ServiceProvider) -> TInjectedItem + Send + Sync + 'static,
    >(
        injection_function: TResolutionFunction,
    ) -> Self {
        Self {
            injection_function: Box::new(injection_function),
            item: RwLock::new(None),
        }
    }

    pub fn resolve(&self, service_provider: &ServiceProvider) -> TInjectedItem {
        {
            if let Some(ref item) = *self.item.read().unwrap() {
                return item.clone();
            }
        }

        let mut guard = self.item.write().unwrap();

        let item = (self.injection_function)(service_provider);
        *guard = Some(item.clone());

        item
    }
}

#[async_trait::async_trait]
impl<TResolvedItem> Fairing for ServiceResolver<TResolvedItem>
where
    TResolvedItem: Clone + Sync + Send + 'static,
{
    fn info(&self) -> Info {
        Info {
            name: Box::leak(format!("{}_resolver", type_name::<TResolvedItem>()).into_boxed_str()),
            kind: Kind::Ignite,
        }
    }

    async fn on_ignite(&self, rocket: Rocket<Build>) -> Result<Rocket<Build>, Rocket<Build>> {
        let service_provider: ServiceProvider = rocket.into();
        let item = (self.injection_function)(&service_provider);
        Ok(service_provider.inner.manage(item))
    }
}

pub trait Resolve {
    fn resolve(service_provider: &ServiceProvider) -> Self;
}

pub trait RocketExtension {
    fn add_with<
        TInjectedItem: Clone + Sync + Send + 'static,
        TInjectionFunction: Fn(&ServiceProvider) -> TInjectedItem + Send + Sync + 'static,
    >(
        self,
        injection_function: TInjectionFunction,
    ) -> Self;

    fn add<TResolve: Resolve + Send + Sync + Clone + 'static>(self) -> Self;
}

impl RocketExtension for Rocket<Build> {
    fn add_with<
        TInjectedItem: Clone + Sync + Send + 'static,
        TInjectionFunction: Fn(&ServiceProvider) -> TInjectedItem + Send + Sync + 'static,
    >(
        self,
        injection_function: TInjectionFunction,
    ) -> Self {
        let service_resolver = Arc::new(ServiceResolver::new(injection_function));

        self.attach(service_resolver.clone())
            .manage(service_resolver)
    }

    fn add<TResolve: Resolve + Send + Sync + Clone + 'static>(self) -> Self {
        self.add_with(TResolve::resolve)
    }
}