storage: start unifying database errors

crates/storage/src/lib.rs

@@ -29,8 +29,10 @@
 )]
 
 use chrono::{DateTime, Utc};
+use pagination::InvalidPagination;
 use sqlx::migrate::Migrator;
 use thiserror::Error;
+use ulid::Ulid;
 
 #[derive(Debug, Error)]
 #[error("failed to lookup {what}")]
@@ -52,6 +54,12 @@ impl LookupError for GenericLookupError {
     }
 }
 
+impl LookupError for sqlx::Error {
+    fn not_found(&self) -> bool {
+        matches!(self, sqlx::Error::RowNotFound)
+    }
+}
+
 pub trait LookupError {
     fn not_found(&self) -> bool;
 }
@@ -80,6 +88,76 @@ where
     }
 }
 
+/// Generic error when interacting with the database
+#[derive(Debug, Error)]
+#[error(transparent)]
+pub enum DatabaseError {
+    /// An error which came from the database itself
+    Driver(#[from] sqlx::Error),
+
+    /// An error which occured while converting the data from the database
+    Inconsistency(#[from] DatabaseInconsistencyError2),
+
+    /// An error which occured while generating the paginated query
+    Pagination(#[from] InvalidPagination),
+}
+
+#[derive(Debug, Error)]
+pub struct DatabaseInconsistencyError2 {
+    table: &'static str,
+    column: Option<&'static str>,
+    row: Option<Ulid>,
+
+    #[source]
+    source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+}
+
+impl std::fmt::Display for DatabaseInconsistencyError2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Database inconsistency on table {}", self.table)?;
+        if let Some(column) = self.column {
+            write!(f, " column {column}")?;
+        }
+        if let Some(row) = self.row {
+            write!(f, " row {row}")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl DatabaseInconsistencyError2 {
+    #[must_use]
+    pub(crate) const fn on(table: &'static str) -> Self {
+        Self {
+            table,
+            column: None,
+            row: None,
+            source: None,
+        }
+    }
+
+    #[must_use]
+    pub(crate) const fn column(mut self, column: &'static str) -> Self {
+        self.column = Some(column);
+        self
+    }
+
+    #[must_use]
+    pub(crate) const fn row(mut self, row: Ulid) -> Self {
+        self.row = Some(row);
+        self
+    }
+
+    pub(crate) fn source<E: std::error::Error + Send + Sync + 'static>(
+        mut self,
+        source: E,
+    ) -> Self {
+        self.source = Some(Box::new(source));
+        self
+    }
+}
+
 #[derive(Default, Debug, Clone, Copy)]
 pub struct Clock {
     _private: (),

crates/storage/src/pagination.rs

@@ -119,7 +119,7 @@ pub trait QueryBuilderExt {
         after: Option<Ulid>,
         first: Option<usize>,
         last: Option<usize>,
-    ) -> Result<&mut Self, anyhow::Error>;
+    ) -> Result<&mut Self, InvalidPagination>;
 }
 
 impl<'a, DB> QueryBuilderExt for QueryBuilder<'a, DB>
@@ -135,7 +135,7 @@ where
         after: Option<Ulid>,
         first: Option<usize>,
         last: Option<usize>,
-    ) -> Result<&mut Self, anyhow::Error> {
+    ) -> Result<&mut Self, InvalidPagination> {
         generate_pagination(self, id_field, before, after, first, last)?;
         Ok(self)
     }

crates/storage/src/upstream_oauth2/link.rs

@@ -22,7 +22,7 @@ use uuid::Uuid;
 
 use crate::{
     pagination::{process_page, QueryBuilderExt},
-    Clock, GenericLookupError,
+    Clock, DatabaseError, LookupResultExt,
 };
 
 #[derive(sqlx::FromRow)]
@@ -54,7 +54,7 @@ impl From<LinkLookup> for UpstreamOAuthLink {
 pub async fn lookup_link(
     executor: impl PgExecutor<'_>,
     id: Ulid,
-) -> Result<UpstreamOAuthLink, GenericLookupError> {
+) -> Result<Option<UpstreamOAuthLink>, DatabaseError> {
     let res = sqlx::query_as!(
         LinkLookup,
         r#"
@@ -71,9 +71,10 @@ pub async fn lookup_link(
     )
     .fetch_one(executor)
     .await
-    .map_err(GenericLookupError::what("Upstream OAuth 2.0 link"))?;
+    .to_option()?
+    .map(Into::into);
 
-    Ok(res.into())
+    Ok(res)
 }
 
 #[tracing::instrument(
@@ -90,7 +91,7 @@ pub async fn lookup_link_by_subject(
     executor: impl PgExecutor<'_>,
     upstream_oauth_provider: &UpstreamOAuthProvider,
     subject: &str,
-) -> Result<UpstreamOAuthLink, GenericLookupError> {
+) -> Result<Option<UpstreamOAuthLink>, DatabaseError> {
     let res = sqlx::query_as!(
         LinkLookup,
         r#"
@@ -109,9 +110,10 @@ pub async fn lookup_link_by_subject(
     )
     .fetch_one(executor)
     .await
-    .map_err(GenericLookupError::what("Upstream OAuth 2.0 link"))?;
+    .to_option()?
+    .map(Into::into);
 
-    Ok(res.into())
+    Ok(res)
 }
 
 #[tracing::instrument(
@@ -131,7 +133,7 @@ pub async fn add_link(
     clock: &Clock,
     upstream_oauth_provider: &UpstreamOAuthProvider,
     subject: String,
-) -> Result<UpstreamOAuthLink, sqlx::Error> {
+) -> Result<UpstreamOAuthLink, DatabaseError> {
     let created_at = clock.now();
     let id = Ulid::from_datetime_with_source(created_at.into(), &mut rng);
     tracing::Span::current().record("upstream_oauth_link.id", tracing::field::display(id));
@@ -205,7 +207,7 @@ pub async fn get_paginated_user_links(
     after: Option<Ulid>,
     first: Option<usize>,
     last: Option<usize>,
-) -> Result<(bool, bool, Vec<UpstreamOAuthLink>), anyhow::Error> {
+) -> Result<(bool, bool, Vec<UpstreamOAuthLink>), DatabaseError> {
     let mut query = QueryBuilder::new(
         r#"
             SELECT

crates/storage/src/upstream_oauth2/mod.rs

@@ -21,9 +21,7 @@ pub use self::{
         add_link, associate_link_to_user, get_paginated_user_links, lookup_link,
         lookup_link_by_subject,
     },
-    provider::{
-        add_provider, get_paginated_providers, get_providers, lookup_provider, ProviderLookupError,
-    },
+    provider::{add_provider, get_paginated_providers, get_providers, lookup_provider},
     session::{
         add_session, complete_session, consume_session, lookup_session, lookup_session_on_link,
         SessionLookupError,

crates/storage/src/upstream_oauth2/provider.rs

@@ -18,29 +18,15 @@ use mas_iana::{jose::JsonWebSignatureAlg, oauth::OAuthClientAuthenticationMethod
 use oauth2_types::scope::Scope;
 use rand::Rng;
 use sqlx::{PgExecutor, QueryBuilder};
-use thiserror::Error;
 use tracing::{info_span, Instrument};
 use ulid::Ulid;
 use uuid::Uuid;
 
 use crate::{
     pagination::{process_page, QueryBuilderExt},
-    Clock, DatabaseInconsistencyError, LookupError,
+    Clock, DatabaseError, DatabaseInconsistencyError2, LookupResultExt,
 };
 
-#[derive(Debug, Error)]
-#[error("Failed to lookup upstream OAuth 2.0 provider")]
-pub enum ProviderLookupError {
-    Driver(#[from] sqlx::Error),
-    Inconcistency(#[from] DatabaseInconsistencyError),
-}
-
-impl LookupError for ProviderLookupError {
-    fn not_found(&self) -> bool {
-        matches!(self, Self::Driver(sqlx::Error::RowNotFound))
-    }
-}
-
 #[derive(sqlx::FromRow)]
 struct ProviderLookup {
     upstream_oauth_provider_id: Uuid,
@@ -54,22 +40,31 @@ struct ProviderLookup {
 }
 
 impl TryFrom<ProviderLookup> for UpstreamOAuthProvider {
-    type Error = DatabaseInconsistencyError;
+    type Error = DatabaseInconsistencyError2;
     fn try_from(value: ProviderLookup) -> Result<Self, Self::Error> {
         let id = value.upstream_oauth_provider_id.into();
-        let scope = value
-            .scope
-            .parse()
-            .map_err(|_| DatabaseInconsistencyError)?;
-        let token_endpoint_auth_method = value
-            .token_endpoint_auth_method
-            .parse()
-            .map_err(|_| DatabaseInconsistencyError)?;
+        let scope = value.scope.parse().map_err(|e| {
+            DatabaseInconsistencyError2::on("upstream_oauth_providers")
+                .column("scope")
+                .row(id)
+                .source(e)
+        })?;
+        let token_endpoint_auth_method = value.token_endpoint_auth_method.parse().map_err(|e| {
+            DatabaseInconsistencyError2::on("upstream_oauth_providers")
+                .column("token_endpoint_auth_method")
+                .row(id)
+                .source(e)
+        })?;
         let token_endpoint_signing_alg = value
             .token_endpoint_signing_alg
             .map(|x| x.parse())
             .transpose()
-            .map_err(|_| DatabaseInconsistencyError)?;
+            .map_err(|e| {
+                DatabaseInconsistencyError2::on("upstream_oauth_providers")
+                    .column("token_endpoint_signing_alg")
+                    .row(id)
+                    .source(e)
+            })?;
 
         Ok(UpstreamOAuthProvider {
             id,
@@ -92,7 +87,7 @@ impl TryFrom<ProviderLookup> for UpstreamOAuthProvider {
 pub async fn lookup_provider(
     executor: impl PgExecutor<'_>,
     id: Ulid,
-) -> Result<UpstreamOAuthProvider, ProviderLookupError> {
+) -> Result<Option<UpstreamOAuthProvider>, DatabaseError> {
     let res = sqlx::query_as!(
         ProviderLookup,
         r#"
@@ -111,9 +106,15 @@ pub async fn lookup_provider(
         Uuid::from(id),
     )
     .fetch_one(executor)
-    .await?;
+    .await
+    .to_option()?;
 
-    Ok(res.try_into()?)
+    let res = res
+        .map(UpstreamOAuthProvider::try_from)
+        .transpose()
+        .map_err(DatabaseError::from)?;
+
+    Ok(res)
 }
 
 #[tracing::instrument(