propelauth/apis/
api_key_service_api.rs

1/*
2 * propelauth
3 *
4 * For consistency with the rest of this codebase, this file matches the output of the terrible openapi generator.
5 */
6
7use hex;
8use reqwest;
9
10use crate::{apis::ResponseContent, propelauth::auth::AUTH_HOSTNAME_HEADER};
11
12use super::{configuration, Error};
13
14/// struct for passing parameters to the method [`fetch_api_keys`, `fetch_archived_api_keys`]
15#[derive(Clone, Debug, Default, Serialize)]
16pub struct ApiKeyQueryParams {
17    pub user_id: Option<String>,
18    pub user_email: Option<String>,
19    pub org_id: Option<String>,
20    pub page_size: Option<i64>,
21    pub page_number: Option<i64>,
22}
23
24/// struct for passing parameters to the method [`create_api_key`]
25#[derive(Clone, Debug, Default, Serialize)]
26pub struct CreateApiKeyParams {
27    pub expires_at_seconds: Option<i64>,
28    pub metadata: Option<serde_json::Value>,
29    pub user_id: Option<String>,
30    pub org_id: Option<String>,
31}
32
33/// struct for passing parameters to the method [`update_api_key`]
34#[derive(Clone, Debug, Default, Serialize)]
35pub struct UpdateApiKeyParams {
36    pub expires_at_seconds: Option<i64>,
37    pub metadata: Option<serde_json::Value>,
38    pub set_to_never_expire: Option<bool>,
39}
40
41/// struct for passing parameters to the method [`validate_api_key`]
42#[derive(Clone, Debug, Default, Serialize)]
43pub struct ValidateApiKeyParams {
44    pub api_key_token: String,
45}
46
47// struct for typed errors on the api keys service
48#[derive(Debug, Clone, Deserialize)]
49#[serde(untagged)]
50pub enum ApiKeyError {
51    BadRequest(crate::models::BadUpdateOrgRequest),
52    InvalidIntegrationAPIKey,
53    InvalidAPIKey {
54        message: String,
55    },
56    RateLimited {
57        wait_seconds: f64,
58        user_facing_error: String,
59    },
60    PropelAuthRateLimit,
61    InvalidPersonalAPIKey,
62    InvalidOrgAPIKey,
63    NotFound,
64    UnknownValue(serde_json::Value),
65    UnknownError,
66    UnexpectedExceptionWithSDK,
67}
68
69#[derive(Debug, Clone, Deserialize)]
70#[serde(untagged)]
71pub enum ApiKeyValidationErrorResponse {
72    InvalidEndUserApiKey {
73        api_key_token: String,
74    },
75    EndUserApiKeyRateLimited {
76        wait_seconds: f64,
77        error_code: String,
78        user_facing_error: String,
79    },
80}
81
82pub async fn fetch_current_api_keys(
83    configuration: &configuration::Configuration,
84    params: ApiKeyQueryParams,
85) -> Result<crate::models::FetchApiKeysPagedResponse, Error<ApiKeyError>> {
86    let client = &configuration.client;
87
88    let uri = format!(
89        "{}/api/backend/v1/end_user_api_keys",
90        configuration.base_path
91    );
92    let mut req_builder = client.request(reqwest::Method::GET, uri.as_str());
93
94    // assemble the query parameters
95    if let Some(ref user_id) = params.user_id {
96        req_builder = req_builder.query(&[("user_id", user_id)]);
97    }
98    if let Some(ref user_email) = params.user_email {
99        req_builder = req_builder.query(&[("user_email", user_email)]);
100    }
101    if let Some(ref org_id) = params.org_id {
102        req_builder = req_builder.query(&[("org_id", org_id)]);
103    }
104    if let Some(ref page_size) = params.page_size {
105        req_builder = req_builder.query(&[("page_size", page_size)]);
106    }
107    if let Some(ref page_number) = params.page_number {
108        req_builder = req_builder.query(&[("page_number", page_number)]);
109    }
110
111    if let Some(ref user_agent) = configuration.user_agent {
112        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
113    }
114    if let Some(ref bearer_token) = configuration.bearer_access_token {
115        req_builder = req_builder.bearer_auth(bearer_token.to_owned());
116    }
117    req_builder = req_builder.header(AUTH_HOSTNAME_HEADER, configuration.auth_hostname.to_owned());
118
119    let req = req_builder.build()?;
120    let resp = client.execute(req).await?;
121
122    let status = resp.status();
123    let content = resp.text().await?;
124
125    if !status.is_client_error() && !status.is_server_error() {
126        serde_json::from_str(&content).map_err(Error::from)
127    } else {
128        let entity: Option<ApiKeyError> = serde_json::from_str(&content).ok();
129        let error = ResponseContent {
130            status,
131            content,
132            entity,
133        };
134        Err(Error::ResponseError(error))
135    }
136}
137
138pub async fn fetch_archived_api_keys(
139    configuration: &configuration::Configuration,
140    params: ApiKeyQueryParams,
141) -> Result<crate::models::FetchApiKeysPagedResponse, Error<ApiKeyError>> {
142    let client = &configuration.client;
143
144    let uri = format!(
145        "{}/api/backend/v1/end_user_api_keys/archived",
146        configuration.base_path
147    );
148    let mut req_builder = client.request(reqwest::Method::GET, uri.as_str());
149
150    // assemble the query parameters
151    if let Some(ref user_id) = params.user_id {
152        req_builder = req_builder.query(&[("user_id", user_id)]);
153    }
154    if let Some(ref user_email) = params.user_email {
155        req_builder = req_builder.query(&[("user_email", user_email)]);
156    }
157    if let Some(ref org_id) = params.org_id {
158        req_builder = req_builder.query(&[("org_id", org_id)]);
159    }
160    if let Some(ref page_size) = params.page_size {
161        req_builder = req_builder.query(&[("page_size", page_size)]);
162    }
163    if let Some(ref page_number) = params.page_number {
164        req_builder = req_builder.query(&[("page_number", page_number)]);
165    }
166
167    if let Some(ref user_agent) = configuration.user_agent {
168        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
169    }
170    if let Some(ref bearer_token) = configuration.bearer_access_token {
171        req_builder = req_builder.bearer_auth(bearer_token.to_owned());
172    }
173    req_builder = req_builder.header(AUTH_HOSTNAME_HEADER, configuration.auth_hostname.to_owned());
174
175    let req = req_builder.build()?;
176    let resp = client.execute(req).await?;
177
178    let status = resp.status();
179    let content = resp.text().await?;
180
181    if !status.is_client_error() && !status.is_server_error() {
182        serde_json::from_str(&content).map_err(Error::from)
183    } else {
184        let entity: Option<ApiKeyError> = serde_json::from_str(&content).ok();
185        let error = ResponseContent {
186            status,
187            content,
188            entity,
189        };
190        Err(Error::ResponseError(error))
191    }
192}
193
194pub async fn fetch_api_key(
195    configuration: &configuration::Configuration,
196    api_key_id: String,
197) -> Result<crate::models::FetchApiKeyResponse, Error<ApiKeyError>> {
198    if hex::decode(&api_key_id).is_err() {
199        return Err(Error::Params("Invalid API key ID format".to_string()));
200    }
201
202    let client = &configuration.client;
203
204    let uri = format!(
205        "{}/api/backend/v1/end_user_api_keys/{}",
206        configuration.base_path, api_key_id
207    );
208    let mut req_builder = client.request(reqwest::Method::GET, uri.as_str());
209
210    if let Some(ref user_agent) = configuration.user_agent {
211        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
212    }
213    if let Some(ref bearer_token) = configuration.bearer_access_token {
214        req_builder = req_builder.bearer_auth(bearer_token.to_owned());
215    }
216    req_builder = req_builder.header(AUTH_HOSTNAME_HEADER, configuration.auth_hostname.to_owned());
217
218    let req = req_builder.build()?;
219    let resp = client.execute(req).await?;
220
221    let status = resp.status();
222    let content = resp.text().await?;
223
224    if !status.is_client_error() && !status.is_server_error() {
225        serde_json::from_str(&content).map_err(Error::from)
226    } else {
227        let entity: Option<ApiKeyError> = serde_json::from_str(&content).ok();
228        let error = ResponseContent {
229            status,
230            content,
231            entity,
232        };
233        Err(Error::ResponseError(error))
234    }
235}
236
237pub async fn create_api_key(
238    configuration: &configuration::Configuration,
239    params: CreateApiKeyParams,
240) -> Result<crate::models::CreateApiKeyResponse, Error<ApiKeyError>> {
241    let client = &configuration.client;
242
243    let uri = format!(
244        "{}/api/backend/v1/end_user_api_keys",
245        configuration.base_path
246    );
247    let mut req_builder = client.request(reqwest::Method::POST, uri.as_str());
248
249    if let Some(ref user_agent) = configuration.user_agent {
250        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
251    }
252    if let Some(ref bearer_token) = configuration.bearer_access_token {
253        req_builder = req_builder.bearer_auth(bearer_token.to_owned());
254    }
255    req_builder = req_builder.header(AUTH_HOSTNAME_HEADER, configuration.auth_hostname.to_owned());
256
257    req_builder = req_builder.json(&params);
258
259    let req = req_builder.build()?;
260    let resp = client.execute(req).await?;
261
262    let status = resp.status();
263    let content = resp.text().await?;
264
265    if !status.is_client_error() && !status.is_server_error() {
266        serde_json::from_str(&content).map_err(Error::from)
267    } else {
268        let entity: Option<ApiKeyError> = serde_json::from_str(&content).ok();
269        let error = ResponseContent {
270            status,
271            content,
272            entity,
273        };
274        Err(Error::ResponseError(error))
275    }
276}
277
278pub async fn update_api_key(
279    configuration: &configuration::Configuration,
280    api_key_id: String,
281    params: UpdateApiKeyParams,
282) -> Result<crate::models::SuccessfulResponse, Error<ApiKeyError>> {
283    if hex::decode(&api_key_id).is_err() {
284        return Err(Error::Params("Invalid API key ID format".to_string()));
285    }
286
287    let client = &configuration.client;
288
289    let uri = format!(
290        "{}/api/backend/v1/end_user_api_keys/{}",
291        configuration.base_path, api_key_id
292    );
293    let mut req_builder = client.request(reqwest::Method::PATCH, uri.as_str());
294
295    if let Some(ref user_agent) = configuration.user_agent {
296        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
297    }
298    if let Some(ref bearer_token) = configuration.bearer_access_token {
299        req_builder = req_builder.bearer_auth(bearer_token.to_owned());
300    }
301    req_builder = req_builder.header(AUTH_HOSTNAME_HEADER, configuration.auth_hostname.to_owned());
302
303    req_builder = req_builder.json(&params);
304
305    let req = req_builder.build()?;
306    let resp = client.execute(req).await?;
307
308    let status = resp.status();
309    let content = resp.text().await?;
310
311    if !status.is_client_error() && !status.is_server_error() {
312        serde_json::from_str(&content).map_err(Error::from)
313    } else {
314        let entity: Option<ApiKeyError> = serde_json::from_str(&content).ok();
315        let error = ResponseContent {
316            status,
317            content,
318            entity,
319        };
320        Err(Error::ResponseError(error))
321    }
322}
323
324pub async fn delete_api_key(
325    configuration: &configuration::Configuration,
326    api_key_id: String,
327) -> Result<crate::models::SuccessfulResponse, Error<ApiKeyError>> {
328    if hex::decode(&api_key_id).is_err() {
329        return Err(Error::Params("Invalid API key ID format".to_string()));
330    }
331
332    let client = &configuration.client;
333
334    let uri = format!(
335        "{}/api/backend/v1/end_user_api_keys/{}",
336        configuration.base_path, api_key_id
337    );
338    let mut req_builder = client.request(reqwest::Method::DELETE, uri.as_str());
339
340    if let Some(ref user_agent) = configuration.user_agent {
341        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
342    }
343    if let Some(ref bearer_token) = configuration.bearer_access_token {
344        req_builder = req_builder.bearer_auth(bearer_token.to_owned());
345    }
346    req_builder = req_builder.header(AUTH_HOSTNAME_HEADER, configuration.auth_hostname.to_owned());
347
348    let req = req_builder.build()?;
349    let resp = client.execute(req).await?;
350
351    let status = resp.status();
352    let content = resp.text().await?;
353
354    if !status.is_client_error() && !status.is_server_error() {
355        Ok(crate::models::successful_response::SuccessfulResponse { message: None })
356    } else {
357        let entity: Option<ApiKeyError> = serde_json::from_str(&content).ok();
358        let error = ResponseContent {
359            status,
360            content,
361            entity,
362        };
363        Err(Error::ResponseError(error))
364    }
365}
366
367pub async fn validate_api_key(
368    configuration: &configuration::Configuration,
369    params: ValidateApiKeyParams,
370) -> Result<crate::models::ValidateApiKeyResponse, Error<ApiKeyValidationErrorResponse>> {
371    let client = &configuration.client;
372
373    let uri = format!(
374        "{}/api/backend/v1/end_user_api_keys/validate",
375        configuration.base_path
376    );
377    let mut req_builder = client.request(reqwest::Method::POST, uri.as_str());
378
379    if let Some(ref user_agent) = configuration.user_agent {
380        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
381    }
382    if let Some(ref bearer_token) = configuration.bearer_access_token {
383        req_builder = req_builder.bearer_auth(bearer_token.to_owned());
384    }
385    req_builder = req_builder.header(AUTH_HOSTNAME_HEADER, configuration.auth_hostname.to_owned());
386
387    req_builder = req_builder.json(&params);
388
389    let req = req_builder.build()?;
390    let resp = client.execute(req).await?;
391
392    let status = resp.status();
393    let content = resp.text().await?;
394
395    if !status.is_client_error() && !status.is_server_error() {
396        serde_json::from_str(&content).map_err(Error::from)
397    } else {
398        let entity: Option<ApiKeyValidationErrorResponse> = serde_json::from_str(&content).ok();
399        let error = ResponseContent {
400            status,
401            content,
402            entity,
403        };
404        Err(Error::ResponseError(error))
405    }
406}
propelauth/apis/api_key_service_api.rs

propelauth/apis/
api_key_service_api.rs
