+217 -5

src/auth.rs

··· 1 1 + use std::{ 2 2 + sync::{Arc, RwLock}, 3 3 + time::Duration, 4 4 + }; 5 5 + 1 6 use base64::{Engine, prelude::BASE64_STANDARD_NO_PAD}; 2 7 use reqwest::{Method, header::HeaderMap}; 3 3 - use serde::Deserialize; 8 8 + use serde::{Deserialize, Deserializer, Serialize, Serializer}; 4 9 use serde_json::{Value, json}; 5 10 6 6 - use crate::{Error, JsonObject, record::RecordService}; 11 11 + use crate::{Error, JsonObject, PocketBase, PocketBaseInner, record::RecordService}; 7 12 8 13 #[derive(Debug, Clone)] 9 14 pub struct AuthStore { 10 10 - pub(crate) token: String, 11 11 - record: RecordModel, 15 15 + pub token: String, 16 16 + pub record: RecordModel, 17 17 + } 18 18 + 19 19 + #[derive(Clone, Debug, Deserialize, Serialize)] 20 20 + pub struct AuthMethodList { 21 21 + pub mfa: AuthMethodMfa, 22 22 + pub oauth2: AuthMethodOAuth2, 23 23 + pub otp: AuthMethodOtp, 24 24 + pub password: AuthMethodPassword, 25 25 + } 26 26 + 27 27 + #[derive(Clone, Debug, Deserialize, Serialize)] 28 28 + pub struct AuthMethodMfa { 29 29 + #[serde( 30 30 + deserialize_with = "deserialize_duration", 31 31 + serialize_with = "serialize_duration" 32 32 + )] 33 33 + pub duration: Duration, 34 34 + pub enabled: bool, 35 35 + } 36 36 + 37 37 + #[derive(Clone, Debug, Deserialize, Serialize)] 38 38 + pub struct AuthMethodOAuth2 { 39 39 + pub enabled: bool, 40 40 + pub providers: Vec<AuthMethodProvider>, 41 41 + } 42 42 + 43 43 + #[derive(Clone, Debug, Deserialize, Serialize)] 44 44 + pub struct AuthMethodOtp { 45 45 + #[serde( 46 46 + deserialize_with = "deserialize_duration", 47 47 + serialize_with = "serialize_duration" 48 48 + )] 49 49 + pub duration: Duration, 50 50 + pub enabled: bool, 51 51 + } 52 52 + 53 53 + #[derive(Clone, Debug, Deserialize, Serialize)] 54 54 + #[serde(rename_all = "camelCase")] 55 55 + pub struct AuthMethodProvider { 56 56 + pub auth_url: String, 57 57 + pub code_challenge: String, 58 58 + pub code_challenge_method: String, 59 59 + pub code_verifier: String, 60 60 + pub display_name: String, 61 61 + pub name: String, 62 62 + pub pkce: Option<bool>, 63 63 + pub state: String, 64 64 + } 65 65 + 66 66 + #[derive(Clone, Debug, Deserialize, Serialize)] 67 67 + #[serde(rename_all = "camelCase")] 68 68 + pub struct AuthMethodPassword { 69 69 + pub enabled: bool, 70 70 + pub identity_fields: Vec<String>, 12 71 } 13 72 14 73 #[derive(Debug, Clone)] ··· 19 78 } 20 79 21 80 #[derive(Debug, Clone)] 81 81 + pub struct AuthWithOtpBuilder<'a> { 82 82 + pub(crate) record_service: RecordService<'a>, 83 83 + pub(crate) otp_id: &'a str, 84 84 + pub(crate) password: &'a str, 85 85 + pub(crate) expand_fields: Option<&'a str>, 86 86 + pub(crate) filter_fields: Option<&'a str>, 87 87 + } 88 88 + 89 89 + #[derive(Debug, Clone)] 22 90 pub struct AuthWithPasswordBuilder<'a> { 23 91 pub(crate) record_service: RecordService<'a>, 24 92 pub(crate) identity: &'a str, ··· 27 95 pub(crate) filter_fields: Option<&'a str>, 28 96 } 29 97 98 98 + #[derive(Debug, Clone)] 99 99 + pub struct ImpersonateBuilder<'a> { 100 100 + pub(crate) record_service: RecordService<'a>, 101 101 + pub(crate) id: &'a str, 102 102 + pub(crate) duration: Option<Duration>, 103 103 + pub(crate) expand_fields: Option<&'a str>, 104 104 + pub(crate) filter_fields: Option<&'a str>, 105 105 + } 106 106 + 30 107 #[derive(Debug, Deserialize, Clone)] 31 108 pub struct RecordAuth { 32 109 token: String, ··· 36 113 #[derive(Debug, Deserialize, Clone)] 37 114 #[serde(transparent)] 38 115 pub struct RecordModel { 39 39 - data: JsonObject, 116 116 + pub(crate) data: JsonObject, 117 117 + } 118 118 + 119 119 + fn deserialize_duration<'de, D>(deserializer: D) -> Result<Duration, D::Error> 120 120 + where 121 121 + D: Deserializer<'de>, 122 122 + { 123 123 + u64::deserialize(deserializer).map(Duration::from_secs) 40 124 } 41 125 42 126 #[cfg(target_arch = "wasm32")] ··· 57 141 .duration_since(UNIX_EPOCH) 58 142 .unwrap() 59 143 .as_secs() 144 144 + } 145 145 + 146 146 + fn serialize_duration<S>(dur: &Duration, serializer: S) -> Result<S::Ok, S::Error> 147 147 + where 148 148 + S: Serializer, 149 149 + { 150 150 + dur.as_secs().serialize(serializer) 60 151 } 61 152 62 153 impl AuthStore { ··· 133 224 } 134 225 } 135 226 227 227 + impl<'a> AuthWithOtpBuilder<'a> { 228 228 + pub fn expand_fields(mut self, field_expression: &'a str) -> Self { 229 229 + self.expand_fields = Some(field_expression); 230 230 + self 231 231 + } 232 232 + 233 233 + pub fn filter_fields(mut self, field_expression: &'a str) -> Self { 234 234 + self.filter_fields = Some(field_expression); 235 235 + self 236 236 + } 237 237 + 238 238 + pub async fn send(self) -> Result<RecordAuth, Error> { 239 239 + let body = json!({"otpId": self.otp_id, "password": self.password}); 240 240 + let mut params = Vec::new(); 241 241 + if let Some(expand) = self.expand_fields { 242 242 + params.push(("expand", expand)); 243 243 + } 244 244 + if let Some(fields) = self.filter_fields { 245 245 + params.push(("fields", fields)); 246 246 + } 247 247 + 248 248 + let auth: RecordAuth = self 249 249 + .record_service 250 250 + .client 251 251 + .send( 252 252 + &format!( 253 253 + "/api/collections/{}/auth-with-otp", 254 254 + self.record_service.collection 255 255 + ), 256 256 + Method::POST, 257 257 + HeaderMap::new(), 258 258 + &params, 259 259 + Some(&body), 260 260 + ) 261 261 + .await?; 262 262 + self.record_service.client.with_auth_store(AuthStore { 263 263 + token: auth.token.clone(), 264 264 + record: auth.record.clone(), 265 265 + }); 266 266 + debug_assert!({ 267 267 + let read = self.record_service.client.inner.read().unwrap(); 268 268 + read.auth_store.as_ref().unwrap().is_valid() 269 269 + }); 270 270 + Ok(auth) 271 271 + } 272 272 + } 273 273 + 136 274 impl<'a> AuthWithPasswordBuilder<'a> { 137 275 pub fn expand_fields(mut self, field_expression: &'a str) -> Self { 138 276 self.expand_fields = Some(field_expression); ··· 177 315 read.auth_store.as_ref().unwrap().is_valid() 178 316 }); 179 317 Ok(auth) 318 318 + } 319 319 + } 320 320 + 321 321 + impl<'a> ImpersonateBuilder<'a> { 322 322 + /// Set the duration that the generated auth token will be valid. 323 323 + /// 324 324 + /// If duration is not set, then the generated auth token will fallback to the 325 325 + /// default collection auth token duration. 326 326 + pub fn duration(mut self, duration: Duration) -> Self { 327 327 + self.duration = Some(duration); 328 328 + self 329 329 + } 330 330 + 331 331 + pub fn expand_fields(mut self, field_expression: &'a str) -> Self { 332 332 + self.expand_fields = Some(field_expression); 333 333 + self 334 334 + } 335 335 + 336 336 + pub fn filter_fields(mut self, field_expression: &'a str) -> Self { 337 337 + self.filter_fields = Some(field_expression); 338 338 + self 339 339 + } 340 340 + 341 341 + pub async fn send(self) -> Result<(PocketBase, RecordAuth), Error> { 342 342 + let mut params = Vec::new(); 343 343 + if let Some(expand) = self.expand_fields { 344 344 + params.push(("expand", expand)); 345 345 + } 346 346 + if let Some(fields) = self.filter_fields { 347 347 + params.push(("fields", fields)); 348 348 + } 349 349 + 350 350 + let auth: RecordAuth = self 351 351 + .record_service 352 352 + .client 353 353 + .send( 354 354 + &format!( 355 355 + "/api/collections/{}/impersonate/{}", 356 356 + self.record_service.collection, self.id 357 357 + ), 358 358 + Method::POST, 359 359 + HeaderMap::new(), 360 360 + &params, 361 361 + if let Some(dur) = self.duration { 362 362 + Some(json!({ "duration": dur.as_secs() })) 363 363 + } else { 364 364 + None 365 365 + } 366 366 + .as_ref(), 367 367 + ) 368 368 + .await?; 369 369 + 370 370 + let client = { 371 371 + let inner = self.record_service.client.inner.read().unwrap(); 372 372 + PocketBase { 373 373 + inner: Arc::new(RwLock::new(PocketBaseInner { 374 374 + reqwest: inner.reqwest.clone(), 375 375 + auth_store: None, 376 376 + base_url: inner.base_url.clone(), 377 377 + lang: inner.lang.clone(), 378 378 + })), 379 379 + } 380 380 + }; 381 381 + 382 382 + client.with_auth_store(AuthStore { 383 383 + token: auth.token.clone(), 384 384 + record: auth.record.clone(), 385 385 + }); 386 386 + debug_assert!({ 387 387 + let read = client.inner.read().unwrap(); 388 388 + read.auth_store.as_ref().unwrap().is_valid() 389 389 + }); 390 390 + 391 391 + Ok((client, auth)) 180 392 } 181 393 } 182 394

