Merge branch 'main' into wip/mobile

1 files changed, 23 insertions, 32 deletions

diff --git a/src/login/app.rs b/src/login/app.rs
index 2f5896f..f458561 100644
--- a/src/login/app.rs
+++ b/src/login/app.rs
@@ -1,65 +1,56 @@
 use sqlx::sqlite::SqlitePool;
 
-use super::repo::Provider as _;
-
-#[cfg(test)]
-use super::{Login, Password};
-#[cfg(test)]
-use crate::{
-    clock::DateTime,
-    event::{repo::Provider as _, Broadcaster, Event},
-    name::Name,
+use super::{
+    create::{self, Create},
+    Login, Password,
 };
+use crate::{clock::DateTime, event::Broadcaster, name::Name};
 
 pub struct Logins<'a> {
     db: &'a SqlitePool,
-    #[cfg(test)]
     events: &'a Broadcaster,
 }
 
 impl<'a> Logins<'a> {
-    #[cfg(not(test))]
-    pub const fn new(db: &'a SqlitePool) -> Self {
-        Self { db }
-    }
-
-    #[cfg(test)]
     pub const fn new(db: &'a SqlitePool, events: &'a Broadcaster) -> Self {
         Self { db, events }
     }
 
-    #[cfg(test)]
     pub async fn create(
         &self,
         name: &Name,
         password: &Password,
         created_at: &DateTime,
     ) -> Result<Login, CreateError> {
-        let password_hash = password.hash()?;
+        let create = Create::begin(name, password, created_at);
+        let validated = create.validate()?;
 
         let mut tx = self.db.begin().await?;
-        let created = tx.sequence().next(created_at).await?;
-        let login = tx.logins().create(name, &password_hash, &created).await?;
+        let stored = validated.store(&mut tx).await?;
         tx.commit().await?;
 
-        self.events
-            .broadcast(login.events().map(Event::from).collect::<Vec<_>>());
+        let login = stored.publish(self.events);
 
         Ok(login.as_created())
     }
-
-    pub async fn recanonicalize(&self) -> Result<(), sqlx::Error> {
-        let mut tx = self.db.begin().await?;
-        tx.logins().recanonicalize().await?;
-        tx.commit().await?;
-
-        Ok(())
-    }
 }
 
 #[derive(Debug, thiserror::Error)]
-#[error(transparent)]
 pub enum CreateError {
-    Database(#[from] sqlx::Error),
+    #[error("invalid login name: {0}")]
+    InvalidName(Name),
+    #[error(transparent)]
     PasswordHash(#[from] password_hash::Error),
+    #[error(transparent)]
+    Database(#[from] sqlx::Error),
+}
+
+#[cfg(test)]
+impl From<create::Error> for CreateError {
+    fn from(error: create::Error) -> Self {
+        match error {
+            create::Error::InvalidName(name) => Self::InvalidName(name),
+            create::Error::PasswordHash(error) => Self::PasswordHash(error),
+        }
+    }
 }