1mod input;
4mod record;
5
6use std::sync::{Arc, Mutex};
7
8use time::OffsetDateTime;
9
10use crate::crypto::random::generate_random_string;
11use crate::db::{
12 Account, Create, DbAdapter, DbValue, Delete, DeleteMany, FindMany, FindOne, JoinOption, Update,
13 User, Where,
14};
15use crate::error::OpenAuthError;
16pub use input::{
17 CreateCredentialAccountInput, CreateOAuthAccountInput, CreateUserInput, UpdateAccountInput,
18 UpdateUserInput,
19};
20use record::{
21 account_from_record, user_from_record, ACCOUNT_FIELDS, USER_FIELDS, USER_FIELDS_WITH_USERNAME,
22};
23
24pub(super) const USER_MODEL: &str = "user";
25pub(super) const ACCOUNT_MODEL: &str = "account";
26const CREDENTIAL_PROVIDER_ID: &str = "credential";
27const DEFAULT_ID_LENGTH: usize = 32;
28
29#[derive(Debug, Clone, PartialEq, Eq)]
30pub struct UserWithAccounts {
31 pub user: User,
32 pub accounts: Vec<Account>,
33}
34
35#[derive(Debug, Clone, PartialEq, Eq)]
36pub struct OAuthUserLookup {
37 pub user: User,
38 pub accounts: Vec<Account>,
39 pub linked_account: Option<Account>,
40}
41
42#[derive(Debug, Clone, PartialEq, Eq)]
43pub struct CreateOAuthUserResult {
44 pub user: User,
45 pub account: Account,
46}
47
48#[derive(Clone, Copy)]
49pub struct DbUserStore<'a> {
50 adapter: &'a dyn DbAdapter,
51}
52
53impl<'a> DbUserStore<'a> {
54 pub fn new(adapter: &'a dyn DbAdapter) -> Self {
55 Self { adapter }
56 }
57
58 pub async fn create_user(&self, input: CreateUserInput) -> Result<User, OpenAuthError> {
59 let now = OffsetDateTime::now_utc();
60 let id = input
61 .id
62 .unwrap_or_else(|| generate_random_string(DEFAULT_ID_LENGTH));
63
64 let include_username_fields = input.username.is_some() || input.display_username.is_some();
65 let mut query = Create::new(USER_MODEL)
66 .data("id", DbValue::String(id))
67 .data("name", DbValue::String(input.name))
68 .data("email", DbValue::String(normalize_email(&input.email)))
69 .data("email_verified", DbValue::Boolean(input.email_verified))
70 .data("image", optional_string(input.image))
71 .data("created_at", DbValue::Timestamp(now))
72 .data("updated_at", DbValue::Timestamp(now))
73 .force_allow_id();
74 if include_username_fields {
75 query = query
76 .data("username", optional_string(input.username))
77 .data("display_username", optional_string(input.display_username))
78 .select(USER_FIELDS_WITH_USERNAME);
79 } else {
80 query = query.select(USER_FIELDS);
81 }
82
83 for (field, value) in input.additional_fields {
84 query = query.data(field, value);
85 }
86
87 let record = self.adapter.create(query).await?;
88
89 user_from_record(record)
90 }
91
92 pub async fn create_credential_account(
93 &self,
94 input: CreateCredentialAccountInput,
95 ) -> Result<Account, OpenAuthError> {
96 let now = OffsetDateTime::now_utc();
97 let id = input
98 .id
99 .unwrap_or_else(|| generate_random_string(DEFAULT_ID_LENGTH));
100 let account_id = input.user_id.clone();
101
102 let record = self
103 .adapter
104 .create(
105 Create::new(ACCOUNT_MODEL)
106 .data("id", DbValue::String(id))
107 .data(
108 "provider_id",
109 DbValue::String(CREDENTIAL_PROVIDER_ID.to_owned()),
110 )
111 .data("account_id", DbValue::String(account_id))
112 .data("user_id", DbValue::String(input.user_id))
113 .data("access_token", DbValue::Null)
114 .data("refresh_token", DbValue::Null)
115 .data("id_token", DbValue::Null)
116 .data("access_token_expires_at", DbValue::Null)
117 .data("refresh_token_expires_at", DbValue::Null)
118 .data("scope", DbValue::Null)
119 .data("password", DbValue::String(input.password_hash))
120 .data("created_at", DbValue::Timestamp(now))
121 .data("updated_at", DbValue::Timestamp(now))
122 .select(ACCOUNT_FIELDS)
123 .force_allow_id(),
124 )
125 .await?;
126
127 account_from_record(record)
128 }
129
130 pub async fn link_account(
131 &self,
132 input: CreateOAuthAccountInput,
133 ) -> Result<Account, OpenAuthError> {
134 let now = OffsetDateTime::now_utc();
135 let id = input
136 .id
137 .unwrap_or_else(|| generate_random_string(DEFAULT_ID_LENGTH));
138
139 let record = self
140 .adapter
141 .create(
142 Create::new(ACCOUNT_MODEL)
143 .data("id", DbValue::String(id))
144 .data("provider_id", DbValue::String(input.provider_id))
145 .data("account_id", DbValue::String(input.account_id))
146 .data("user_id", DbValue::String(input.user_id))
147 .data("access_token", optional_string(input.access_token))
148 .data("refresh_token", optional_string(input.refresh_token))
149 .data("id_token", optional_string(input.id_token))
150 .data(
151 "access_token_expires_at",
152 optional_timestamp(input.access_token_expires_at),
153 )
154 .data(
155 "refresh_token_expires_at",
156 optional_timestamp(input.refresh_token_expires_at),
157 )
158 .data("scope", optional_string(input.scope))
159 .data("password", DbValue::Null)
160 .data("created_at", DbValue::Timestamp(now))
161 .data("updated_at", DbValue::Timestamp(now))
162 .select(ACCOUNT_FIELDS)
163 .force_allow_id(),
164 )
165 .await?;
166
167 account_from_record(record)
168 }
169
170 pub async fn create_oauth_user(
171 &self,
172 user: CreateUserInput,
173 mut account: CreateOAuthAccountInput,
174 ) -> Result<CreateOAuthUserResult, OpenAuthError> {
175 let result = Arc::new(Mutex::new(None));
176 let result_for_transaction = Arc::clone(&result);
177 let transaction_status = self
178 .adapter
179 .transaction(Box::new(move |transaction| {
180 Box::pin(async move {
181 let users = DbUserStore::new(transaction.as_ref());
182 let user = users.create_user(user).await?;
183 account.user_id = user.id.clone();
184 let account = users.link_account(account).await?;
185 store_create_oauth_user_result(
186 &result_for_transaction,
187 CreateOAuthUserResult { user, account },
188 )?;
189 Ok(())
190 })
191 }))
192 .await;
193
194 match transaction_status {
195 Ok(()) => take_create_oauth_user_result(&result)?.ok_or_else(|| {
196 OpenAuthError::Adapter(
197 "create OAuth user transaction completed without a result".to_owned(),
198 )
199 }),
200 Err(error) => Err(error),
201 }
202 }
203
204 pub async fn find_user_by_email(&self, email: &str) -> Result<Option<User>, OpenAuthError> {
205 let record = self
206 .adapter
207 .find_one(
208 FindOne::new(USER_MODEL)
209 .where_clause(Where::new("email", DbValue::String(normalize_email(email))))
210 .select(USER_FIELDS),
211 )
212 .await?;
213
214 record.map(user_from_record).transpose()
215 }
216
217 pub async fn find_user_by_id(&self, user_id: &str) -> Result<Option<User>, OpenAuthError> {
218 let record = self
219 .adapter
220 .find_one(
221 FindOne::new(USER_MODEL)
222 .where_clause(Where::new("id", DbValue::String(user_id.to_owned())))
223 .select(USER_FIELDS),
224 )
225 .await?;
226
227 record.map(user_from_record).transpose()
228 }
229
230 pub async fn find_user_by_username(
231 &self,
232 username: &str,
233 ) -> Result<Option<User>, OpenAuthError> {
234 let record = self
235 .adapter
236 .find_one(
237 FindOne::new(USER_MODEL)
238 .where_clause(Where::new("username", DbValue::String(username.to_owned())))
239 .select(USER_FIELDS_WITH_USERNAME),
240 )
241 .await?;
242
243 record.map(user_from_record).transpose()
244 }
245
246 pub async fn find_user_by_username_with_accounts(
247 &self,
248 username: &str,
249 ) -> Result<Option<UserWithAccounts>, OpenAuthError> {
250 let Some(user) = self.find_user_by_username(username).await? else {
251 return Ok(None);
252 };
253 let accounts = self.list_accounts_for_user(&user.id).await?;
254 Ok(Some(UserWithAccounts { user, accounts }))
255 }
256
257 pub async fn find_user_by_email_with_accounts(
258 &self,
259 email: &str,
260 ) -> Result<Option<UserWithAccounts>, OpenAuthError> {
261 let Some(mut record) = self
262 .adapter
263 .find_one(
264 FindOne::new(USER_MODEL)
265 .where_clause(Where::new("email", DbValue::String(normalize_email(email))))
266 .select(USER_FIELDS)
267 .join(ACCOUNT_MODEL, JoinOption::enabled()),
268 )
269 .await?
270 else {
271 return Ok(None);
272 };
273
274 let joined_accounts = record.shift_remove(ACCOUNT_MODEL);
275 let user = user_from_record(record)?;
276 let accounts = match joined_accounts {
277 Some(DbValue::RecordArray(accounts)) => accounts
278 .into_iter()
279 .map(account_from_record)
280 .collect::<Result<Vec<_>, _>>()?,
281 Some(DbValue::Null) => Vec::new(),
282 None => self.list_accounts_for_user(&user.id).await?,
283 Some(_) => {
284 return Err(OpenAuthError::Adapter(
285 "joined account result must be an array".to_owned(),
286 ));
287 }
288 };
289 Ok(Some(UserWithAccounts { user, accounts }))
290 }
291
292 pub async fn find_oauth_user(
293 &self,
294 email: &str,
295 account_id: &str,
296 provider_id: &str,
297 ) -> Result<Option<OAuthUserLookup>, OpenAuthError> {
298 let linked_account = self
299 .find_account_by_provider_account(account_id, provider_id)
300 .await?;
301 let user = if let Some(account) = &linked_account {
302 self.find_user_by_id(&account.user_id).await?
303 } else {
304 self.find_user_by_email(email).await?
305 };
306 let Some(user) = user else {
307 return Ok(None);
308 };
309 let accounts = self.list_accounts_for_user(&user.id).await?;
310 Ok(Some(OAuthUserLookup {
311 user,
312 accounts,
313 linked_account,
314 }))
315 }
316
317 pub async fn list_accounts_for_user(
318 &self,
319 user_id: &str,
320 ) -> Result<Vec<Account>, OpenAuthError> {
321 self.adapter
322 .find_many(
323 FindMany::new(ACCOUNT_MODEL)
324 .where_clause(Where::new("user_id", DbValue::String(user_id.to_owned())))
325 .select(ACCOUNT_FIELDS),
326 )
327 .await?
328 .into_iter()
329 .map(account_from_record)
330 .collect()
331 }
332
333 pub async fn find_credential_account(
334 &self,
335 user_id: &str,
336 ) -> Result<Option<Account>, OpenAuthError> {
337 let record = self
338 .adapter
339 .find_one(
340 FindOne::new(ACCOUNT_MODEL)
341 .where_clause(Where::new("user_id", DbValue::String(user_id.to_owned())))
342 .where_clause(Where::new(
343 "provider_id",
344 DbValue::String(CREDENTIAL_PROVIDER_ID.to_owned()),
345 ))
346 .select(ACCOUNT_FIELDS),
347 )
348 .await?;
349
350 record.map(account_from_record).transpose()
351 }
352
353 pub async fn find_account_by_provider_account(
354 &self,
355 account_id: &str,
356 provider_id: &str,
357 ) -> Result<Option<Account>, OpenAuthError> {
358 let record = self
359 .adapter
360 .find_one(
361 FindOne::new(ACCOUNT_MODEL)
362 .where_clause(Where::new(
363 "account_id",
364 DbValue::String(account_id.to_owned()),
365 ))
366 .where_clause(Where::new(
367 "provider_id",
368 DbValue::String(provider_id.to_owned()),
369 ))
370 .select(ACCOUNT_FIELDS),
371 )
372 .await?;
373
374 record.map(account_from_record).transpose()
375 }
376
377 pub async fn update_account(
378 &self,
379 account_id: &str,
380 input: UpdateAccountInput,
381 ) -> Result<Option<Account>, OpenAuthError> {
382 let mut query = Update::new(ACCOUNT_MODEL)
383 .where_clause(Where::new("id", DbValue::String(account_id.to_owned())))
384 .data("updated_at", DbValue::Timestamp(OffsetDateTime::now_utc()));
385 if let Some(value) = input.access_token {
386 query = query.data("access_token", optional_string(value));
387 }
388 if let Some(value) = input.refresh_token {
389 query = query.data("refresh_token", optional_string(value));
390 }
391 if let Some(value) = input.id_token {
392 query = query.data("id_token", optional_string(value));
393 }
394 if let Some(value) = input.access_token_expires_at {
395 query = query.data("access_token_expires_at", optional_timestamp(value));
396 }
397 if let Some(value) = input.refresh_token_expires_at {
398 query = query.data("refresh_token_expires_at", optional_timestamp(value));
399 }
400 if let Some(value) = input.scope {
401 query = query.data("scope", optional_string(value));
402 }
403
404 self.adapter
405 .update(query)
406 .await?
407 .map(account_from_record)
408 .transpose()
409 }
410
411 pub async fn update_user(
412 &self,
413 user_id: &str,
414 input: UpdateUserInput,
415 ) -> Result<Option<User>, OpenAuthError> {
416 if input.is_empty() {
417 return self.find_user_by_id(user_id).await;
418 }
419 let mut query = Update::new(USER_MODEL)
420 .where_clause(Where::new("id", DbValue::String(user_id.to_owned())))
421 .data("updated_at", DbValue::Timestamp(OffsetDateTime::now_utc()));
422 if let Some(name) = input.name {
423 query = query.data("name", DbValue::String(name));
424 }
425 if let Some(image) = input.image {
426 query = query.data("image", optional_string(image));
427 }
428 if let Some(username) = input.username {
429 query = query.data("username", optional_string(username));
430 }
431 if let Some(display_username) = input.display_username {
432 query = query.data("display_username", optional_string(display_username));
433 }
434 for (field, value) in input.fields {
435 query = query.data(field, value);
436 }
437 for (field, value) in input.additional_fields {
438 query = query.data(field, value);
439 }
440
441 self.adapter
442 .update(query)
443 .await?
444 .map(user_from_record)
445 .transpose()
446 }
447
448 pub async fn update_credential_password(
449 &self,
450 user_id: &str,
451 password_hash: &str,
452 ) -> Result<Option<Account>, OpenAuthError> {
453 self.adapter
454 .update(
455 Update::new(ACCOUNT_MODEL)
456 .where_clause(Where::new("user_id", DbValue::String(user_id.to_owned())))
457 .where_clause(Where::new(
458 "provider_id",
459 DbValue::String(CREDENTIAL_PROVIDER_ID.to_owned()),
460 ))
461 .data("password", DbValue::String(password_hash.to_owned()))
462 .data("updated_at", DbValue::Timestamp(OffsetDateTime::now_utc())),
463 )
464 .await?
465 .map(account_from_record)
466 .transpose()
467 }
468
469 pub async fn update_user_email_verified(
470 &self,
471 user_id: &str,
472 email_verified: bool,
473 ) -> Result<Option<User>, OpenAuthError> {
474 self.adapter
475 .update(
476 Update::new(USER_MODEL)
477 .where_clause(Where::new("id", DbValue::String(user_id.to_owned())))
478 .data("email_verified", DbValue::Boolean(email_verified))
479 .data("updated_at", DbValue::Timestamp(OffsetDateTime::now_utc())),
480 )
481 .await?
482 .map(user_from_record)
483 .transpose()
484 }
485
486 pub async fn update_user_email(
487 &self,
488 user_id: &str,
489 email: &str,
490 email_verified: bool,
491 ) -> Result<Option<User>, OpenAuthError> {
492 self.adapter
493 .update(
494 Update::new(USER_MODEL)
495 .where_clause(Where::new("id", DbValue::String(user_id.to_owned())))
496 .data("email", DbValue::String(normalize_email(email)))
497 .data("email_verified", DbValue::Boolean(email_verified))
498 .data("updated_at", DbValue::Timestamp(OffsetDateTime::now_utc())),
499 )
500 .await?
501 .map(user_from_record)
502 .transpose()
503 }
504
505 pub async fn delete_account(&self, account_id: &str) -> Result<(), OpenAuthError> {
506 self.adapter
507 .delete(
508 Delete::new(ACCOUNT_MODEL)
509 .where_clause(Where::new("id", DbValue::String(account_id.to_owned()))),
510 )
511 .await
512 }
513
514 pub async fn delete_user_accounts(&self, user_id: &str) -> Result<u64, OpenAuthError> {
515 self.adapter
516 .delete_many(
517 DeleteMany::new(ACCOUNT_MODEL)
518 .where_clause(Where::new("user_id", DbValue::String(user_id.to_owned()))),
519 )
520 .await
521 }
522
523 pub async fn delete_user(&self, user_id: &str) -> Result<(), OpenAuthError> {
524 self.adapter
525 .delete(
526 Delete::new(USER_MODEL)
527 .where_clause(Where::new("id", DbValue::String(user_id.to_owned()))),
528 )
529 .await
530 }
531}
532
533fn normalize_email(email: &str) -> String {
534 email.to_lowercase()
535}
536
537fn optional_string(value: Option<String>) -> DbValue {
538 value.map(DbValue::String).unwrap_or(DbValue::Null)
539}
540
541fn optional_timestamp(value: Option<OffsetDateTime>) -> DbValue {
542 value.map(DbValue::Timestamp).unwrap_or(DbValue::Null)
543}
544
545fn store_create_oauth_user_result(
546 result: &Mutex<Option<CreateOAuthUserResult>>,
547 value: CreateOAuthUserResult,
548) -> Result<(), OpenAuthError> {
549 let mut guard = result.lock().map_err(|_| OpenAuthError::LockPoisoned {
550 context: "create OAuth user result",
551 })?;
552 *guard = Some(value);
553 Ok(())
554}
555
556fn take_create_oauth_user_result(
557 result: &Mutex<Option<CreateOAuthUserResult>>,
558) -> Result<Option<CreateOAuthUserResult>, OpenAuthError> {
559 result
560 .lock()
561 .map_err(|_| OpenAuthError::LockPoisoned {
562 context: "create OAuth user result",
563 })
564 .map(|mut guard| guard.take())
565}