+6

src/health.rs

··· 5 5 use crate::{Error, PocketBase}; 6 6 7 7 #[derive(Clone, Debug)] 8 8 + /// Service that handles the Health APIs. 8 9 pub struct HealthService<'a> { 10 10 + /// Reference to the PocketBase client. 9 11 pub(super) client: &'a PocketBase, 12 12 + /// Optional comma-separated list of fields to include in the response. 10 13 pub(super) fields: Option<String>, 11 14 } 12 15 13 16 #[derive(Clone, Debug, Deserialize)] 14 17 pub struct HealthCheck { 18 18 + /// Status message. 15 19 pub message: String, 20 20 + /// Additional data. 16 21 pub data: Map<String, Value>, 17 22 } 18 23 19 24 impl HealthService<'_> { 25 25 + /// Checks the health status of the api. 20 26 pub async fn check(self) -> Result<HealthCheck, Error> { 21 27 let mut params = Vec::new(); 22 28 if let Some(fields) = self.fields {

+31 -5

src/lib.rs

··· 7 7 use serde::{Serialize, de::DeserializeOwned}; 8 8 use serde_json::{Map, Value}; 9 9 use thiserror::Error; 10 10 - use url::{ParseError, Url}; 10 10 + use url::Url; 11 11 12 12 pub mod auth; 13 13 pub mod health; ··· 15 15 16 16 use crate::{auth::AuthStore, health::HealthService, record::RecordService}; 17 17 18 18 - pub type Error = reqwest::Error; 18 18 + /// Type alias for reqwest's error type, that should be generally used if an 19 19 + /// error is returned. 20 20 + type Error = reqwest::Error; 19 21 20 20 - pub type JsonObject = Map<String, Value>; 22 22 + /// Type alias for a type that can represent general JSON objects. 23 23 + type JsonObject = Map<String, Value>; 21 24 22 25 #[derive(Clone, Debug)] 26 26 + /// Main PocketBase API client. 23 27 pub struct PocketBase { 24 28 inner: Arc<RwLock<PocketBaseInner>>, 25 29 } 26 30 27 31 #[derive(Clone, Debug)] 32 32 + /// Inner storage for the PocketBase API client. 28 33 struct PocketBaseInner { 29 29 - reqwest: Client, 34 34 + /// Storage of the authenticated user and the authenticated token, if any. 30 35 auth_store: Option<AuthStore>, 36 36 + /// The PocketBase backend base url address (e.g. `http://127.0.0.1:8090`). 31 37 base_url: Url, 38 38 + /// Language code that will be sent with the requests to the server as 39 39 + /// `Accept-Language` header. 40 40 + /// 41 41 + /// Will be set to `en-US` by default. 32 42 lang: String, 43 43 + /// Reqwest [`Client`] used. 44 44 + reqwest: Client, 33 45 } 34 46 35 47 impl PocketBase { 48 48 + /// Clears the previously stored token and record auth data. 36 49 pub fn auth_clear<'a>(&'a self) { 37 50 let mut write = self.inner.write().unwrap(); 38 51 write.auth_store = None; 39 52 } 40 53 54 54 + /// Returns the [`RecordService`] associated to the specified collection. 41 55 pub fn collection<'a>(&'a self, collection: &'a str) -> RecordService<'a> { 42 56 RecordService { 43 57 client: self, ··· 45 59 } 46 60 } 47 61 62 62 + /// Return an instance of the service that handles the Health APIs. 48 63 pub fn health(&self) -> HealthService { 49 64 HealthService { 50 65 client: self, ··· 52 67 } 53 68 } 54 69 70 70 + /// Get the language code that will be sent with the requests to the server as 71 71 + /// `Accept-Language` header. 55 72 pub fn lang(&self) -> String { 56 73 self.inner.read().unwrap().lang.clone() 57 74 } 58 75 59 59 - pub fn new(base_url: &str) -> Result<Self, ParseError> { 76 76 + /// Create a new [`PocketBase`] instance using the provided base URL for the 77 77 + /// PocketBase instance (e.g. `http://127.0.0.1:8090`). 78 78 + pub fn new(base_url: &str) -> Result<Self, url::ParseError> { 60 79 let base_url = Url::parse(base_url)?; 61 80 let inner = PocketBaseInner { 62 81 reqwest: Client::new(), ··· 69 88 }) 70 89 } 71 90 91 91 + /// Internal method used to send requests to the Pockatbase instance. 72 92 async fn send<Q, B, T>( 73 93 &self, 74 94 path: &str, ··· 125 145 response.error_for_status()?.json().await 126 146 } 127 147 148 148 + /// Internal method to set the authentication store when using one of the 149 149 + /// authentication methods. 128 150 fn with_auth_store(&self, auth: AuthStore) { 129 151 let mut write = self.inner.write().unwrap(); 130 152 write.auth_store = Some(auth); 131 153 } 132 154 155 155 + /// Set the language code that will be sent with the requests to the server as 156 156 + /// `Accept-Language` header. 157 157 + /// 158 158 + /// Will be`en-US`, if not set. 133 159 pub fn with_lang(self, lang: String) -> Self { 134 160 { 135 161 let mut write = self.inner.write().unwrap();

