[TIC-365] Add create_access_token request

docs/AccessTokenServiceApi.md

@@ -0,0 +1,32 @@
+# \AccessTokenServiceApi
+
+All URIs are relative to _http://localhost_
+
+| Method                                                                  | HTTP request                          | Description |
+| ----------------------------------------------------------------------- | ------------------------------------- | ----------- |
+| [**create_access_Token**](AccessTokenServiceApi.md#create_access_token) | **POST** /api/backend/v1/access_token |
+
+## create_access_Token
+
+> crate::models::CreateAccessTokenResponse create_access_token(create_access_token_params)
+
+### Parameters
+
+| Name                       | Type                                                                       | Description | Notes |
+| -------------------------- | -------------------------------------------------------------------------- | ----------- | ----- |
+| create_access_token_params | [**crate::models::CreateAccessTokenRequest**](CreateAccessTokenRequest.md) |             |       |
+
+### Return type
+
+[**crate::models::CreateAccessTokenResponse**](CreateAccessTokenResponse.md)
+
+### Authorization
+
+[BearerAuth](../README.md#BearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

docs/CreateAccessTokenRequest.md

@@ -0,0 +1,12 @@
+# CreateAccessTokenRequest
+
+## Properties
+
+| Name                        | Type                 | Description | Notes |
+| --------------------------- | -------------------- | ----------- | ----- |
+| **user_id**                 | **String**           |             |
+| **duration_in_minutes**     | **u64**              |             |
+| **active_org_id**           | **Option\<String\>** |             |
+| **with_active_org_support** | **bool**             |             |
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

docs/CreateAccessTokenResponse.md

@@ -0,0 +1,9 @@
+# CreateAccessTokenResponse
+
+## Properties
+
+| Name             | Type       | Description | Notes |
+| ---------------- | ---------- | ----------- | ----- |
+| **access_token** | **String** |             |
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

src/apis/access_token_service_api.rs

@@ -0,0 +1,58 @@
+use reqwest;
+
+use crate::apis::ResponseContent;
+use super::{Error, configuration};
+
+/// struct for passing parameters to the method [`create_access_token`]
+#[derive(Clone, Debug, Default)]
+pub struct CreateAccessTokenParams {
+    pub create_access_token_request: crate::models::CreateAccessTokenRequest
+}
+
+
+
+/// struct for typed errors of method [`create_access_token`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum CreateAccessTokenError {
+    Status400(crate::models::BadCreateAccessTokenError),
+    Status401(serde_json::Value),
+    Status404(serde_json::Value),
+    UnknownValue(serde_json::Value),
+}
+
+
+pub async fn create_access_token(configuration: &configuration::Configuration, params: CreateAccessTokenParams) -> Result<crate::models::CreateAccessTokenResponse, Error<CreateAccessTokenError>> {
+    let local_var_configuration = configuration;
+
+    // unbox the parameters
+    let create_access_token_request = params.create_access_token_request;
+
+    let local_var_client = &local_var_configuration.client;
+
+    let local_var_uri_str = format!("{}/api/backend/v1/access_token", local_var_configuration.base_path);
+    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
+
+    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
+        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
+    }
+    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
+        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
+    };
+    local_var_req_builder = local_var_req_builder.json(&create_access_token_request);
+
+    let local_var_req = local_var_req_builder.build()?;
+    let local_var_resp = local_var_client.execute(local_var_req).await?;
+
+    let local_var_status = local_var_resp.status();
+    let local_var_content = local_var_resp.text().await?;
+
+    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
+        serde_json::from_str(&local_var_content).map_err(Error::from)
+    } else {
+        let local_var_entity: Option<CreateAccessTokenError> = serde_json::from_str(&local_var_content).ok();
+        let local_var_error: ResponseContent<CreateAccessTokenError> = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
+        Err(Error::ResponseError(local_var_error))
+    }
+}
+

src/apis/mod.rs

@@ -65,6 +65,7 @@ pub fn urlencode<T: AsRef<str>>(s: T) -> String {
 }
 
 pub mod api_key_service_api;
+pub mod access_token_service_api;
 pub mod auth_service_api;
 pub mod org_service_api;
 pub mod user_service_api;

src/models/bad_create_access_token_error.rs

@@ -0,0 +1,17 @@
+
+#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+pub struct BadCreateAccessTokenError {
+    #[serde(rename = "active_org_id", skip_serializing_if = "Option::is_none")]
+    pub active_org_id: Option<Vec<String>>,
+    #[serde(rename = "user_id", skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<Vec<String>>,
+}
+
+impl BadCreateAccessTokenError {
+    pub fn new() -> BadCreateAccessTokenError {
+        BadCreateAccessTokenError {
+            active_org_id: None,
+            user_id: None,
+        }
+    }
+}

src/models/create_access_token_request.rs

@@ -0,0 +1,22 @@
+#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+pub struct CreateAccessTokenRequest {
+    #[serde(rename = "user_id")]
+    pub user_id: String,
+    #[serde(rename = "duration_in_minutes")]
+    pub duration_in_minutes: u64,
+    #[serde(rename = "active_org_id", skip_serializing_if = "Option::is_none")]
+    pub active_org_id: Option<String>,
+    #[serde(rename = "with_active_org_support")]
+    pub with_active_org_support: bool,
+}
+
+impl CreateAccessTokenRequest {
+    pub fn new(user_id: String, duration_in_minutes: u64, with_active_org_support: bool) -> CreateAccessTokenRequest {
+        CreateAccessTokenRequest {
+            user_id,
+            active_org_id: None,
+            duration_in_minutes,
+            with_active_org_support,
+        }
+    }
+}

