diff --git a/server/migrations/20260920000000_create_recurring_transactions.sql b/server/migrations/20260920000000_create_recurring_transactions.sql index 533e12a..d687c92 100644 --- a/server/migrations/20260920000000_create_recurring_transactions.sql +++ b/server/migrations/20260920000000_create_recurring_transactions.sql @@ -20,5 +20,9 @@ CREATE TABLE recurring_transactions ( 'previous_business_day', 'next_business_day' ) + ), + CHECK ( + ends_at IS NULL + OR ends_at >= starts_at ) ); \ No newline at end of file diff --git a/server/src/error.rs b/server/src/error.rs index 3fa39c5..b67c369 100644 --- a/server/src/error.rs +++ b/server/src/error.rs @@ -7,6 +7,7 @@ use crate::routes::{ dtos::{ direction::DirectionConversionError, scheduled_transaction::RecurringTransactionConversionError, + transaction::TransactionConversionError, }, validation::scheduled_transaction::ScheduledTransactionValidationError, }; @@ -16,6 +17,7 @@ pub enum AppError { Database(sqlx::Error), Direction(DirectionConversionError), RecurringTransaction(RecurringTransactionConversionError), + Transaction(TransactionConversionError), ScheduledTransactionValidation(ScheduledTransactionValidationError), } @@ -37,6 +39,12 @@ impl From for AppError { } } +impl From for AppError { + fn from(error: TransactionConversionError) -> Self { + Self::Transaction(error) + } +} + impl From for AppError { fn from(error: ScheduledTransactionValidationError) -> Self { Self::ScheduledTransactionValidation(error) @@ -56,6 +64,7 @@ impl IntoResponse for AppError { Self::RecurringTransaction(error) => { tracing::error!(%error, "Invalid recurring transaction data") } + Self::Transaction(error) => tracing::error!(%error, "Invalid transaction data"), } (StatusCode::INTERNAL_SERVER_ERROR, "Internal server error").into_response() diff --git a/server/src/routes/dtos/scheduled_transaction.rs b/server/src/routes/dtos/scheduled_transaction.rs index 57c55ca..2872410 100644 --- a/server/src/routes/dtos/scheduled_transaction.rs +++ b/server/src/routes/dtos/scheduled_transaction.rs @@ -36,7 +36,9 @@ impl TryFrom for RecurringTransaction { id: row.id, data: RecurringTransactionData { name: row.name, - amount: row.amount_cents as f64 / 100.0, + amount_cents: row.amount_cents.try_into().map_err(|_| { + RecurringTransactionConversionError::AmountCents(row.amount_cents) + })?, direction: Direction::try_from(row.direction) .map_err(RecurringTransactionConversionError::Direction)?, start: row.starts_at, @@ -66,7 +68,7 @@ pub enum ScheduledTransactionData { #[derive(Debug, Clone, Serialize, Deserialize)] pub struct RecurringTransactionData { pub name: String, - pub amount: f64, + pub amount_cents: u64, pub direction: Direction, pub start: DateTime, pub end: Option>, @@ -146,6 +148,7 @@ impl TryFrom for WeekendAdjustment { #[derive(Debug)] pub enum RecurringTransactionConversionError { + AmountCents(i64), Direction(DirectionConversionError), RecurrenceEvery(i32), RecurrenceUnit(String), @@ -157,6 +160,9 @@ impl std::error::Error for RecurringTransactionConversionError {} impl std::fmt::Display for RecurringTransactionConversionError { fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { + Self::AmountCents(value) => { + write!(formatter, "invalid amount_cents value: {value}") + } Self::Direction(error) => error.fmt(formatter), Self::RecurrenceEvery(value) => { write!(formatter, "invalid recurrence_every value: {value}") @@ -182,10 +188,10 @@ mod tests { }; use crate::routes::dtos::direction::Direction; - fn transaction(amount: f64) -> RecurringTransactionData { + fn transaction(amount_cents: u64) -> RecurringTransactionData { RecurringTransactionData { name: String::new(), - amount, + amount_cents, direction: Direction::Out, start: Utc.with_ymd_and_hms(2026, 9, 24, 12, 0, 0).unwrap(), end: None, @@ -201,17 +207,17 @@ mod tests { fn keeps_scheduled_transaction_json_flat() { let response = ScheduledTransaction::Recurring(RecurringTransaction { id: Uuid::nil(), - data: transaction(12.34), + data: transaction(1234), }); let response = serde_json::to_value(response).unwrap(); assert_eq!(response["type"], "recurring"); assert_eq!(response["id"], Uuid::nil().to_string()); - assert_eq!(response["amount"], 12.34); + assert_eq!(response["amount_cents"], 1234); assert!(response.get("data").is_none()); let request: ScheduledTransactionData = serde_json::from_value(response).unwrap(); let ScheduledTransactionData::Recurring(data) = request; - assert_eq!(data.amount, 12.34); + assert_eq!(data.amount_cents, 1234); assert_eq!(data.recurrence.every, 2); } } diff --git a/server/src/routes/dtos/transaction.rs b/server/src/routes/dtos/transaction.rs index e753649..c183861 100644 --- a/server/src/routes/dtos/transaction.rs +++ b/server/src/routes/dtos/transaction.rs @@ -9,31 +9,54 @@ use crate::routes::dtos::direction::{Direction, DirectionConversionError}; pub struct TransactionResponse { pub id: Uuid, pub description: String, - pub amount: f64, + pub amount_cents: u64, pub direction: Direction, pub date: DateTime, } impl TryFrom for TransactionResponse { - type Error = DirectionConversionError; + type Error = TransactionConversionError; fn try_from(row: TransactionRow) -> Result { Ok(Self { id: row.id, description: row.description, - amount: row.amount_cents as f64 / 100.0, - direction: Direction::try_from(row.direction)?, + amount_cents: row + .amount_cents + .try_into() + .map_err(|_| TransactionConversionError::AmountCents(row.amount_cents))?, + direction: Direction::try_from(row.direction) + .map_err(TransactionConversionError::Direction)?, date: row.date, }) } } +#[derive(Debug)] +pub enum TransactionConversionError { + AmountCents(i64), + Direction(DirectionConversionError), +} + +impl std::error::Error for TransactionConversionError {} + +impl std::fmt::Display for TransactionConversionError { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::AmountCents(value) => { + write!(formatter, "invalid amount_cents value: {value}") + } + Self::Direction(error) => error.fmt(formatter), + } + } +} + #[cfg(test)] mod tests { use super::*; #[test] - fn converts_cents_to_major_currency_units() { + fn preserves_cents_in_response() { let id = Uuid::new_v4(); let date = Utc::now(); let response = TransactionResponse::try_from(TransactionRow { @@ -48,7 +71,7 @@ mod tests { assert_eq!(response.id, id); assert_eq!(response.description, "Groceries"); - assert_eq!(response.amount, 42.5); + assert_eq!(response.amount_cents, 4250); assert_eq!(response.date, date); } } diff --git a/server/src/routes/validation/scheduled_transaction.rs b/server/src/routes/validation/scheduled_transaction.rs index f67ae3c..7406a58 100644 --- a/server/src/routes/validation/scheduled_transaction.rs +++ b/server/src/routes/validation/scheduled_transaction.rs @@ -31,7 +31,7 @@ impl TryFrom for ValidatedRecurringTransaction { Ok(Self { name: transaction.name, - amount_cents: transaction.amount.try_into()?, + amount_cents: transaction.amount_cents.try_into()?, direction: transaction.direction, starts_at: transaction.start, ends_at: transaction.end, @@ -51,29 +51,13 @@ impl Cents { } } -impl TryFrom for Cents { +impl TryFrom for Cents { type Error = ScheduledTransactionValidationError; - fn try_from(amount: f64) -> Result { - if !amount.is_finite() { - return Err(ScheduledTransactionValidationError::AmountNotFinite); - } - if amount < 0.0 { - return Err(ScheduledTransactionValidationError::AmountNegative); - } - - let amount_cents = amount * 100.0; - if amount_cents >= 9_223_372_036_854_775_808.0 { - return Err(ScheduledTransactionValidationError::AmountOutOfRange); - } - - let rounded_amount_cents = amount_cents.round(); - let rounding_tolerance = f64::EPSILON * amount_cents.abs().max(1.0) * 2.0; - if (amount_cents - rounded_amount_cents).abs() > rounding_tolerance { - return Err(ScheduledTransactionValidationError::AmountHasFractionalCents); - } - - Ok(Self(rounded_amount_cents as i64)) + fn try_from(amount_cents: u64) -> Result { + i64::try_from(amount_cents) + .map(Self) + .map_err(|_| ScheduledTransactionValidationError::AmountOutOfRange) } } @@ -100,9 +84,6 @@ impl TryFrom for PositiveRecurrenceInterval { #[derive(Debug)] pub enum ScheduledTransactionValidationError { - AmountNotFinite, - AmountNegative, - AmountHasFractionalCents, AmountOutOfRange, RecurrenceEvery(u32), EndBeforeStart, @@ -113,11 +94,6 @@ impl std::error::Error for ScheduledTransactionValidationError {} impl std::fmt::Display for ScheduledTransactionValidationError { fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - Self::AmountNotFinite => write!(formatter, "amount must be finite"), - Self::AmountNegative => write!(formatter, "amount must not be negative"), - Self::AmountHasFractionalCents => { - write!(formatter, "amount must have at most two decimal places") - } Self::AmountOutOfRange => write!(formatter, "amount is too large"), Self::RecurrenceEvery(value) => { write!( @@ -146,10 +122,10 @@ mod tests { }, }; - fn transaction(amount: f64) -> RecurringTransactionData { + fn transaction(amount_cents: u64) -> RecurringTransactionData { RecurringTransactionData { name: String::new(), - amount, + amount_cents, direction: Direction::Out, start: Utc.with_ymd_and_hms(2026, 9, 24, 12, 0, 0).unwrap(), end: None, @@ -163,7 +139,7 @@ mod tests { #[test] fn validates_and_preserves_typed_values() { - let transaction = ValidatedRecurringTransaction::try_from(transaction(12.34)).unwrap(); + let transaction = ValidatedRecurringTransaction::try_from(transaction(1234)).unwrap(); assert_eq!(transaction.name, ""); assert_eq!(transaction.amount_cents.get(), 1234); assert!(matches!(transaction.direction, Direction::Out)); @@ -176,29 +152,21 @@ mod tests { } #[test] - fn rejects_invalid_amounts() { - for (amount, expected) in [ - (f64::NAN, "amount must be finite"), - (f64::INFINITY, "amount must be finite"), - (-0.01, "amount must not be negative"), - (1.001, "amount must have at most two decimal places"), - (f64::MAX, "amount is too large"), - ] { - let error = Cents::try_from(amount).unwrap_err(); - assert_eq!(error.to_string(), expected); - } + fn rejects_amounts_that_do_not_fit_in_database() { + let error = Cents::try_from(i64::MAX as u64 + 1).unwrap_err(); + assert_eq!(error.to_string(), "amount is too large"); } #[test] fn validates_date_ordering() { - let mut invalid = transaction(1.0); + let mut invalid = transaction(100); invalid.end = Some(invalid.start - chrono::TimeDelta::seconds(1)); assert!(matches!( ValidatedRecurringTransaction::try_from(invalid), Err(ScheduledTransactionValidationError::EndBeforeStart) )); - let mut valid = transaction(1.0); + let mut valid = transaction(100); valid.end = Some(valid.start); assert!(ValidatedRecurringTransaction::try_from(valid).is_ok()); }