+252 -8

src/record.rs

··· 1 1 + use base64::{Engine, prelude::BASE64_STANDARD_NO_PAD}; 1 2 use reqwest::{Method, header::HeaderMap}; 2 3 use serde::{Deserialize, Serialize, de::DeserializeOwned}; 3 3 - use serde_json::{Map, Value}; 4 4 + use serde_json::{Map, Value, json}; 4 5 5 6 use crate::{ 6 7 Error, JsonObject, PocketBase, 7 7 - auth::{AuthRefreshBuilder, AuthWithPasswordBuilder}, 8 8 + auth::{ 9 9 + AuthMethodList, AuthRefreshBuilder, AuthWithOtpBuilder, AuthWithPasswordBuilder, 10 10 + ImpersonateBuilder, 11 11 + }, 8 12 }; 9 13 10 10 - pub struct CreateRequestBuilder<'a, T: Serialize = JsonObject> { 14 14 + const NO_PARAMS: &[&str] = &[]; 15 15 + 16 16 + pub struct CreateRequestBuilder<'a, T: Serialize> { 11 17 record_service: RecordService<'a>, 12 18 body: T, 13 19 } ··· 65 71 } 66 72 67 73 #[derive(Clone, Debug)] 68 68 - pub struct UpdateRequestBuilder<'a, T: Serialize = JsonObject> { 74 74 + pub struct UpdateRequestBuilder<'a, T: Serialize> { 69 75 record_service: RecordService<'a>, 70 76 body: T, 71 77 expand_fields: Option<&'a str>, ··· 100 106 } 101 107 } 102 108 103 103 - impl CreateRequestBuilder<'_, JsonObject> { 109 109 + impl<T: Extend<(String, Value)> + Serialize> CreateRequestBuilder<'_, T> { 104 110 pub fn fields<Iter: IntoIterator<Item = (String, Value)>>(mut self, patch: Iter) -> Self { 105 111 self.body.extend(patch); 106 112 self ··· 123 129 None::<&()>, 124 130 ) 125 131 .await 132 132 + // TODO: Dart SDK also implements the following behaviour. 133 133 + // 134 134 + // If the current [`AuthStore.record`] matches with the deleted id, then on 135 135 + // success the client [`AuthStore`] will be also cleared. 126 136 } 127 137 } 128 138 ··· 248 258 } 249 259 250 260 impl<'a> RecordService<'a> { 261 261 + /// Refreshes the current authenticated auth record instance and returns a new 262 262 + /// token and record data. 263 263 + /// 264 264 + /// On success this method automatically updates the client's AuthStore. 251 265 pub fn auth_refresh(&self) -> AuthRefreshBuilder<'a> { 252 266 AuthRefreshBuilder { 253 267 record_service: self.clone(), ··· 256 270 } 257 271 } 258 272 273 273 + /// Authenticate an auth record via OTP. 274 274 + /// 275 275 + /// On success this method automatically updates the client's [`AuthStore`]. 276 276 + pub fn auth_with_otp(&'a self, otp_id: &'a str, password: &'a str) -> AuthWithOtpBuilder<'a> { 277 277 + AuthWithOtpBuilder { 278 278 + record_service: self.clone(), 279 279 + otp_id, 280 280 + password, 281 281 + expand_fields: None, 282 282 + filter_fields: None, 283 283 + } 284 284 + } 285 285 + 286 286 + /// Authenticate an auth record by its username/email and password and returns 287 287 + /// a new auth token and record data. 288 288 + /// 289 289 + /// On success this method automatically updates the client's [`AuthStore`]. 259 290 pub fn auth_with_password( 260 291 &self, 261 292 identity: &'a str, ··· 270 301 } 271 302 } 272 303 273 273 - pub fn create(&self) -> CreateRequestBuilder<'a> { 304 304 + /// Confirms auth record new email address. 305 305 + /// 306 306 + /// If the current [`AuthStore.record`] matches with the record from the 307 307 + /// token, then on success the client [`AuthStore`] will be also cleared. 308 308 + pub async fn confirm_email_change(&self, token: &str, password: &str) -> Result<(), Error> { 309 309 + let () = self 310 310 + .client 311 311 + .send( 312 312 + &format!("/api/collections/{}/confirm-email-change", self.collection), 313 313 + Method::POST, 314 314 + HeaderMap::new(), 315 315 + NO_PARAMS, 316 316 + Some(&json!({ "token": token, "password": password })), 317 317 + ) 318 318 + .await?; 319 319 + 320 320 + let parts: Vec<_> = token.split(".").collect(); 321 321 + if parts.len() != 3 { 322 322 + return Ok(()); 323 323 + } 324 324 + let Ok(payload_str) = String::from_utf8(BASE64_STANDARD_NO_PAD.decode(parts[1]).unwrap()) 325 325 + else { 326 326 + return Ok(()); 327 327 + }; 328 328 + let Ok(payload) = serde_json::from_str::<JsonObject>(&payload_str) else { 329 329 + return Ok(()); 330 330 + }; 331 331 + 332 332 + { 333 333 + let inner = self.client.inner.read().unwrap(); 334 334 + if let Some(auth) = inner.auth_store.as_ref() { 335 335 + if auth.record.data.get("id") == payload.get("id") 336 336 + && auth.record.data.get("collectionId") == payload.get("collectionId") 337 337 + { 338 338 + self.client.auth_clear(); 339 339 + } 340 340 + } 341 341 + } 342 342 + Ok(()) 343 343 + } 344 344 + 345 345 + /// Confirms auth record password reset request. 346 346 + pub async fn confirm_password_reset( 347 347 + &self, 348 348 + token: &str, 349 349 + password: &str, 350 350 + password_confirm: &str, 351 351 + ) -> Result<(), Error> { 352 352 + self.client 353 353 + .send( 354 354 + &format!( 355 355 + "/api/collections/{}/confirm-password-reset", 356 356 + self.collection 357 357 + ), 358 358 + Method::POST, 359 359 + HeaderMap::new(), 360 360 + NO_PARAMS, 361 361 + Some( 362 362 + &json!({ "token": token, "password": password, "passwordConfirm": password_confirm }), 363 363 + ), 364 364 + ) 365 365 + .await 366 366 + } 367 367 + 368 368 + /// Confirms auth record email verification request. 369 369 + /// 370 370 + /// On success this method automatically updates the client's [`AuthStore`]. 371 371 + pub async fn confirm_verification(&self, token: &str) -> Result<(), Error> { 372 372 + let () = self 373 373 + .client 374 374 + .send( 375 375 + &format!("/api/collections/{}/confirm-verification", self.collection), 376 376 + Method::POST, 377 377 + HeaderMap::new(), 378 378 + NO_PARAMS, 379 379 + Some(&json!({ "token": token })), 380 380 + ) 381 381 + .await?; 382 382 + 383 383 + let parts: Vec<_> = token.split(".").collect(); 384 384 + if parts.len() != 3 { 385 385 + return Ok(()); 386 386 + } 387 387 + let Ok(payload_str) = String::from_utf8(BASE64_STANDARD_NO_PAD.decode(parts[1]).unwrap()) 388 388 + else { 389 389 + return Ok(()); 390 390 + }; 391 391 + let Ok(payload) = serde_json::from_str::<JsonObject>(&payload_str) else { 392 392 + return Ok(()); 393 393 + }; 394 394 + 395 395 + { 396 396 + let mut inner = self.client.inner.write().unwrap(); 397 397 + if let Some(auth) = inner.auth_store.as_mut() { 398 398 + if !auth 399 399 + .record 400 400 + .data 401 401 + .get("verified") 402 402 + .map(|v| v.as_bool().unwrap_or(false)) 403 403 + .unwrap_or(false) 404 404 + && auth.record.data.get("id") == payload.get("id") 405 405 + && auth.record.data.get("collectionId") == payload.get("collectionId") 406 406 + { 407 407 + let _ = auth.record.data.insert("verified".to_string(), true.into()); 408 408 + } 409 409 + } 410 410 + } 411 411 + Ok(()) 412 412 + } 413 413 + 414 414 + /// Creates a new item. 415 415 + pub fn create(&self) -> CreateRequestBuilder<'a, JsonObject> { 274 416 CreateRequestBuilder { 275 417 record_service: self.clone(), 276 418 body: Map::new(), 277 419 } 278 420 } 279 421 422 422 + /// Deletes a single record model by its id. 280 423 pub fn delete(&self, id: &'a str) -> DeleteRequestBuilder<'a> { 281 424 DeleteRequestBuilder { 282 425 record_service: self.clone(), ··· 284 427 } 285 428 } 286 429 430 430 + /// Returns a list with all items batch fetched at once. 287 431 pub fn get_full_list(&self) -> FullListRequestBuilder<'a> { 288 432 FullListRequestBuilder { 289 433 record_service: self.clone(), ··· 296 440 } 297 441 } 298 442 443 443 + /// Returns paginated items list. 299 444 pub fn get_list(&self, page: usize, per_page: usize) -> ListRequestBuilder<'a> { 300 445 ListRequestBuilder { 301 446 record_service: self.clone(), ··· 309 454 } 310 455 } 311 456 457 457 + /// Returns single item by its id. 458 458 + /// 459 459 + /// Throws `404` [`Error`] in case an empty id is provided. 312 460 pub fn get_one(&'a self, id: &'a str) -> ViewRequestBuilder<'a> { 313 461 ViewRequestBuilder { 314 462 record_service: self.clone(), ··· 318 466 } 319 467 } 320 468 321 321 - pub fn update(&self, id: &'a str) -> UpdateRequestBuilder<'a> { 469 469 + /// Authenticates with the specified recordId and returns a new client with 470 470 + /// the received auth token in a memory store. 471 471 + /// 472 472 + /// This action currently requires superusers privileges. 473 473 + pub fn impersonate(&'a self, id: &'a str) -> ImpersonateBuilder<'a> { 474 474 + ImpersonateBuilder { 475 475 + record_service: self.clone(), 476 476 + id, 477 477 + duration: None, 478 478 + expand_fields: None, 479 479 + filter_fields: None, 480 480 + } 481 481 + } 482 482 + 483 483 + /// Returns all available application auth methods. 484 484 + pub async fn list_auth_methods(&'a self) -> Result<AuthMethodList, Error> { 485 485 + self.client 486 486 + .send( 487 487 + &format!("/api/collections/{}/auth-methods", self.collection), 488 488 + Method::GET, 489 489 + HeaderMap::new(), 490 490 + NO_PARAMS, 491 491 + None::<&()>, 492 492 + ) 493 493 + .await 494 494 + } 495 495 + 496 496 + /// Sends auth record email change request to the provided email. 497 497 + pub async fn request_email_change(&self, new_email: &str) -> Result<(), Error> { 498 498 + self.client 499 499 + .send( 500 500 + &format!("/api/collections/{}/request-email-change", self.collection), 501 501 + Method::POST, 502 502 + HeaderMap::new(), 503 503 + NO_PARAMS, 504 504 + Some(&json!({ "newEmail": new_email })), 505 505 + ) 506 506 + .await 507 507 + } 508 508 + 509 509 + /// Sends auth record OTP request to the provided email. 510 510 + pub async fn request_otp(&self, email: &str) -> Result<String, Error> { 511 511 + #[derive(Deserialize)] 512 512 + #[serde(rename_all = "camelCase")] 513 513 + struct OtpIdResponse { 514 514 + otp_id: String, 515 515 + } 516 516 + 517 517 + let response: OtpIdResponse = self 518 518 + .client 519 519 + .send( 520 520 + &format!("/api/collections/{}/request-otp", self.collection), 521 521 + Method::POST, 522 522 + HeaderMap::new(), 523 523 + NO_PARAMS, 524 524 + Some(&json!({ "email": email })), 525 525 + ) 526 526 + .await?; 527 527 + 528 528 + Ok(response.otp_id) 529 529 + } 530 530 + 531 531 + /// Sends auth record password reset request. 532 532 + pub async fn request_password_reset(&self, email: &str) -> Result<(), Error> { 533 533 + self.client 534 534 + .send( 535 535 + &format!( 536 536 + "/api/collections/{}/request-password-reset", 537 537 + self.collection 538 538 + ), 539 539 + Method::POST, 540 540 + HeaderMap::new(), 541 541 + NO_PARAMS, 542 542 + Some(&json!({ "email": email })), 543 543 + ) 544 544 + .await 545 545 + } 546 546 + 547 547 + /// Sends auth record verification email request. 548 548 + pub async fn request_verification(&self, email: &str) -> Result<String, Error> { 549 549 + self.client 550 550 + .send( 551 551 + &format!("/api/collections/{}/request-verification", self.collection), 552 552 + Method::POST, 553 553 + HeaderMap::new(), 554 554 + NO_PARAMS, 555 555 + Some(&json!({ "email": email })), 556 556 + ) 557 557 + .await 558 558 + } 559 559 + 560 560 + /// Updates a single record model by its id. 561 561 + pub fn update(&self, id: &'a str) -> UpdateRequestBuilder<'a, JsonObject> { 322 562 UpdateRequestBuilder { 323 563 record_service: self.clone(), 324 564 id, ··· 453 693 Some(&self.body), 454 694 ) 455 695 .await 696 696 + // TODO: The following behaviour is also implemented in the Dart SDK. 697 697 + // 698 698 + // If the current [`AuthStore.record`] matches with the updated id, then on 699 699 + // success the client [`AuthStore`] will be updated with the result model. 456 700 } 457 701 } 458 702 459 459 - impl UpdateRequestBuilder<'_, JsonObject> { 703 703 + impl<T: Extend<(String, Value)> + Serialize> UpdateRequestBuilder<'_, T> { 460 704 pub fn fields<Iter: IntoIterator<Item = (String, Value)>>(mut self, patch: Iter) -> Self { 461 705 self.body.extend(patch); 462 706 self