2 files changed, 36 insertions, 51 deletions

diff --git a/src/message/app.rs b/src/message/app.rs
index cbcbff9..b82fa83 100644
--- a/src/message/app.rs
+++ b/src/message/app.rs
@@ -6,10 +6,11 @@ use super::{Body, History, Id, Message, history, repo::Provider as _};
 use crate::{
     clock::DateTime,
     conversation::{self, repo::Provider as _},
+    db,
     db::NotFound as _,
+    error::failed::{Failed, ResultExt as _},
     event::{Broadcaster, Sequence, repo::Provider as _},
     login::Login,
-    name,
     user::{self, repo::Provider as _},
 };
 
@@ -35,21 +36,29 @@ impl Messages {
         let sender_not_found = || SendError::SenderNotFound(sender.id.clone().into());
         let sender_deleted = || SendError::SenderDeleted(sender.id.clone().into());
 
-        let mut tx = self.db.begin().await?;
+        let mut tx = self.db.begin().await.fail(db::failed::BEGIN)?;
         let conversation = tx
             .conversations()
             .by_id(conversation)
             .await
-            .not_found(conversation_not_found)?;
+            .optional()
+            .fail("Failed to load conversation")?
+            .ok_or_else(conversation_not_found)?;
         let sender = tx
             .users()
             .by_login(sender)
             .await
-            .not_found(sender_not_found)?;
+            .optional()
+            .fail("Failed to load sending user")?
+            .ok_or_else(sender_not_found)?;
 
         // Ordering: don't bother allocating a sequence number before we know the channel might
         // exist.
-        let sent = tx.sequence().next(sent_at).await?;
+        let sent = tx
+            .sequence()
+            .next(sent_at)
+            .await
+            .fail("Failed to find event sequence number")?;
         let conversation = conversation.as_of(sent).ok_or_else(conversation_deleted)?;
         let sender = sender.as_of(sent).ok_or_else(sender_deleted)?;
         let message = History::begin(&conversation, &sender, body, sent);
@@ -58,9 +67,12 @@ impl Messages {
         // the various event-manipulating app methods are consistent, and it's harmless to have an
         // always-satisfied filter.
         let events = message.events().filter(Sequence::start_from(sent));
-        tx.messages().record_events(events.clone()).await?;
+        tx.messages()
+            .record_events(events.clone())
+            .await
+            .fail("Failed to store events")?;
 
-        tx.commit().await?;
+        tx.commit().await.fail(db::failed::COMMIT)?;
 
         self.events.broadcast_from(events);
 
@@ -76,20 +88,29 @@ impl Messages {
         let message_not_found = || DeleteError::MessageNotFound(message.clone());
         let not_sender = || DeleteError::NotSender(deleted_by.id.clone().into());
 
-        let mut tx = self.db.begin().await?;
+        let mut tx = self.db.begin().await.fail(db::failed::BEGIN)?;
 
         let message = tx
             .messages()
             .by_id(message)
             .await
-            .not_found(message_not_found)?;
+            .optional()
+            .fail("Failed to load message")?
+            .ok_or_else(message_not_found)?;
         if message.sender() == &deleted_by.id {
-            let deleted_at = tx.sequence().next(deleted_at).await?;
+            let deleted_at = tx
+                .sequence()
+                .next(deleted_at)
+                .await
+                .fail("Failed to find event sequence number")?;
             let message = message.delete(deleted_at)?;
 
             let events = message.events().filter(Sequence::start_from(deleted_at));
-            tx.messages().record_events(events.clone()).await?;
-            tx.commit().await?;
+            tx.messages()
+                .record_events(events.clone())
+                .await
+                .fail("Failed to store events")?;
+            tx.commit().await.fail(db::failed::COMMIT)?;
 
             self.events.broadcast_from(events);
 
@@ -153,29 +174,7 @@ pub enum SendError {
     #[error("user {0} deleted")]
     SenderDeleted(user::Id),
     #[error(transparent)]
-    Database(#[from] sqlx::Error),
-    #[error(transparent)]
-    Name(#[from] name::Error),
-}
-
-impl From<conversation::repo::LoadError> for SendError {
-    fn from(error: conversation::repo::LoadError) -> Self {
-        use conversation::repo::LoadError;
-        match error {
-            LoadError::Database(error) => error.into(),
-            LoadError::Name(error) => error.into(),
-        }
-    }
-}
-
-impl From<user::repo::LoadError> for SendError {
-    fn from(error: user::repo::LoadError) -> Self {
-        use user::repo::LoadError;
-        match error {
-            LoadError::Database(error) => error.into(),
-            LoadError::Name(error) => error.into(),
-        }
-    }
+    Failed(#[from] Failed),
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -187,19 +186,7 @@ pub enum DeleteError {
     #[error("message {0} deleted")]
     Deleted(Id),
     #[error(transparent)]
-    Database(#[from] sqlx::Error),
-    #[error(transparent)]
-    Name(#[from] name::Error),
-}
-
-impl From<user::repo::LoadError> for DeleteError {
-    fn from(error: user::repo::LoadError) -> Self {
-        use user::repo::LoadError;
-        match error {
-            LoadError::Database(error) => error.into(),
-            LoadError::Name(error) => error.into(),
-        }
-    }
+    Failed(#[from] Failed),
 }
 
 impl From<history::DeleteError> for DeleteError {
diff --git a/src/message/handlers/delete/mod.rs b/src/message/handlers/delete/mod.rs
index c09a752..c680db1 100644
--- a/src/message/handlers/delete/mod.rs
+++ b/src/message/handlers/delete/mod.rs
@@ -53,9 +53,7 @@ impl IntoResponse for Error {
             DeleteError::MessageNotFound(_) | DeleteError::Deleted(_) => {
                 NotFound(error).into_response()
             }
-            DeleteError::Database(_) | DeleteError::Name(_) => {
-                Internal::from(error).into_response()
-            }
+            DeleteError::Failed(_) => Internal::from(error).into_response(),
         }
     }
 }