pooly 0.2.1

A protobuf to Postgres adapter + connection pooling middleware.
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

use jwt::Claims;

use crate::models::errors::AuthError;

const POOLY_ROLE: &str = "pooly_role";

const ADMIN: &str = "admin";
const CLIENT_SERVICE: &str = "client_service";

#[derive(Debug)]
pub enum AuthOutcome {

    Authenticated(RoleToken),
    Unauthenticated

}

#[derive(Debug)]
pub enum RoleToken {

    Admin(AdminToken, Role),
    ClientService(ClientServiceToken, Role),

}

impl RoleToken {

    pub fn get_role(&self) -> &Role {
        match self {
            RoleToken::Admin(_, role) => role,
            RoleToken::ClientService(_, role) => role
        }
    }

}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Role {

    Admin,
    ClientService

}

#[derive(Debug, Clone)]
pub struct ClientServiceToken {

    client_id: String

}

impl ClientServiceToken {

    pub fn get_client_id(&self) -> &str {
        &self.client_id
    }

}

#[derive(Debug, Clone)]
pub struct AdminToken {

    admin_id: String

}

impl TryFrom<&Claims> for RoleToken {
    type Error = AuthError;

    fn try_from(value: &Claims) -> Result<Self, Self::Error> {
        let role_maybe = value.private
            .get(POOLY_ROLE)
            .and_then(|v| v.as_str());

        let id_maybe = &value.registered.subject;

        match (role_maybe, id_maybe) {
            (Some(ADMIN), Some(admin_id)) =>
                Ok(RoleToken::Admin(
                    AdminToken { admin_id: admin_id.clone() },
                    Role::Admin )),
            (Some(CLIENT_SERVICE), Some(client_id)) =>
                Ok(RoleToken::ClientService(
                    ClientServiceToken { client_id: client_id.clone() },
                    Role::ClientService )),
            (_, _) => Err(AuthError::InvalidClaims)
        }
    }
}