1 files changed, 88 insertions, 52 deletions

diff --git a/src/login/repo.rs b/src/login/repo.rs
index 6d6510c..611edd6 100644
--- a/src/login/repo.rs
+++ b/src/login/repo.rs
@@ -1,9 +1,11 @@
+use futures::stream::{StreamExt as _, TryStreamExt as _};
 use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 
 use crate::{
     clock::DateTime,
     event::{Instant, ResumePoint, Sequence},
     login::{password::StoredHash, History, Id, Login},
+    name::{self, Name},
 };
 
 pub trait Provider {
@@ -21,80 +23,80 @@ pub struct Logins<'t>(&'t mut SqliteConnection);
 impl<'c> Logins<'c> {
     pub async fn create(
         &mut self,
-        name: &str,
+        name: &Name,
         password_hash: &StoredHash,
         created: &Instant,
     ) -> Result<History, sqlx::Error> {
         let id = Id::generate();
+        let display_name = name.display();
+        let canonical_name = name.canonical();
 
-        let login = sqlx::query!(
+        sqlx::query!(
             r#"
                 insert
-                into login (id, name, password_hash, created_sequence, created_at)
-                values ($1, $2, $3, $4, $5)
-                returning
-                    id as "id: Id",
-                    name,
-                    created_sequence as "created_sequence: Sequence",
-                    created_at as "created_at: DateTime"
+                into login (id, display_name, canonical_name, password_hash, created_sequence, created_at)
+                values ($1, $2, $3, $4, $5, $6)
             "#,
             id,
-            name,
+            display_name,
+            canonical_name,
             password_hash,
             created.sequence,
             created.at,
         )
-        .map(|row| History {
+        .execute(&mut *self.0)
+        .await?;
+
+        let login = History {
+            created: *created,
             login: Login {
-                id: row.id,
-                name: row.name,
-            },
-            created: Instant {
-                at: row.created_at,
-                sequence: row.created_sequence,
+                id,
+                name: name.clone(),
             },
-        })
-        .fetch_one(&mut *self.0)
-        .await?;
+        };
 
         Ok(login)
     }
 
-    pub async fn all(&mut self, resume_at: ResumePoint) -> Result<Vec<History>, sqlx::Error> {
-        let channels = sqlx::query!(
+    pub async fn all(&mut self, resume_at: ResumePoint) -> Result<Vec<History>, LoadError> {
+        let logins = sqlx::query!(
             r#"
                 select
                     id as "id: Id",
-                    name,
+                    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 coalesce(created_sequence <= $1, true)
-                    order by created_sequence
+                    order by canonical_name
             "#,
             resume_at,
         )
-        .map(|row| History {
-            login: Login {
-                id: row.id,
-                name: row.name,
-            },
-            created: Instant {
-                at: row.created_at,
-                sequence: row.created_sequence,
-            },
+        .map(|row| {
+            Ok::<_, LoadError>(History {
+                login: Login {
+                    id: row.id,
+                    name: Name::new(row.display_name, row.canonical_name)?,
+                },
+                created: Instant::new(row.created_at, row.created_sequence),
+            })
         })
-        .fetch_all(&mut *self.0)
+        .fetch(&mut *self.0)
+        .map(|res| res?)
+        .try_collect()
         .await?;
 
-        Ok(channels)
+        Ok(logins)
     }
-    pub async fn replay(&mut self, resume_at: ResumePoint) -> Result<Vec<History>, sqlx::Error> {
-        let messages = sqlx::query!(
+
+    pub async fn replay(&mut self, resume_at: ResumePoint) -> Result<Vec<History>, LoadError> {
+        let logins = sqlx::query!(
             r#"
                 select
                     id as "id: Id",
-                    name,
+                    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
@@ -102,25 +104,59 @@ impl<'c> Logins<'c> {
             "#,
             resume_at,
         )
-        .map(|row| History {
-            login: Login {
-                id: row.id,
-                name: row.name,
-            },
-            created: Instant {
-                at: row.created_at,
-                sequence: row.created_sequence,
-            },
+        .map(|row| {
+            Ok::<_, name::Error>(History {
+                login: Login {
+                    id: row.id,
+                    name: Name::new(row.display_name, row.canonical_name)?,
+                },
+                created: Instant::new(row.created_at, row.created_sequence),
+            })
         })
+        .fetch(&mut *self.0)
+        .map(|res| Ok::<_, LoadError>(res??))
+        .try_collect()
+        .await?;
+
+        Ok(logins)
+    }
+
+    pub async fn recanonicalize(&mut self) -> Result<(), sqlx::Error> {
+        let logins = sqlx::query!(
+            r#"
+                select
+                    id as "id: Id",
+                    display_name as "display_name: String"
+                from login
+            "#,
+        )
         .fetch_all(&mut *self.0)
         .await?;
 
-        Ok(messages)
+        for login in logins {
+            let name = Name::from(login.display_name);
+            let canonical_name = name.canonical();
+
+            sqlx::query!(
+                r#"
+                    update login
+                    set canonical_name = $1
+                    where id = $2
+                "#,
+                canonical_name,
+                login.id,
+            )
+            .execute(&mut *self.0)
+            .await?;
+        }
+
+        Ok(())
     }
 }
 
-impl<'t> From<&'t mut SqliteConnection> for Logins<'t> {
-    fn from(tx: &'t mut SqliteConnection) -> Self {
-        Self(tx)
-    }
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub enum LoadError {
+    Database(#[from] sqlx::Error),
+    Name(#[from] name::Error),
 }