filigree 0.4.1

Filigree web application framework
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

use std::sync::Arc;

use axum::{extract::Request, response::Response};
use tower::{Layer, Service};

use super::{lookup::AuthLookup, AuthInfo, AuthQueries};

/// A type-erased container for AuthQueries
pub type AuthQueriesContainer<INFO> = Arc<dyn AuthQueries<AuthInfo = INFO>>;

/// A layer that inserts the auth lookup object into the request, for later
/// use by the Authed extractor.
pub struct AuthLayer<INFO: AuthInfo> {
    queries: AuthQueriesContainer<INFO>,
}

impl<INFO: AuthInfo> Clone for AuthLayer<INFO> {
    fn clone(&self) -> Self {
        Self {
            queries: self.queries.clone(),
        }
    }
}

impl<INFO: AuthInfo> AuthLayer<INFO> {
    /// Create a new AuthLayer with the provided lookup object
    pub fn new(queries: AuthQueriesContainer<INFO>) -> Self {
        Self { queries }
    }
}

impl<S: Clone, INFO: AuthInfo> Layer<S> for AuthLayer<INFO> {
    type Service = AuthService<S, INFO>;

    fn layer(&self, inner: S) -> Self::Service {
        AuthService {
            queries: self.queries.clone(),
            inner,
        }
    }
}

/// A middleware service for fetching authorization info
pub struct AuthService<S: Clone, INFO: AuthInfo> {
    queries: AuthQueriesContainer<INFO>,
    inner: S,
}

impl<S: Clone, INFO: AuthInfo> Clone for AuthService<S, INFO> {
    fn clone(&self) -> Self {
        Self {
            queries: self.queries.clone(),
            inner: self.inner.clone(),
        }
    }
}

impl<S, INFO: AuthInfo + 'static> Service<Request> for AuthService<S, INFO>
where
    S: Service<Request, Response = Response> + Send + Clone + 'static,
    S::Response: 'static,
    S::Future: Send + 'static,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = S::Future;

    fn poll_ready(
        &mut self,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, mut request: Request) -> Self::Future {
        let lookup = AuthLookup::new(self.queries.clone());
        request.extensions_mut().insert(Arc::new(lookup));
        self.inner.call(request)
    }
}