1 files changed, 24 insertions, 19 deletions

diff --git a/src/setup/app.rs b/src/setup/app.rs
index 9539406..a0245f7 100644
--- a/src/setup/app.rs
+++ b/src/setup/app.rs
@@ -3,11 +3,13 @@ use sqlx::sqlite::SqlitePool;
 use super::repo::Provider as _;
 use crate::{
     clock::DateTime,
+    db,
+    error::failed::{ErrorExt, Failed, ResultExt as _},
     event::Broadcaster,
     name::Name,
     password::Password,
     token::{Secret, Token, repo::Provider as _},
-    user::create::{self, Create},
+    user::{create, create::Create},
 };
 
 #[derive(Clone)]
@@ -29,18 +31,32 @@ impl Setup {
     ) -> Result<Secret, Error> {
         let create = Create::begin(name, password, created_at);
 
-        let validated = create.validate()?;
+        let validated = create.validate().map_err(|err| match err {
+            create::Error::InvalidName(name) => Error::InvalidName(name),
+            create::Error::Failed(_) => err.fail("Failed to validate new user"),
+        })?;
 
-        let mut tx = self.db.begin().await?;
-        if tx.setup().completed().await? {
+        let mut tx = self.db.begin().await.fail(db::failed::BEGIN)?;
+        if tx
+            .setup()
+            .completed()
+            .await
+            .fail("Failed to check for prior setup completion")?
+        {
             Err(Error::SetupCompleted)
         } else {
-            let stored = validated.store(&mut tx).await?;
+            let stored = validated
+                .store(&mut tx)
+                .await
+                .fail("Failed to create initial user")?;
             let login = stored.login();
 
             let (token, secret) = Token::generate(login, created_at);
-            tx.tokens().create(&token, &secret).await?;
-            tx.commit().await?;
+            tx.tokens()
+                .create(&token, &secret)
+                .await
+                .fail("Failed to create token")?;
+            tx.commit().await.fail(db::failed::COMMIT)?;
 
             stored.publish(&self.events);
 
@@ -64,16 +80,5 @@ pub enum Error {
     #[error("invalid user name: {0}")]
     InvalidName(Name),
     #[error(transparent)]
-    Database(#[from] sqlx::Error),
-    #[error(transparent)]
-    PasswordHash(#[from] password_hash::Error),
-}
-
-impl From<create::Error> for Error {
-    fn from(error: create::Error) -> Self {
-        match error {
-            create::Error::InvalidName(name) => Self::InvalidName(name),
-            create::Error::PasswordHash(error) => Self::PasswordHash(error),
-        }
-    }
+    Failed(#[from] Failed),
 }