Skip to main content

openauth_core/user/
mod.rs

1//! Database-backed user and credential account helpers.
2
3mod 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}