lenso-platform-http 0.1.1

HTTP primitives for the Lenso backend 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
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
130
131
132
133
134
135
136
137

use crate::{ApiErrorResponse, HttpRequestContext};
use axum::extract::FromRequestParts;
use axum::http::request::Parts;
use platform_core::{ActorContext, AppError, ErrorCode};

#[derive(Debug, Clone)]
pub struct OptionalActor(pub ActorContext);

#[derive(Debug, Clone)]
pub struct AuthenticatedActor(pub ActorContext);

#[derive(Debug, Clone)]
pub struct UserActor {
    pub user_id: String,
    pub scopes: Vec<String>,
}

#[derive(Debug, Clone)]
pub struct ServiceActor {
    pub service_id: String,
    pub scopes: Vec<String>,
}

#[derive(Debug, Clone)]
pub enum AdminActor {
    Service {
        service_id: String,
        scopes: Vec<String>,
    },
    System,
}

impl<S> FromRequestParts<S> for OptionalActor
where
    S: Send + Sync,
{
    type Rejection = ApiErrorResponse;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        let HttpRequestContext(ctx) = HttpRequestContext::from_request_parts(parts, state).await?;
        Ok(Self(ctx.actor))
    }
}

impl<S> FromRequestParts<S> for AuthenticatedActor
where
    S: Send + Sync,
{
    type Rejection = ApiErrorResponse;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        let HttpRequestContext(ctx) = HttpRequestContext::from_request_parts(parts, state).await?;
        match ctx.actor {
            ActorContext::Anonymous => Err(ApiErrorResponse::with_context(
                AppError::new(ErrorCode::Unauthorized, "Authentication is required"),
                &ctx,
            )),
            actor => Ok(Self(actor)),
        }
    }
}

impl<S> FromRequestParts<S> for UserActor
where
    S: Send + Sync,
{
    type Rejection = ApiErrorResponse;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        let HttpRequestContext(ctx) = HttpRequestContext::from_request_parts(parts, state).await?;
        match ctx.actor {
            ActorContext::Anonymous => Err(ApiErrorResponse::with_context(
                AppError::new(ErrorCode::Unauthorized, "Authentication is required"),
                &ctx,
            )),
            ActorContext::User { user_id, scopes } => Ok(Self { user_id, scopes }),
            ActorContext::Service { .. } | ActorContext::System => {
                Err(ApiErrorResponse::with_context(
                    AppError::new(ErrorCode::Forbidden, "User authentication is required"),
                    &ctx,
                ))
            }
        }
    }
}

impl<S> FromRequestParts<S> for ServiceActor
where
    S: Send + Sync,
{
    type Rejection = ApiErrorResponse;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        let HttpRequestContext(ctx) = HttpRequestContext::from_request_parts(parts, state).await?;
        match ctx.actor {
            ActorContext::Anonymous => Err(ApiErrorResponse::with_context(
                AppError::new(ErrorCode::Unauthorized, "Authentication is required"),
                &ctx,
            )),
            ActorContext::Service { service_id, scopes } => Ok(Self { service_id, scopes }),
            ActorContext::User { .. } | ActorContext::System => {
                Err(ApiErrorResponse::with_context(
                    AppError::new(ErrorCode::Forbidden, "Service authentication is required"),
                    &ctx,
                ))
            }
        }
    }
}

impl<S> FromRequestParts<S> for AdminActor
where
    S: Send + Sync,
{
    type Rejection = ApiErrorResponse;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        let HttpRequestContext(ctx) = HttpRequestContext::from_request_parts(parts, state).await?;
        match ctx.actor {
            ActorContext::Anonymous => Err(ApiErrorResponse::with_context(
                AppError::new(ErrorCode::Unauthorized, "Authentication is required"),
                &ctx,
            )),
            ActorContext::Service { service_id, scopes } => {
                Ok(Self::Service { service_id, scopes })
            }
            ActorContext::System => Ok(Self::System),
            ActorContext::User { .. } => Err(ApiErrorResponse::with_context(
                AppError::new(
                    ErrorCode::Forbidden,
                    "Service or system authentication is required",
                ),
                &ctx,
            )),
        }
    }
}