workos 0.8.1

Rust SDK for interacting with the WorkOS API.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use async_trait::async_trait;
use serde::{Deserialize, Serialize};

use crate::organizations::OrganizationId;
use crate::portal::{GeneratePortalLinkIntent, Portal};
use crate::{ResponseExt, WorkOsResult};

/// The parameters for [`GeneratePortalLink`].
#[derive(Debug, Serialize)]
pub struct GeneratePortalLinkParams<'a> {
    /// The ID of the organization.
    #[serde(rename = "organization")]
    pub organization_id: &'a OrganizationId,

    /// The intent of the Admin Portal.
    pub intent: GeneratePortalLinkIntent,

    /// The URL to go to when an admin clicks on your logo in the Admin Portal.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub return_url: Option<&'a str>,

    /// The URL to redirect the admin to when they finish setup.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub success_url: Option<&'a str>,
}

/// The response for [`GeneratePortalLink`].
#[derive(Debug, Deserialize)]
pub struct GeneratePortalLinkResponse {
    /// An ephemeral link to initiate the Admin Portal.
    pub link: String,
}

/// An error returned from [`GeneratePortalLink`].
#[derive(Debug)]
pub enum GeneratePortalLinkError {}

/// [WorkOS Docs: Generate a Portal Link](https://workos.com/docs/reference/admin-portal/portal-link/generate)
#[async_trait]
pub trait GeneratePortalLink {
    /// Generate a Portal Link scoped to an Organization.
    ///
    /// [WorkOS Docs: Generate a Portal Link](https://workos.com/docs/reference/admin-portal/portal-link/generate)
    ///
    /// # Examples
    ///
    /// ```
    /// # use workos::WorkOsResult;
    /// # use workos::organizations::OrganizationId;
    /// # use workos::portal::*;
    /// use workos::{ApiKey, WorkOs};
    ///
    /// # async fn run() -> WorkOsResult<(), GeneratePortalLinkError> {
    /// let workos = WorkOs::new(&ApiKey::from("sk_example_123456789"));
    ///
    /// let GeneratePortalLinkResponse { link } = workos
    ///     .portal()
    ///     .generate_portal_link(&GeneratePortalLinkParams {
    ///         organization_id: &OrganizationId::from("org_01EHZNVPK3SFK441A1RGBFSHRT"),
    ///         intent: GeneratePortalLinkIntent::Sso,
    ///         return_url: None,
    ///         success_url: None,
    ///     })
    ///     .await?;
    /// # Ok(())
    /// # }
    /// ```
    async fn generate_portal_link(
        &self,
        params: &GeneratePortalLinkParams<'_>,
    ) -> WorkOsResult<GeneratePortalLinkResponse, GeneratePortalLinkError>;
}

#[async_trait]
impl GeneratePortalLink for Portal<'_> {
    async fn generate_portal_link(
        &self,
        params: &GeneratePortalLinkParams<'_>,
    ) -> WorkOsResult<GeneratePortalLinkResponse, GeneratePortalLinkError> {
        let url = self.workos.base_url().join("/portal/generate_link")?;
        let response = self
            .workos
            .client()
            .post(url)
            .bearer_auth(self.workos.key())
            .json(&params)
            .send()
            .await?
            .handle_unauthorized_or_generic_error()
            .await?
            .json::<GeneratePortalLinkResponse>()
            .await?;

        Ok(response)
    }
}

#[cfg(test)]
mod test {
    use mockito::Matcher;
    use serde_json::json;
    use tokio;

    use crate::organizations::OrganizationId;
    use crate::{ApiKey, WorkOs};

    use super::*;

    #[tokio::test]
    async fn it_calls_the_generate_portal_link_endpoint() {
        let mut server = mockito::Server::new_async().await;

        let workos = WorkOs::builder(&ApiKey::from("sk_example_123456789"))
            .base_url(&dbg!(server.url()))
            .unwrap()
            .build();

        server
            .mock("POST", "/portal/generate_link")
            .match_header("Authorization", "Bearer sk_example_123456789")
            .match_body(Matcher::Json(json!({
                "organization": "org_01EHZNVPK3SFK441A1RGBFSHRT",
                "intent": "sso",
            })))
            .with_status(201)
            .with_body(
                json!({
                    "link": "https://setup.workos.com?token=token"
                })
                .to_string(),
            )
            .create_async()
            .await;

        let GeneratePortalLinkResponse { link } = workos
            .portal()
            .generate_portal_link(&GeneratePortalLinkParams {
                organization_id: &OrganizationId::from("org_01EHZNVPK3SFK441A1RGBFSHRT"),
                intent: GeneratePortalLinkIntent::Sso,
                return_url: None,
                success_url: None,
            })
            .await
            .unwrap();

        assert_eq!(link, "https://setup.workos.com?token=token".to_string())
    }
}