proksi 0.3.20

A batteries-included reverse proxy with automatic HTTPS using Cloudflare Pingora and Let's Encrypt.
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

use std::borrow::Cow;

use serde::Deserialize;

use super::{provider::OauthUser, HTTP_CLIENT};

pub(super) struct WorkosOauthService;

const WORKOS_API_URL: &str = "https://api.workos.com/user_management/authorize";

impl WorkosOauthService {
    /// Get the OAuth callback URL for Workos
    pub fn get_oauth_callback_url(client_id: &str, state: &str) -> String {
        format!("{WORKOS_API_URL}?client_id={client_id}&redirect_uri={}&state={state}&provider=authkit&response_type=code","")
    }

    /// Retrieves the user information from Workos
    pub async fn get_oauth_user(
        client_id: &str,
        client_secret: &str,
        code: &str,
    ) -> Result<OauthUser, anyhow::Error> {
        let response = HTTP_CLIENT
            .post(WORKOS_API_URL)
            .json(&serde_json::json!(
                {
                    "client_id": client_id,
                    "client_secret": client_secret,
                    "code": code,
                    "grant_type": "authorization_code",
                    "user-agent": "pingora/0.2.0"
                }
            ))
            .send()
            .await?;
        let body = response.json::<WorkosTokenResponse>().await?;

        Ok(OauthUser {
            email: body.user.email,
            team_ids: vec![],
            organization_ids: vec![],
            usernames: vec![],
        })
    }
}

#[derive(Deserialize)]
struct WorkosTokenResponse {
    // access_token: Cow<'static, str>,
    // refresh_token: Cow<'static, str>,
    user: WorkosUserResponse,
}

#[derive(Deserialize)]
struct WorkosUserResponse {
    // id: Cow<'static, str>,
    email: Cow<'static, str>,
}