diff --git a/server/migrations/20260920000000_create_recurring_expenses.sql b/server/migrations/20260920000000_create_recurring_expenses.sql new file mode 100644 index 0000000..c192615 --- /dev/null +++ b/server/migrations/20260920000000_create_recurring_expenses.sql @@ -0,0 +1,23 @@ +CREATE TABLE recurring_expenses ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid (), + name TEXT NOT NULL, + amount_cents BIGINT NOT NULL, + starts_at TIMESTAMPTZ NOT NULL, + ends_at TIMESTAMPTZ, + recurrence_every INTEGER NOT NULL CHECK (recurrence_every > 0), + recurrence_unit TEXT NOT NULL CHECK ( + recurrence_unit IN ( + 'day', + 'week', + 'month', + 'year' + ) + ), + weekend_adjustment TEXT CHECK ( + weekend_adjustment IS NULL + OR weekend_adjustment IN ( + 'previous_business_day', + 'next_business_day' + ) + ) +); \ No newline at end of file diff --git a/server/src/database/dtos.rs b/server/src/database/dtos.rs index 37f0806..31ab374 100644 --- a/server/src/database/dtos.rs +++ b/server/src/database/dtos.rs @@ -1 +1,2 @@ +pub mod expense; pub mod transaction; diff --git a/server/src/database/dtos/expense.rs b/server/src/database/dtos/expense.rs new file mode 100644 index 0000000..21958f0 --- /dev/null +++ b/server/src/database/dtos/expense.rs @@ -0,0 +1,14 @@ +use chrono::{DateTime, Utc}; +use uuid::Uuid; + +#[derive(sqlx::FromRow)] +pub struct RecurringExpenseRow { + pub id: Uuid, + pub name: String, + pub amount_cents: i64, + pub starts_at: DateTime, + pub ends_at: Option>, + pub recurrence_every: i32, + pub recurrence_unit: String, + pub weekend_adjustment: Option, +} diff --git a/server/src/error.rs b/server/src/error.rs index b8a5042..8359c00 100644 --- a/server/src/error.rs +++ b/server/src/error.rs @@ -3,9 +3,12 @@ use axum::{ response::{IntoResponse, Response}, }; +use crate::routes::dtos::expense::RecurringExpenseConversionError; + #[derive(Debug)] pub enum AppError { Database(sqlx::Error), + InvalidRecurringExpense(RecurringExpenseConversionError), } impl From for AppError { @@ -14,10 +17,19 @@ impl From for AppError { } } +impl From for AppError { + fn from(error: RecurringExpenseConversionError) -> Self { + Self::InvalidRecurringExpense(error) + } +} + impl IntoResponse for AppError { fn into_response(self) -> Response { match self { Self::Database(error) => tracing::error!(%error, "Database query failed"), + Self::InvalidRecurringExpense(error) => { + tracing::error!(%error, "Invalid recurring expense data") + } } (StatusCode::INTERNAL_SERVER_ERROR, "Internal server error").into_response() diff --git a/server/src/routes.rs b/server/src/routes.rs index ffc7e22..6029256 100644 --- a/server/src/routes.rs +++ b/server/src/routes.rs @@ -1,11 +1,14 @@ pub mod dtos; +mod expenses; mod transactions; pub fn create_router(pool: sqlx::PgPool) -> axum::Router { axum::Router::new() .nest( "/api", - axum::Router::new().nest("/transactions", transactions::create_router()), + axum::Router::new() + .nest("/expenses", expenses::create_router()) + .nest("/transactions", transactions::create_router()), ) .with_state(pool) } diff --git a/server/src/routes/dtos.rs b/server/src/routes/dtos.rs index 37f0806..31ab374 100644 --- a/server/src/routes/dtos.rs +++ b/server/src/routes/dtos.rs @@ -1 +1,2 @@ +pub mod expense; pub mod transaction; diff --git a/server/src/routes/dtos/expense.rs b/server/src/routes/dtos/expense.rs new file mode 100644 index 0000000..7f4a5a8 --- /dev/null +++ b/server/src/routes/dtos/expense.rs @@ -0,0 +1,130 @@ +use chrono::{DateTime, Utc}; +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +use crate::database::dtos::expense::RecurringExpenseRow; + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +#[serde(tag = "type")] +pub enum Expense { + Recurring(RecurringExpense), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct RecurringExpense { + pub id: Uuid, + pub name: String, + pub amount: f64, + pub start: DateTime, + pub end: Option>, + pub recurrence: Recurrence, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Recurrence { + pub every: u32, + pub unit: RecurrenceUnit, + pub weekend_adjustment: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum RecurrenceUnit { + Day, + Week, + Month, + Year, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum WeekendAdjustment { + PreviousBusinessDay, + NextBusinessDay, +} + +#[derive(Debug)] +pub enum RecurringExpenseConversionError { + InvalidRecurrenceEvery(i32), + InvalidRecurrenceUnit(String), + InvalidWeekendAdjustment(String), +} + +impl From for Expense { + fn from(expense: RecurringExpense) -> Self { + Self::Recurring(expense) + } +} + +impl std::fmt::Display for RecurringExpenseConversionError { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::InvalidRecurrenceEvery(value) => { + write!(formatter, "invalid recurrence_every value: {value}") + } + Self::InvalidRecurrenceUnit(value) => { + write!(formatter, "invalid recurrence_unit value: {value}") + } + Self::InvalidWeekendAdjustment(value) => { + write!(formatter, "invalid weekend_adjustment value: {value}") + } + } + } +} + +impl std::error::Error for RecurringExpenseConversionError {} + +impl TryFrom for RecurringExpense { + type Error = RecurringExpenseConversionError; + + fn try_from(row: RecurringExpenseRow) -> Result { + Ok(Self { + id: row.id, + name: row.name, + amount: row.amount_cents as f64 / 100.0, + start: row.starts_at, + end: row.ends_at, + recurrence: Recurrence { + every: row.recurrence_every.try_into().map_err(|_| { + RecurringExpenseConversionError::InvalidRecurrenceEvery(row.recurrence_every) + })?, + unit: RecurrenceUnit::try_from(row.recurrence_unit)?, + weekend_adjustment: match row.weekend_adjustment { + Some(value) => Some(WeekendAdjustment::try_from(value)?), + None => None, + }, + }, + }) + } +} + +impl TryFrom for RecurrenceUnit { + type Error = RecurringExpenseConversionError; + + fn try_from(value: String) -> Result { + match value.as_str() { + "day" => Ok(Self::Day), + "week" => Ok(Self::Week), + "month" => Ok(Self::Month), + "year" => Ok(Self::Year), + _ => Err(RecurringExpenseConversionError::InvalidRecurrenceUnit( + value, + )), + } + } +} + +impl TryFrom for WeekendAdjustment { + type Error = RecurringExpenseConversionError; + + fn try_from(value: String) -> Result { + match value.as_str() { + "previous_business_day" => Ok(Self::PreviousBusinessDay), + "next_business_day" => Ok(Self::NextBusinessDay), + _ => Err(RecurringExpenseConversionError::InvalidWeekendAdjustment( + value, + )), + } + } +} diff --git a/server/src/routes/expenses.rs b/server/src/routes/expenses.rs new file mode 100644 index 0000000..8e6052f --- /dev/null +++ b/server/src/routes/expenses.rs @@ -0,0 +1,41 @@ +use axum::{Json, extract::State}; +use sqlx::PgPool; + +use crate::{ + database::dtos::expense::RecurringExpenseRow, + error::AppError, + routes::dtos::expense::{Expense, RecurringExpense}, +}; + +pub fn create_router() -> axum::Router { + axum::Router::new().route("/", axum::routing::get(get_expenses)) +} + +#[tracing::instrument(skip(pool))] +async fn get_expenses(State(pool): State) -> Result>, AppError> { + let rows = sqlx::query_as::<_, RecurringExpenseRow>( + r#" + SELECT + id, + name, + amount_cents, + starts_at, + ends_at, + recurrence_every, + recurrence_unit, + weekend_adjustment + FROM recurring_expenses + ORDER BY starts_at DESC, id DESC + "#, + ) + .fetch_all(&pool) + .await?; + + let expenses = rows + .into_iter() + .map(RecurringExpense::try_from) + .map(|result| result.map(Expense::from)) + .collect::, _>>()?; + + Ok(Json(expenses)) +}