Expose sqlx errors directly in repo interfaces.

BoxedError conceals the exact nature of the error, which in turn prevents me from using sqlx::Error::RowNotFound to signal absences.

4 files changed, 13 insertions, 16 deletions

diff --git a/src/channel/repo/channels.rs b/src/channel/repo/channels.rs
index fc52aa3..ab7489c 100644
--- a/src/channel/repo/channels.rs
+++ b/src/channel/repo/channels.rs
@@ -2,7 +2,6 @@ use std::fmt;
 
 use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 
-use crate::error::BoxedError;
 use crate::id::Id as BaseId;
 
 pub trait Provider {
@@ -25,7 +24,7 @@ pub struct Channel {
 
 impl<'c> Channels<'c> {
     /// Create a new channel.
-    pub async fn create(&mut self, name: &str) -> Result<Id, BoxedError> {
+    pub async fn create(&mut self, name: &str) -> Result<Id, sqlx::Error> {
         let id = Id::generate();
 
         let channel = sqlx::query_scalar!(
@@ -44,7 +43,7 @@ impl<'c> Channels<'c> {
         Ok(channel)
     }
 
-    pub async fn by_id(&mut self, channel: Id) -> Result<Channel, BoxedError> {
+    pub async fn by_id(&mut self, channel: Id) -> Result<Channel, sqlx::Error> {
         let channel = sqlx::query_as!(
             Channel,
             r#"
@@ -60,7 +59,7 @@ impl<'c> Channels<'c> {
         Ok(channel)
     }
 
-    pub async fn all(&mut self) -> Result<Vec<Channel>, BoxedError> {
+    pub async fn all(&mut self) -> Result<Vec<Channel>, sqlx::Error> {
         let channels = sqlx::query_as!(
             Channel,
             r#"
diff --git a/src/channel/repo/messages.rs b/src/channel/repo/messages.rs
index 2c89724..a30e6da 100644
--- a/src/channel/repo/messages.rs
+++ b/src/channel/repo/messages.rs
@@ -5,7 +5,6 @@ use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 use super::channels::Id as ChannelId;
 use crate::{
     clock::DateTime,
-    error::BoxedError,
     id::Id as BaseId,
     login::repo::logins::{Id as LoginId, Login, Logins},
 };
@@ -37,7 +36,7 @@ impl<'c> Messages<'c> {
         channel: &ChannelId,
         body: &str,
         sent_at: &DateTime,
-    ) -> Result<BroadcastMessage, BoxedError> {
+    ) -> Result<BroadcastMessage, sqlx::Error> {
         let id = Id::generate();
 
         let sender = Logins::from(&mut *self.0).by_id(sender).await?;
@@ -78,7 +77,7 @@ impl<'c> Messages<'c> {
         &mut self,
         channel: &ChannelId,
         resume_at: Option<&DateTime>,
-    ) -> Result<Vec<BroadcastMessage>, BoxedError> {
+    ) -> Result<Vec<BroadcastMessage>, sqlx::Error> {
         let messages = sqlx::query!(
             r#"
                 select
diff --git a/src/login/repo/logins.rs b/src/login/repo/logins.rs
index b0c8ce4..11ae50f 100644
--- a/src/login/repo/logins.rs
+++ b/src/login/repo/logins.rs
@@ -1,6 +1,5 @@
 use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 
-use crate::error::BoxedError;
 use crate::id::Id as BaseId;
 use crate::login::app::StoredHash;
 
@@ -32,7 +31,7 @@ impl<'c> Logins<'c> {
         &mut self,
         name: &str,
         password_hash: &StoredHash,
-    ) -> Result<Login, BoxedError> {
+    ) -> Result<Login, sqlx::Error> {
         let id = Id::generate();
 
         let login = sqlx::query_as!(
@@ -55,7 +54,7 @@ impl<'c> Logins<'c> {
         Ok(login)
     }
 
-    pub async fn by_id(&mut self, id: &Id) -> Result<Login, BoxedError> {
+    pub async fn by_id(&mut self, id: &Id) -> Result<Login, sqlx::Error> {
         let login = sqlx::query_as!(
             Login,
             r#"
@@ -79,7 +78,7 @@ impl<'c> Logins<'c> {
     pub async fn for_login(
         &mut self,
         name: &str,
-    ) -> Result<Option<(Login, StoredHash)>, BoxedError> {
+    ) -> Result<Option<(Login, StoredHash)>, sqlx::Error> {
         let found = sqlx::query!(
             r#"
                 select
diff --git a/src/login/repo/tokens.rs b/src/login/repo/tokens.rs
index 2e46186..4d381ef 100644
--- a/src/login/repo/tokens.rs
+++ b/src/login/repo/tokens.rs
@@ -3,7 +3,7 @@ use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 use uuid::Uuid;
 
 use super::logins::{Id as LoginId, Login};
-use crate::{clock::DateTime, error::BoxedError};
+use crate::clock::DateTime;
 
 pub trait Provider {
     fn tokens(&mut self) -> Tokens;
@@ -24,7 +24,7 @@ impl<'c> Tokens<'c> {
         &mut self,
         login: &LoginId,
         issued_at: DateTime,
-    ) -> Result<String, BoxedError> {
+    ) -> Result<String, sqlx::Error> {
         let secret = Uuid::new_v4().to_string();
 
         let secret = sqlx::query_scalar!(
@@ -46,7 +46,7 @@ impl<'c> Tokens<'c> {
 
     /// Revoke a token by its secret. If there is no such token with that
     /// secret, this will succeed by doing nothing.
-    pub async fn revoke(&mut self, secret: &str) -> Result<(), BoxedError> {
+    pub async fn revoke(&mut self, secret: &str) -> Result<(), sqlx::Error> {
         sqlx::query!(
             r#"
                 delete
@@ -64,7 +64,7 @@ impl<'c> Tokens<'c> {
     /// Expire and delete all tokens that haven't been used within the expiry
     /// interval (right now, 7 days) prior to `expire_at`. Tokens that are in
     /// use within that period will be retained.
-    pub async fn expire(&mut self, expire_at: DateTime) -> Result<(), BoxedError> {
+    pub async fn expire(&mut self, expire_at: DateTime) -> Result<(), sqlx::Error> {
         // Somewhat arbitrarily, expire after 7 days.
         let expired_issue_at = expire_at - TimeDelta::days(7);
         sqlx::query!(
@@ -88,7 +88,7 @@ impl<'c> Tokens<'c> {
         &mut self,
         secret: &str,
         used_at: DateTime,
-    ) -> Result<Option<Login>, BoxedError> {
+    ) -> Result<Option<Login>, sqlx::Error> {
         // I would use `update … returning` to do this in one query, but
         // sqlite3, as of this writing, does not allow an update's `returning`
         // clause to reference columns from tables joined into the update. Two