manas_authentication 0.1.0

This crate provides implementations of various http authentication schemes for solid storage resource servers and authorization servers.
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

//! I define a basic implementation of the [`RequestCredentials`].
//!

use http_uri::invariant::AbsoluteHttpUri;
use serde::Serialize;
use webid::WebId;

use super::void::VoidCredentials;
use crate::common::credentials::{
    AgentCredentials, ClientCredentials, ClientId, IssuerCredentials, RequestCredentials,
};

/// A basic implementation of [`AgentCredentials`].
#[derive(Debug, Clone, Serialize)]
pub struct BasicAgentCredentials {
    /// Webid of the agent.
    pub webid: WebId,
}

impl AgentCredentials for BasicAgentCredentials {
    #[inline]
    fn webid(&self) -> &WebId {
        &self.webid
    }
}

/// A basic implementation of [`ClientCredentials`].
#[derive(Debug, Clone, Serialize)]
pub struct BasicClientCredentials {
    /// Client_id of the client.
    pub client_id: ClientId,

    /// Webid of the client.
    pub client_web_id: Option<WebId>,
}

impl ClientCredentials for BasicClientCredentials {
    #[inline]
    fn client_id(&self) -> &ClientId {
        &self.client_id
    }

    #[inline]
    fn client_web_id(&self) -> Option<&WebId> {
        self.client_web_id.as_ref()
    }
}

/// A basic implementation of [`IssuerCredentials`].
#[derive(Debug, Clone, Serialize)]
pub struct BasicIssuerCredentials {
    /// Uri of the issuer.
    pub uri: AbsoluteHttpUri,
}

impl IssuerCredentials for BasicIssuerCredentials {
    #[inline]
    fn uri(&self) -> &AbsoluteHttpUri {
        &self.uri
    }
}

/// A basic implementation of [`RequestCredentials`].
#[derive(Debug, Clone, Default, Serialize)]
pub struct BasicRequestCredentials {
    /// Agent credentials.
    pub of_agent: Option<BasicAgentCredentials>,

    /// Client credentials.
    pub of_client: Option<BasicClientCredentials>,

    /// Issuer credentials.
    pub of_issuer: Option<BasicIssuerCredentials>,
}

impl RequestCredentials for BasicRequestCredentials {
    type AgentCredentials = BasicAgentCredentials;

    type ClientCredentials = BasicClientCredentials;

    type IssuerCredentials = BasicIssuerCredentials;

    #[inline]
    fn of_agent(&self) -> Option<&Self::AgentCredentials> {
        self.of_agent.as_ref()
    }

    #[inline]
    fn of_client(&self) -> Option<&Self::ClientCredentials> {
        self.of_client.as_ref()
    }

    #[inline]
    fn of_issuer(&self) -> Option<&Self::IssuerCredentials> {
        self.of_issuer.as_ref()
    }
}

#[cfg(feature = "creds-context")]
impl super::super::ToContext for BasicRequestCredentials {}

impl From<BasicRequestCredentials> for VoidCredentials {
    #[inline]
    fn from(_value: BasicRequestCredentials) -> Self {
        Self {}
    }
}