rauthy-client 0.14.0

Client for the Rauthy OIDC IAM project
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

use base64::DecodeError;
use chacha20poly1305::Error;
use std::borrow::Cow;
use thiserror::Error;

#[derive(Debug, PartialEq, Error)]
pub enum RauthyError {
    #[error("BadRequest: {0}")]
    BadRequest(&'static str),
    #[error("Base64: {0}")]
    Base64(String),
    #[error("Encryption: {0}")]
    Encryption(Cow<'static, str>),
    #[error("Internal: {0}")]
    Internal(Cow<'static, str>),
    #[error("Init: {0}")]
    Init(&'static str),
    #[error("InvalidClaims: {0}")]
    InvalidClaims(&'static str),
    #[error("InvalidJwt: {0}")]
    InvalidJwt(&'static str),
    #[error("JWK: {0}")]
    JWK(Cow<'static, str>),
    #[error("MalformedJwt: {0}")]
    MalformedJwt(&'static str),
    #[error("Provider: {0}")]
    Provider(Cow<'static, str>),
    #[error("Request Error: {0}")]
    Request(Cow<'static, str>),
    #[error("Serde: {0}")]
    Serde(String),
    #[error("Token: {0}")]
    Token(Cow<'static, str>),
}

impl From<base64::DecodeError> for RauthyError {
    fn from(value: DecodeError) -> Self {
        Self::Base64(value.to_string())
    }
}

impl From<chacha20poly1305::Error> for RauthyError {
    fn from(value: Error) -> Self {
        Self::Encryption(Cow::from(value.to_string()))
    }
}

impl From<bincode::error::DecodeError> for RauthyError {
    fn from(value: bincode::error::DecodeError) -> Self {
        Self::Internal(Cow::from(value.to_string()))
    }
}

impl From<reqwest::Error> for RauthyError {
    fn from(value: reqwest::Error) -> Self {
        Self::Request(Cow::from(value.to_string()))
    }
}

impl From<serde_json::Error> for RauthyError {
    fn from(value: serde_json::Error) -> Self {
        Self::Serde(value.to_string())
    }
}

impl From<ed25519_compact::Error> for RauthyError {
    fn from(value: ed25519_compact::Error) -> Self {
        Self::JWK(value.to_string().into())
    }
}

#[cfg(feature = "rsa")]
impl From<rsa::Error> for RauthyError {
    fn from(value: rsa::Error) -> Self {
        Self::JWK(value.to_string().into())
    }
}

#[cfg(feature = "qrcode")]
impl From<qrcode::types::QrError> for RauthyError {
    fn from(value: qrcode::types::QrError) -> Self {
        Self::Internal(Cow::from(value.to_string()))
    }
}

#[cfg(feature = "device-code")]
impl From<tokio::sync::watch::error::SendError<String>> for RauthyError {
    fn from(value: tokio::sync::watch::error::SendError<String>) -> Self {
        Self::Internal(Cow::from(value.to_string()))
    }
}

#[cfg(feature = "device-code")]
impl From<tokio::sync::watch::error::SendError<Option<String>>> for RauthyError {
    fn from(value: tokio::sync::watch::error::SendError<Option<String>>) -> Self {
        Self::Internal(Cow::from(value.to_string()))
    }
}

#[cfg(feature = "axum")]
impl axum::response::IntoResponse for RauthyError {
    fn into_response(self) -> axum::response::Response {
        let (status, body) = match self {
            RauthyError::BadRequest(err) => (400, err.to_string()),
            RauthyError::Base64(err) => (400, err),
            RauthyError::Encryption(err) => (400, err.to_string()),
            RauthyError::Internal(err) => (400, err.to_string()),
            RauthyError::Init(err) => (400, err.to_string()),
            RauthyError::InvalidClaims(err) => (400, err.to_string()),
            RauthyError::InvalidJwt(err) => (400, err.to_string()),
            RauthyError::JWK(err) => (400, err.to_string()),
            RauthyError::MalformedJwt(err) => (400, err.to_string()),
            RauthyError::Provider(err) => (400, err.to_string()),
            RauthyError::Request(err) => (400, err.to_string()),
            RauthyError::Serde(err) => (400, err),
            RauthyError::Token(err) => (400, err.to_string()),
        };
        axum::response::Response::builder()
            .status(status)
            .body(axum::body::Body::from(body))
            .unwrap()
    }
}