1 files changed, 43 insertions, 26 deletions
diff --git a/src/token/repo/auth.rs b/src/token/repo/auth.rs
index 9aee81f..bdc4c33 100644
--- a/src/token/repo/auth.rs
+++ b/src/token/repo/auth.rs
@@ -2,8 +2,10 @@ use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 
 use crate::{
     clock::DateTime,
+    db::NotFound,
     event::{Instant, Sequence},
     login::{self, password::StoredHash, History, Login},
+    name::{self, Name},
 };
 
 pub trait Provider {
@@ -19,38 +21,53 @@ impl<'c> Provider for Transaction<'c, Sqlite> {
 pub struct Auth<'t>(&'t mut SqliteConnection);
 
 impl<'t> Auth<'t> {
-    pub async fn for_name(&mut self, name: &str) -> Result<(History, StoredHash), sqlx::Error> {
-        let found = sqlx::query!(
+    pub async fn for_name(&mut self, name: &Name) -> Result<(History, StoredHash), LoadError> {
+        let name = name.canonical();
+        let row = sqlx::query!(
             r#"
-				select
-					id as "id: login::Id",
-					name,
-					password_hash as "password_hash: StoredHash",
+                select
+                    id as "id: login::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
-				where name = $1
-			"#,
+                    created_at as "created_at: DateTime",
+                    password_hash as "password_hash: StoredHash"
+                from login
+                where canonical_name = $1
+            "#,
             name,
         )
-        .map(|row| {
-            (
-                History {
-                    login: Login {
-                        id: row.id,
-                        name: row.name,
-                    },
-                    created: Instant {
-                        at: row.created_at,
-                        sequence: row.created_sequence,
-                    },
-                },
-                row.password_hash,
-            )
-        })
         .fetch_one(&mut *self.0)
         .await?;
 
-        Ok(found)
+        let login = History {
+            login: Login {
+                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))
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub enum LoadError {
+    Database(#[from] sqlx::Error),
+    Name(#[from] name::Error),
+}
+
+impl<T> NotFound for Result<T, LoadError> {
+    type Ok = T;
+    type Error = LoadError;
+
+    fn optional(self) -> Result<Option<T>, LoadError> {
+        match self {
+            Ok(value) => Ok(Some(value)),
+            Err(LoadError::Database(sqlx::Error::RowNotFound)) => Ok(None),
+            Err(other) => Err(other),
+        }
     }
 }