src/models/create_access_token_response.rs

@@ -0,0 +1,12 @@
+#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+pub struct CreateAccessTokenResponse {
+    pub access_token: String,
+}
+
+impl CreateAccessTokenResponse {
+    pub fn new(access_token: String) -> Self {
+        CreateAccessTokenResponse {
+            access_token,
+        }
+    }
+}

src/models/mod.rs

@@ -86,3 +86,9 @@ pub mod usernames_query;
 pub use self::usernames_query::UsernamesQuery;
 pub mod validate_api_key_response;
 pub use self::validate_api_key_response::ValidateApiKeyResponse;
+pub mod create_access_token_response;
+pub use self::create_access_token_response::CreateAccessTokenResponse;
+pub mod create_access_token_request;
+pub use self::create_access_token_request::CreateAccessTokenRequest;
+pub mod bad_create_access_token_error;
+pub use self::bad_create_access_token_error::BadCreateAccessTokenError;

src/propelauth/access_token.rs

@@ -0,0 +1,38 @@
+use crate::apis::access_token_service_api::CreateAccessTokenParams;
+use crate::apis::configuration::Configuration;
+
+use crate::models::CreateAccessTokenResponse;
+use crate::propelauth::errors::CreateAccessTokenError;
+use crate::propelauth::helpers::{is_valid_id, map_autogenerated_error};
+
+pub struct AccessTokenService<'a> {
+    pub(crate) config: &'a Configuration,
+}
+
+impl AccessTokenService<'_> {
+    pub async fn create_access_token(&self, params: CreateAccessTokenParams) -> Result<CreateAccessTokenResponse, CreateAccessTokenError> {
+        if !is_valid_id(&params.create_access_token_request.user_id) {
+            return Err(CreateAccessTokenError::NotFound);
+        }
+
+        crate::apis::access_token_service_api::create_access_token(&self.config, params)
+            .await
+            .map_err(|err| {
+                map_autogenerated_error(
+                    err,
+                    CreateAccessTokenError::UnexpectedException,
+                    |status_code, err_entity| match (status_code.as_u16(), err_entity) {
+                        (
+                            _,
+                            Some(crate::apis::access_token_service_api::CreateAccessTokenError::Status400(
+                                bad_request,
+                            )),
+                        ) => CreateAccessTokenError::BadRequest(bad_request),
+                        (401, _) => CreateAccessTokenError::InvalidApiKey,
+                        (404, _) => CreateAccessTokenError::NotFound,
+                        _ => CreateAccessTokenError::UnexpectedException,
+                    },
+                )
+            })
+    }
+}

src/propelauth/auth.rs

@@ -10,6 +10,7 @@ use crate::propelauth::options::{AuthOptions, AuthOptionsWithTokenVerification};
 use crate::propelauth::org::OrgService;
 use crate::propelauth::token::TokenService;
 use crate::propelauth::user::UserService;
+use crate::propelauth::access_token::AccessTokenService;
 
 /// The main entrypoint of this library.
 /// All authentication, authorization and API requests starts from this struct
@@ -96,6 +97,13 @@ impl PropelAuth {
             issuer: &self.issuer,
         }
     }
+
+    /// API requests related to access tokens.
+    pub fn access_token(&self) -> AccessTokenService {
+        AccessTokenService {
+            config: &self.config,
+        }
+    }
 }
 
 fn validate_auth_url(auth_url: &str) -> Result<String, InitializationError> {

src/propelauth/errors.rs

@@ -1,7 +1,7 @@
 use crate::models::{
     BadCreateMagicLinkRequest, BadCreateOrgRequest, BadCreateUserRequest, BadFetchOrgQuery,
     BadFetchUsersByQuery, BadFetchUsersInOrgQuery, BadMigrateUserRequest, BadUpdateOrgRequest,
-    BadUpdatePasswordRequest, BadUpdateUserEmailRequest, BadUpdateUserMetadataRequest,
+    BadUpdatePasswordRequest, BadUpdateUserEmailRequest, BadUpdateUserMetadataRequest, BadCreateAccessTokenError,
 };
 use thiserror::Error;
 
@@ -203,6 +203,21 @@ pub enum FetchOrgsByQueryError {
     UnexpectedException,
 }
 
+#[derive(Error, Debug, PartialEq, Clone)]
+pub enum CreateAccessTokenError {
+    #[error("Invalid API Key")]
+    InvalidApiKey,
+
+    #[error("Unexpected exception, please try again")]
+    UnexpectedException,
+
+    #[error("Not found")]
+    NotFound,
+
+    #[error("Bad request")]
+    BadRequest(BadCreateAccessTokenError),
+}
+
 #[derive(Error, Debug, Eq, PartialEq, Copy, Clone)]
 pub enum DetailedAuthError {
     #[error("Invalid public key for decoding the JWT - make sure it's formatted correctly")]

src/propelauth/mod.rs

@@ -7,3 +7,4 @@ pub mod org;
 pub mod token;
 pub mod token_models;
 pub mod user;
+pub mod access_token;