Merge branch 'prop/rename-login-to-user'

4 files changed, 50 insertions, 50 deletions

diff --git a/src/token/app.rs b/src/token/app.rs
index 3f054ff..46b2d73 100644
--- a/src/token/app.rs
+++ b/src/token/app.rs
@@ -12,8 +12,8 @@ use super::{
 use crate::{
     clock::DateTime,
     db::NotFound as _,
-    login::{Login, Password, repo::Provider as _},
     name::{self, Name},
+    user::{Password, User, repo::Provider as _},
 };
 
 pub struct Tokens<'a> {
@@ -31,9 +31,9 @@ impl<'a> Tokens<'a> {
         name: &Name,
         password: &Password,
         login_at: &DateTime,
-    ) -> Result<(Login, Secret), LoginError> {
+    ) -> Result<(User, Secret), LoginError> {
         let mut tx = self.db.begin().await?;
-        let (login, stored_hash) = tx
+        let (user, stored_hash) = tx
             .auth()
             .for_name(name)
             .await
@@ -46,11 +46,11 @@ impl<'a> Tokens<'a> {
         // if the account is deleted during that time.
         tx.commit().await?;
 
-        let snapshot = login.as_snapshot().ok_or(LoginError::Rejected)?;
+        let snapshot = user.as_snapshot().ok_or(LoginError::Rejected)?;
 
         let token = if stored_hash.verify(password)? {
             let mut tx = self.db.begin().await?;
-            let token = tx.tokens().issue(&login, login_at).await?;
+            let token = tx.tokens().issue(&user, login_at).await?;
             tx.commit().await?;
             token
         } else {
@@ -62,15 +62,15 @@ impl<'a> Tokens<'a> {
 
     pub async fn change_password(
         &self,
-        login: &Login,
+        user: &User,
         password: &Password,
         to: &Password,
         changed_at: &DateTime,
-    ) -> Result<(Login, Secret), LoginError> {
+    ) -> Result<(User, Secret), LoginError> {
         let mut tx = self.db.begin().await?;
-        let (login, stored_hash) = tx
+        let (user, stored_hash) = tx
             .auth()
-            .for_login(login)
+            .for_user(user)
             .await
             .optional()?
             .ok_or(LoginError::Rejected)?;
@@ -85,13 +85,13 @@ impl<'a> Tokens<'a> {
             return Err(LoginError::Rejected);
         }
 
-        let snapshot = login.as_snapshot().ok_or(LoginError::Rejected)?;
+        let snapshot = user.as_snapshot().ok_or(LoginError::Rejected)?;
         let to_hash = to.hash()?;
 
         let mut tx = self.db.begin().await?;
-        let tokens = tx.tokens().revoke_all(&login).await?;
-        tx.logins().set_password(&login, &to_hash).await?;
-        let secret = tx.tokens().issue(&login, changed_at).await?;
+        let tokens = tx.tokens().revoke_all(&user).await?;
+        tx.users().set_password(&user, &to_hash).await?;
+        let secret = tx.tokens().issue(&user, changed_at).await?;
         tx.commit().await?;
 
         for event in tokens.into_iter().map(TokenEvent::Revoked) {
@@ -105,18 +105,18 @@ impl<'a> Tokens<'a> {
         &self,
         secret: &Secret,
         used_at: &DateTime,
-    ) -> Result<(Id, Login), ValidateError> {
+    ) -> Result<(Id, User), ValidateError> {
         let mut tx = self.db.begin().await?;
-        let (token, login) = tx
+        let (token, user) = tx
             .tokens()
             .validate(secret, used_at)
             .await
             .not_found(|| ValidateError::InvalidToken)?;
         tx.commit().await?;
 
-        let login = login.as_snapshot().ok_or(ValidateError::LoginDeleted)?;
+        let user = user.as_snapshot().ok_or(ValidateError::LoginDeleted)?;
 
-        Ok((token, login))
+        Ok((token, user))
     }
 
     pub async fn limit_stream<S, E>(
@@ -226,7 +226,7 @@ impl From<repo::auth::LoadError> for LoginError {
 pub enum ValidateError {
     #[error("invalid token")]
     InvalidToken,
-    #[error("login deleted")]
+    #[error("user deleted")]
     LoginDeleted,
     #[error(transparent)]
     Database(#[from] sqlx::Error),
diff --git a/src/token/extract/identity.rs b/src/token/extract/identity.rs
index acfd7ae..d1c0334 100644
--- a/src/token/extract/identity.rs
+++ b/src/token/extract/identity.rs
@@ -10,14 +10,14 @@ use crate::{
     app::App,
     clock::RequestedAt,
     error::{Internal, Unauthorized},
-    login::Login,
     token::{self, app::ValidateError},
+    user::User,
 };
 
 #[derive(Clone, Debug)]
 pub struct Identity {
     pub token: token::Id,
-    pub login: Login,
+    pub user: User,
 }
 
 impl FromRequestParts<App> for Identity {
@@ -31,7 +31,7 @@ impl FromRequestParts<App> for Identity {
 
         let app = State::<App>::from_request_parts(parts, state).await?;
         match app.tokens().validate(&secret, &used_at).await {
-            Ok((token, login)) => Ok(Identity { token, login }),
+            Ok((token, user)) => Ok(Identity { token, user }),
             Err(ValidateError::InvalidToken) => Err(LoginError::Unauthorized),
             Err(other) => Err(other.into()),
         }
diff --git a/src/token/repo/auth.rs b/src/token/repo/auth.rs
index 0deed10..68a81c7 100644
--- a/src/token/repo/auth.rs
+++ b/src/token/repo/auth.rs
@@ -4,8 +4,8 @@ use crate::{
     clock::DateTime,
     db::NotFound,
     event::{Instant, Sequence},
-    login::{self, History, Login, password::StoredHash},
     name::{self, Name},
+    user::{self, History, User, password::StoredHash},
 };
 
 pub trait Provider {
@@ -26,13 +26,13 @@ impl Auth<'_> {
         let row = sqlx::query!(
             r#"
                 select
-                    id as "id: login::Id",
+                    id as "id: user::Id",
                     display_name as "display_name: String",
                     canonical_name as "canonical_name: String",
                     created_sequence as "created_sequence: Sequence",
                     created_at as "created_at: DateTime",
                     password_hash as "password_hash: StoredHash"
-                from login
+                from user
                 where canonical_name = $1
             "#,
             name,
@@ -41,7 +41,7 @@ impl Auth<'_> {
         .await?;
 
         let login = History {
-            login: Login {
+            user: User {
                 id: row.id,
                 name: Name::new(row.display_name, row.canonical_name)?,
             },
@@ -51,33 +51,33 @@ impl Auth<'_> {
         Ok((login, row.password_hash))
     }
 
-    pub async fn for_login(&mut self, login: &Login) -> Result<(History, StoredHash), LoadError> {
+    pub async fn for_user(&mut self, user: &User) -> Result<(History, StoredHash), LoadError> {
         let row = sqlx::query!(
             r#"
                 select
-                    id as "id: login::Id",
+                    id as "id: user::Id",
                     display_name as "display_name: String",
                     canonical_name as "canonical_name: String",
                     created_sequence as "created_sequence: Sequence",
                     created_at as "created_at: DateTime",
                     password_hash as "password_hash: StoredHash"
-                from login
+                from user
                 where id = $1
             "#,
-            login.id,
+            user.id,
         )
         .fetch_one(&mut *self.0)
         .await?;
 
-        let login = History {
-            login: Login {
+        let user = History {
+            user: User {
                 id: row.id,
                 name: Name::new(row.display_name, row.canonical_name)?,
             },
             created: Instant::new(row.created_at, row.created_sequence),
         };
 
-        Ok((login, row.password_hash))
+        Ok((user, row.password_hash))
     }
 }
 
diff --git a/src/token/repo/token.rs b/src/token/repo/token.rs
index ff42fad..e49c2d4 100644
--- a/src/token/repo/token.rs
+++ b/src/token/repo/token.rs
@@ -5,9 +5,9 @@ use crate::{
     clock::DateTime,
     db::NotFound,
     event::{Instant, Sequence},
-    login::{self, History, Login},
     name::{self, Name},
     token::{Id, Secret},
+    user::{self, History, User},
 };
 
 pub trait Provider {
@@ -27,23 +27,23 @@ impl Tokens<'_> {
     // be used to control expiry, until the token is actually used.
     pub async fn issue(
         &mut self,
-        login: &History,
+        user: &History,
         issued_at: &DateTime,
     ) -> Result<Secret, sqlx::Error> {
         let id = Id::generate();
         let secret = Uuid::new_v4().to_string();
-        let login = login.id();
+        let user = user.id();
 
         let secret = sqlx::query_scalar!(
             r#"
                 insert
-                into token (id, secret, login, issued_at, last_used_at)
+                into token (id, secret, user, issued_at, last_used_at)
                 values ($1, $2, $3, $4, $4)
                 returning secret as "secret!: Secret"
             "#,
             id,
             secret,
-            login,
+            user,
             issued_at,
         )
         .fetch_one(&mut *self.0)
@@ -85,16 +85,16 @@ impl Tokens<'_> {
     }
 
     // Revoke tokens for a login
-    pub async fn revoke_all(&mut self, login: &login::History) -> Result<Vec<Id>, sqlx::Error> {
-        let login = login.id();
+    pub async fn revoke_all(&mut self, user: &user::History) -> Result<Vec<Id>, sqlx::Error> {
+        let user = user.id();
         let tokens = sqlx::query_scalar!(
             r#"
                 delete
                 from token
-                where login = $1
+                where user = $1
                 returning id as "id: Id"
             "#,
-            login,
+            user,
         )
         .fetch_all(&mut *self.0)
         .await?;
@@ -132,38 +132,38 @@ impl Tokens<'_> {
         // sqlite3, as of this writing, does not allow an update's `returning`
         // clause to reference columns from tables joined into the update. Two
         // queries is fine, but it feels untidy.
-        let (token, login) = sqlx::query!(
+        let (token, user) = sqlx::query!(
             r#"
                 update token
                 set last_used_at = $1
                 where secret = $2
                 returning
                     id as "token: Id",
-                    login as "login: login::Id"
+                    user as "user: user::Id"
             "#,
             used_at,
             secret,
         )
-        .map(|row| (row.token, row.login))
+        .map(|row| (row.token, row.user))
         .fetch_one(&mut *self.0)
         .await?;
 
-        let login = sqlx::query!(
+        let user = sqlx::query!(
             r#"
                 select
-                    id as "id: login::Id",
+                    id as "id: user::Id",
                     display_name as "display_name: String",
                     canonical_name as "canonical_name: String",
                     created_sequence as "created_sequence: Sequence",
                     created_at as "created_at: DateTime"
-                from login
+                from user
                 where id = $1
             "#,
-            login,
+            user,
         )
         .map(|row| {
             Ok::<_, name::Error>(History {
-                login: Login {
+                user: User {
                     id: row.id,
                     name: Name::new(row.display_name, row.canonical_name)?,
                 },
@@ -173,7 +173,7 @@ impl Tokens<'_> {
         .fetch_one(&mut *self.0)
         .await??;
 
-        Ok((token, login))
+        Ok((token, user))
     }
 }