prest 0.5.1

Progressive RESTful 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

use crate::*;
use openidconnect::{core::*, reqwest::async_http_client, *};

state!(WITH_GOOGLE_AUTH: bool = {
    env_var("GOOGLE_CLIENT_ID").is_ok() && env_var("GOOGLE_CLIENT_SECRET").is_ok()
});

state!(GOOGLE_CLIENT: GoogleClient = async {
    if !*WITH_GOOGLE_AUTH {
        panic!("Attempted to use google client without credentials!")
    }
    let client_id = env_var("GOOGLE_CLIENT_ID")?;
    let client_secret = env_var("GOOGLE_CLIENT_SECRET")?;

    let domain = if let Some(domain) = &APP_CONFIG.domain {
        format!("https://{domain}")
    } else {
        format!("http://localhost")
    };
    let callback_url = format!("{domain}{GOOGLE_CALLBACK_ROUTE}");
    GoogleClient::init(callback_url, client_id, client_secret).await
});

pub struct GoogleClient(GoogleOAuthClient);

impl GoogleClient {
    pub async fn init(callback_url: String, client_id: String, client_secret: String) -> Self {
        let redirect_url = RedirectUrl::new(callback_url).unwrap();
        let client_id = ClientId::new(client_id);
        let client_secret = ClientSecret::new(client_secret);
        let issuer_url = IssuerUrl::new("https://accounts.google.com".to_string()).unwrap();
        let provider_metadata = CoreProviderMetadata::discover_async(issuer_url, async_http_client)
            .await
            .unwrap();

        let client =
            CoreClient::from_provider_metadata(provider_metadata, client_id, Some(client_secret))
                .set_redirect_uri(redirect_url);

        Self(client)
    }
    pub fn authz_request(&self) -> (url::Url, OAuthCSRF, OAuthNonce) {
        let mut authz_req = self.0.authorize_url(
            AuthenticationFlow::<CoreResponseType>::AuthorizationCode,
            OAuthCSRF::new_random,
            OAuthNonce::new_random,
        );
        let scopes = ["email"];
        for scope in scopes {
            authz_req = authz_req.add_scope(Scope::new(scope.to_string()));
        }
        authz_req.url()
    }

    pub async fn get_email(&self, code: OAuthCode, nonce: OAuthNonce) -> Result<String> {
        let token = self.get_token(code).await?;
        Ok(token
            .extra_fields()
            .id_token()
            .ok_or(e!("server did not return an ID token"))?
            .claims(&self.0.id_token_verifier(), &nonce)?
            .email()
            .ok_or(e!("email not found in openID claims"))?
            .to_string())
    }

    pub async fn get_token(&self, code: OAuthCode) -> Result<GoogleTokenResponse> {
        Ok(self
            .0
            .exchange_code(AuthorizationCode::new(code))
            .request_async(async_http_client)
            .await
            .somehow()?)
    }
}

pub type GoogleTokenResponse = StandardTokenResponse<
    IdTokenFields<
        EmptyAdditionalClaims,
        EmptyExtraTokenFields,
        CoreGenderClaim,
        CoreJweContentEncryptionAlgorithm,
        CoreJwsSigningAlgorithm,
        CoreJsonWebKeyType,
    >,
    CoreTokenType,
>;

pub type GoogleOAuthClient = Client<
    EmptyAdditionalClaims,
    CoreAuthDisplay,
    CoreGenderClaim,
    CoreJweContentEncryptionAlgorithm,
    CoreJwsSigningAlgorithm,
    CoreJsonWebKeyType,
    CoreJsonWebKeyUse,
    CoreJsonWebKey,
    CoreAuthPrompt,
    StandardErrorResponse<CoreErrorResponseType>,
    GoogleTokenResponse,
    CoreTokenType,
    StandardTokenIntrospectionResponse<EmptyExtraTokenFields, CoreTokenType>,
    CoreRevocableToken,
    StandardErrorResponse<RevocationErrorResponseType>,
>;