From a67c67bbbdd4f35cf53806a770afb35560a4445d Mon Sep 17 00:00:00 2001 From: Rogier Reerink Date: Sun, 27 Sep 2026 21:57:59 +0200 Subject: [PATCH] Communicate known foreign key violations to the user. --- ...20000000_create_recurring_transactions.sql | 4 +- server/src/database.rs | 44 ++++++++++- server/src/error.rs | 45 ++++++++++- server/src/repository.rs | 29 +++++++ server/src/repository/accounts.rs | 64 ++++++++++++++- .../src/repository/recurring_transactions.rs | 77 ++++++++++++++++++- 6 files changed, 248 insertions(+), 15 deletions(-) diff --git a/server/migrations/20260920000000_create_recurring_transactions.sql b/server/migrations/20260920000000_create_recurring_transactions.sql index d1a1db0..a6968f6 100644 --- a/server/migrations/20260920000000_create_recurring_transactions.sql +++ b/server/migrations/20260920000000_create_recurring_transactions.sql @@ -3,8 +3,8 @@ CREATE TABLE recurring_transactions ( name TEXT NOT NULL, amount_cents BIGINT NOT NULL CHECK (amount_cents >= 0), direction TEXT NOT NULL CHECK (direction IN ('in', 'out')), - source_account_id UUID REFERENCES accounts (id), - destination_account_id UUID REFERENCES accounts (id), + source_account_id UUID CONSTRAINT fk_recurring_transactions_source_account REFERENCES accounts (id), + destination_account_id UUID CONSTRAINT fk_recurring_transactions_destination_account REFERENCES accounts (id), starts_at TIMESTAMPTZ NOT NULL, ends_at TIMESTAMPTZ, recurrence_every INTEGER NOT NULL CHECK (recurrence_every > 0), diff --git a/server/src/database.rs b/server/src/database.rs index 0be2fc7..fb01b3d 100644 --- a/server/src/database.rs +++ b/server/src/database.rs @@ -5,8 +5,12 @@ pub mod transactions; #[derive(Debug, thiserror::Error)] pub enum DatabaseError { - #[error("Foreign key violation")] - ForeignKeyViolation, + #[error("Foreign key violation ({constraint}): {source}")] + ForeignKeyViolation { + constraint: Constraint, + #[source] + source: sqlx::Error, + }, #[error("Internal error: {0}")] Internal(#[source] sqlx::Error), @@ -16,9 +20,43 @@ impl From for DatabaseError { fn from(err: sqlx::Error) -> Self { match err { sqlx::Error::Database(db_err) if db_err.code().as_deref() == Some("23503") => { - DatabaseError::ForeignKeyViolation + let constraint = db_err + .constraint() + .map(Constraint::from) + .unwrap_or(Constraint::Unknown(None)); + + DatabaseError::ForeignKeyViolation { + constraint, + source: sqlx::Error::Database(db_err), + } } _ => DatabaseError::Internal(err), } } } + +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +pub enum Constraint { + #[error("Recurring transaction source account constraint violation")] + RecurringTransactionSourceAccount, + + #[error("Recurring transaction destination account constraint violation")] + RecurringTransactionDestinationAccount, + + #[error("Unknown constraint violation: {0:?}")] + Unknown(Option), +} + +impl From<&str> for Constraint { + fn from(constraint: &str) -> Self { + match constraint { + "fk_recurring_transactions_source_account" => { + Constraint::RecurringTransactionSourceAccount + } + "fk_recurring_transactions_destination_account" => { + Constraint::RecurringTransactionDestinationAccount + } + _ => Constraint::Unknown(Some(constraint.to_string())), + } + } +} diff --git a/server/src/error.rs b/server/src/error.rs index fa3b76b..a9cf08d 100644 --- a/server/src/error.rs +++ b/server/src/error.rs @@ -3,7 +3,10 @@ use axum::{ response::{IntoResponse, Response}, }; -use crate::{database::DatabaseError, domain::DomainError, repository::RepositoryError}; +use crate::{ + domain::DomainError, + repository::{ReferenceRelation, ReferenceViolationKind, RepositoryError}, +}; #[derive(Debug, thiserror::Error)] pub enum AppError { @@ -32,15 +35,49 @@ impl IntoResponse for AppError { Self::Domain(error) => { return error_response(StatusCode::UNPROCESSABLE_ENTITY, error.to_string()); } - Self::Repository(RepositoryError::Database(DatabaseError::ForeignKeyViolation)) => { - return error_response(StatusCode::UNPROCESSABLE_ENTITY, "Reference violation"); - } Self::Repository(RepositoryError::Database(error)) => { tracing::error!(%error, "Database query failed"); } Self::Repository(RepositoryError::Decode(error)) => { tracing::error!(%error, "Invalid stored data"); } + Self::Repository(RepositoryError::ReferenceViolation { + relation: ReferenceRelation::SourceAccount, + kind: ReferenceViolationKind::Missing, + .. + }) => { + return error_response( + StatusCode::UNPROCESSABLE_ENTITY, + "Source account cannot be found", + ); + } + Self::Repository(RepositoryError::ReferenceViolation { + relation: ReferenceRelation::DestinationAccount, + kind: ReferenceViolationKind::Missing, + .. + }) => { + return error_response( + StatusCode::UNPROCESSABLE_ENTITY, + "Destination account cannot be found", + ); + } + Self::Repository(RepositoryError::ReferenceViolation { + relation: ReferenceRelation::RecurringTransaction, + kind: ReferenceViolationKind::StillReferenced, + .. + }) => { + return error_response( + StatusCode::CONFLICT, + "Still referenced by one or more recurring transactions", + ); + } + Self::Repository(RepositoryError::ReferenceViolation { + relation, + kind, + source, + }) => { + tracing::error!(%relation, %kind, error = ?source, "Unhandled reference violation"); + } Self::Repository(RepositoryError::QueryConversion(error)) => { return error_response(StatusCode::BAD_REQUEST, error.to_string()); } diff --git a/server/src/repository.rs b/server/src/repository.rs index 91c8a49..48c0ce8 100644 --- a/server/src/repository.rs +++ b/server/src/repository.rs @@ -17,6 +17,14 @@ pub enum RepositoryError { #[error(transparent)] Decode(#[from] DecodeError), + #[error("reference violation ({kind}: {relation})")] + ReferenceViolation { + relation: ReferenceRelation, + kind: ReferenceViolationKind, + #[source] + source: DatabaseError, + }, + #[error(transparent)] QueryConversion(#[from] QueryConversionError), } @@ -45,6 +53,27 @@ pub enum DecodeError { WeekendAdjustment(String), } +#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)] +pub enum ReferenceRelation { + #[error("source account")] + SourceAccount, + + #[error("destination account")] + DestinationAccount, + + #[error("recurring transaction")] + RecurringTransaction, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)] +pub enum ReferenceViolationKind { + #[error("missing")] + Missing, + + #[error("still referenced")] + StillReferenced, +} + #[derive(Debug, thiserror::Error)] pub enum QueryConversionError { #[error("Failed to convert limit: {0}")] diff --git a/server/src/repository/accounts.rs b/server/src/repository/accounts.rs index 265b910..e8a9b90 100644 --- a/server/src/repository/accounts.rs +++ b/server/src/repository/accounts.rs @@ -3,11 +3,11 @@ use std::collections::HashMap; use uuid::Uuid; use super::{ - DecodeError, QueryConversionError, RepositoryError, + DecodeError, QueryConversionError, ReferenceRelation, ReferenceViolationKind, RepositoryError, dtos::{Delete, Upsert}, }; use crate::{ - database::{accounts as db, dtos::AccountRow}, + database::{Constraint, DatabaseError, accounts as db, dtos::AccountRow}, domain::Account, }; @@ -109,7 +109,32 @@ pub async fn delete<'e, E>(executor: E, id: Uuid) -> Result, { - Ok(db::delete_by_id(executor, id).await?.into()) + let deleted = db::delete_by_id(executor, id) + .await + .map_err(classify_delete_error)?; + + Ok(deleted.into()) +} + +fn classify_delete_error(error: DatabaseError) -> RepositoryError { + let is_recurring_transaction_reference = matches!( + &error, + DatabaseError::ForeignKeyViolation { + constraint: Constraint::RecurringTransactionSourceAccount + | Constraint::RecurringTransactionDestinationAccount, + .. + } + ); + + if is_recurring_transaction_reference { + RepositoryError::ReferenceViolation { + relation: ReferenceRelation::RecurringTransaction, + kind: ReferenceViolationKind::StillReferenced, + source: error, + } + } else { + RepositoryError::Database(error) + } } fn decode(row: AccountRow) -> Result { @@ -132,6 +157,39 @@ mod tests { use super::*; + fn foreign_key_violation(constraint: Constraint) -> DatabaseError { + DatabaseError::ForeignKeyViolation { + constraint, + source: sqlx::Error::Protocol("test database cause".to_owned()), + } + } + + #[test] + fn classifies_account_delete_foreign_key_constraint() { + let error = classify_delete_error(foreign_key_violation( + Constraint::RecurringTransactionSourceAccount, + )); + assert!(matches!( + &error, + RepositoryError::ReferenceViolation { + relation: ReferenceRelation::RecurringTransaction, + kind: ReferenceViolationKind::StillReferenced, + .. + } + )); + + let database_error = std::error::Error::source(&error).unwrap(); + let sqlx_error = std::error::Error::source(database_error).unwrap(); + assert!(sqlx_error.to_string().contains("test database cause")); + } + + #[test] + fn keeps_unknown_account_delete_foreign_keys_generic() { + let error = classify_delete_error(foreign_key_violation(Constraint::Unknown(None))); + + assert!(matches!(error, RepositoryError::Database(_))); + } + fn row() -> AccountRow { AccountRow { id: Uuid::new_v4(), diff --git a/server/src/repository/recurring_transactions.rs b/server/src/repository/recurring_transactions.rs index 8e7e626..426f3b2 100644 --- a/server/src/repository/recurring_transactions.rs +++ b/server/src/repository/recurring_transactions.rs @@ -1,7 +1,7 @@ use uuid::Uuid; use super::{ - DecodeError, QueryConversionError, RepositoryError, + DecodeError, QueryConversionError, ReferenceRelation, ReferenceViolationKind, RepositoryError, dtos::{Delete, Upsert}, encoding::{ decode_direction, decode_recurrence_unit, decode_weekend_adjustment, encode_direction, @@ -9,7 +9,9 @@ use super::{ }, }; use crate::{ - database::{dtos::RecurringTransactionRow, recurring_transactions as db}, + database::{ + Constraint, DatabaseError, dtos::RecurringTransactionRow, recurring_transactions as db, + }, domain::{Cents, Recurrence, RecurrenceInterval, RecurringTransaction, Schedule}, }; @@ -81,12 +83,36 @@ where E: sqlx::Executor<'e, Database = sqlx::Postgres>, { let transaction = db::upsert(executor, encode(transaction)) - .await? + .await + .map_err(classify_upsert_error)? .try_map(decode)?; Ok(transaction.into()) } +fn classify_upsert_error(error: DatabaseError) -> RepositoryError { + let relation = match &error { + DatabaseError::ForeignKeyViolation { + constraint: Constraint::RecurringTransactionSourceAccount, + .. + } => Some(ReferenceRelation::SourceAccount), + DatabaseError::ForeignKeyViolation { + constraint: Constraint::RecurringTransactionDestinationAccount, + .. + } => Some(ReferenceRelation::DestinationAccount), + _ => None, + }; + + match relation { + Some(relation) => RepositoryError::ReferenceViolation { + relation, + kind: ReferenceViolationKind::Missing, + source: error, + }, + None => RepositoryError::Database(error), + } +} + pub async fn delete<'e, E>(executor: E, id: Uuid) -> Result where E: sqlx::Executor<'e, Database = sqlx::Postgres>, @@ -144,6 +170,51 @@ mod tests { use super::*; use crate::domain::{Direction, RecurrenceUnit, ScheduleError, WeekendAdjustment}; + fn foreign_key_violation(constraint: Constraint) -> DatabaseError { + DatabaseError::ForeignKeyViolation { + constraint, + source: sqlx::Error::Protocol("test database cause".to_owned()), + } + } + + #[test] + fn classifies_upsert_foreign_key_constraints() { + let source = classify_upsert_error(foreign_key_violation( + Constraint::RecurringTransactionSourceAccount, + )); + assert!(matches!( + &source, + RepositoryError::ReferenceViolation { + relation: ReferenceRelation::SourceAccount, + kind: ReferenceViolationKind::Missing, + .. + } + )); + + let database_error = std::error::Error::source(&source).unwrap(); + let sqlx_error = std::error::Error::source(database_error).unwrap(); + assert!(sqlx_error.to_string().contains("test database cause")); + + let destination = classify_upsert_error(foreign_key_violation( + Constraint::RecurringTransactionDestinationAccount, + )); + assert!(matches!( + &destination, + RepositoryError::ReferenceViolation { + relation: ReferenceRelation::DestinationAccount, + kind: ReferenceViolationKind::Missing, + .. + } + )); + } + + #[test] + fn keeps_unknown_upsert_foreign_keys_generic() { + let error = classify_upsert_error(foreign_key_violation(Constraint::Unknown(None))); + + assert!(matches!(error, RepositoryError::Database(_))); + } + fn row() -> RecurringTransactionRow { RecurringTransactionRow { id: Uuid::new_v4(),