shield-axum 0.2.5

Axum integration for Shield.
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

use axum::{extract::FromRequestParts, http::request::Parts};
use shield::{ConfigurationError, Session, Shield, ShieldError, User};

use crate::error::RouteError;

pub struct ExtractShield<U: User>(pub Shield<U>);

impl<S: Send + Sync, U: User + Clone + 'static> FromRequestParts<S> for ExtractShield<U> {
    type Rejection = RouteError;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        parts
            .extensions
            .get::<Shield<U>>()
            .cloned()
            .map(ExtractShield)
            .ok_or(ShieldError::Configuration(ConfigurationError::Invalid(
                "Can't extract Shield. Is `ShieldLayer` enabled?".to_owned(),
            )))
            .map_err(RouteError::from)
    }
}

pub struct ExtractSession(pub Session);

impl<S: Send + Sync> FromRequestParts<S> for ExtractSession {
    type Rejection = RouteError;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        parts
            .extensions
            .get::<Session>()
            .cloned()
            .map(ExtractSession)
            .ok_or(ShieldError::Configuration(ConfigurationError::Invalid(
                "Can't extract Shield session. Is `ShieldLayer` enabled?".to_owned(),
            )))
            .map_err(RouteError::from)
    }
}

pub struct ExtractUser<U: User>(pub Option<U>);

impl<S: Send + Sync, U: User + Clone + 'static> FromRequestParts<S> for ExtractUser<U> {
    type Rejection = RouteError;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        parts
            .extensions
            .get::<Option<U>>()
            .cloned()
            .map(ExtractUser)
            .ok_or(ShieldError::Configuration(ConfigurationError::Invalid(
                "Can't extract Shield user. Is `ShieldLayer` enabled?".to_owned(),
            )))
            .map_err(RouteError::from)
    }
}

pub struct UserRequired<U: User>(pub U);

impl<S: Send + Sync, U: User + Clone + 'static> FromRequestParts<S> for UserRequired<U> {
    type Rejection = RouteError;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        parts
            .extensions
            .get::<Option<U>>()
            .cloned()
            .ok_or(ShieldError::Configuration(ConfigurationError::Invalid(
                "Can't extract Shield user. Is `ShieldLayer` enabled?".to_owned(),
            )))
            .and_then(|user| user.ok_or(ShieldError::Unauthorized))
            .map(UserRequired)
            .map_err(RouteError::from)
    }
}