diff --git a/server/.sqlx/query-ab6330c86c647fc7b8085152087066269b95eab3d60ad9d97219e93686a85a55.json b/server/.sqlx/query-ab6330c86c647fc7b8085152087066269b95eab3d60ad9d97219e93686a85a55.json new file mode 100644 index 0000000..9292e86 --- /dev/null +++ b/server/.sqlx/query-ab6330c86c647fc7b8085152087066269b95eab3d60ad9d97219e93686a85a55.json @@ -0,0 +1,35 @@ +{ + "db_name": "PostgreSQL", + "query": "\n\t\tINSERT INTO accounts (id, name)\n\t\tVALUES ($1, $2)\n\t\tON CONFLICT (id) DO UPDATE SET\n\t\t\tname = EXCLUDED.name\n\t\tRETURNING WITH (OLD AS old_row, NEW AS new_row)\n\t\t\told_row.id AS \"old_id?\",\n\t\t\tnew_row.id AS \"id!\",\n\t\t\tnew_row.name AS \"name!\"\n\t\t", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "old_id?", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "id!", + "type_info": "Uuid" + }, + { + "ordinal": 2, + "name": "name!", + "type_info": "Text" + } + ], + "parameters": { + "Left": [ + "Uuid", + "Text" + ] + }, + "nullable": [ + false, + false, + false + ] + }, + "hash": "ab6330c86c647fc7b8085152087066269b95eab3d60ad9d97219e93686a85a55" +} diff --git a/server/.sqlx/query-b755bf49d60419830ddaf5855268dd31e1f82bef6b4fd0046a4c5cbffb3e877a.json b/server/.sqlx/query-b755bf49d60419830ddaf5855268dd31e1f82bef6b4fd0046a4c5cbffb3e877a.json new file mode 100644 index 0000000..d38284e --- /dev/null +++ b/server/.sqlx/query-b755bf49d60419830ddaf5855268dd31e1f82bef6b4fd0046a4c5cbffb3e877a.json @@ -0,0 +1,22 @@ +{ + "db_name": "PostgreSQL", + "query": "DELETE FROM accounts WHERE id = $1 RETURNING id", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false + ] + }, + "hash": "b755bf49d60419830ddaf5855268dd31e1f82bef6b4fd0046a4c5cbffb3e877a" +} diff --git a/server/.sqlx/query-b7bfaaed62475d82b8d551e1c9223ae42f06e1534d9587b876dbc494c9eeaebc.json b/server/.sqlx/query-b7bfaaed62475d82b8d551e1c9223ae42f06e1534d9587b876dbc494c9eeaebc.json new file mode 100644 index 0000000..1339fdc --- /dev/null +++ b/server/.sqlx/query-b7bfaaed62475d82b8d551e1c9223ae42f06e1534d9587b876dbc494c9eeaebc.json @@ -0,0 +1,29 @@ +{ + "db_name": "PostgreSQL", + "query": "\n\t\tSELECT id, name\n\t\tFROM accounts\n\t\tORDER BY name DESC, id DESC\n\t\tLIMIT $1\n\t\tOFFSET $2\n\t\t", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "name", + "type_info": "Text" + } + ], + "parameters": { + "Left": [ + "Int8", + "Int8" + ] + }, + "nullable": [ + false, + false + ] + }, + "hash": "b7bfaaed62475d82b8d551e1c9223ae42f06e1534d9587b876dbc494c9eeaebc" +} diff --git a/server/.sqlx/query-f671ec25a4bc22127ea7d3a63be134719dc4aa4eb4c96d7c4d64388cfb658fa8.json b/server/.sqlx/query-f671ec25a4bc22127ea7d3a63be134719dc4aa4eb4c96d7c4d64388cfb658fa8.json new file mode 100644 index 0000000..44a8fdb --- /dev/null +++ b/server/.sqlx/query-f671ec25a4bc22127ea7d3a63be134719dc4aa4eb4c96d7c4d64388cfb658fa8.json @@ -0,0 +1,28 @@ +{ + "db_name": "PostgreSQL", + "query": "\n\t\tSELECT id, name\n\t\tFROM accounts\n\t\tWHERE id = $1\n\t\t", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "name", + "type_info": "Text" + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false, + false + ] + }, + "hash": "f671ec25a4bc22127ea7d3a63be134719dc4aa4eb4c96d7c4d64388cfb658fa8" +} diff --git a/server/migrations/20260927000000_create_accounts.sql b/server/migrations/20260927000000_create_accounts.sql new file mode 100644 index 0000000..5b3b7ff --- /dev/null +++ b/server/migrations/20260927000000_create_accounts.sql @@ -0,0 +1,4 @@ +CREATE TABLE accounts ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid (), + name TEXT NOT NULL +); \ No newline at end of file diff --git a/server/migrations/20260921000000_seed_demo_data.sql b/server/migrations/20260928000000_seed_demo_data.sql similarity index 83% rename from server/migrations/20260921000000_seed_demo_data.sql rename to server/migrations/20260928000000_seed_demo_data.sql index af8ebfb..bd4fdeb 100644 --- a/server/migrations/20260921000000_seed_demo_data.sql +++ b/server/migrations/20260928000000_seed_demo_data.sql @@ -54,4 +54,15 @@ VALUES ( 1, 'month', 'previous_business_day' + ); + +INSERT INTO + accounts (id, name) +VALUES ( + '00000000-0000-0000-0000-000000000001', + 'Checking Account' + ), + ( + '00000000-0000-0000-0000-000000000002', + 'Savings Account' ); \ No newline at end of file diff --git a/server/src/database.rs b/server/src/database.rs index c239825..1d56ad7 100644 --- a/server/src/database.rs +++ b/server/src/database.rs @@ -1,3 +1,4 @@ +pub mod accounts; pub mod dtos; pub mod recurring_transactions; pub mod transactions; diff --git a/server/src/database/accounts.rs b/server/src/database/accounts.rs new file mode 100644 index 0000000..70a6e05 --- /dev/null +++ b/server/src/database/accounts.rs @@ -0,0 +1,96 @@ +use uuid::Uuid; + +use super::dtos::{AccountRow, Delete, Upsert}; + +pub struct Query { + pub limit: Option, + pub offset: Option, +} + +pub async fn query<'e, E>(executor: E, query: Query) -> Result, sqlx::Error> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_as!( + AccountRow, + r#" + SELECT id, name + FROM accounts + ORDER BY name DESC, id DESC + LIMIT $1 + OFFSET $2 + "#, + query.limit, + query.offset, + ) + .fetch_all(executor) + .await +} + +pub async fn get_by_id<'e, E>(executor: E, id: Uuid) -> Result, sqlx::Error> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_as!( + AccountRow, + r#" + SELECT id, name + FROM accounts + WHERE id = $1 + "#, + id, + ) + .fetch_optional(executor) + .await +} + +pub async fn upsert<'e, E>( + executor: E, + account: AccountRow, +) -> Result, sqlx::Error> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let row = sqlx::query!( + r#" + INSERT INTO accounts (id, name) + VALUES ($1, $2) + ON CONFLICT (id) DO UPDATE SET + name = EXCLUDED.name + RETURNING WITH (OLD AS old_row, NEW AS new_row) + old_row.id AS "old_id?", + new_row.id AS "id!", + new_row.name AS "name!" + "#, + account.id, + account.name, + ) + .fetch_one(executor) + .await?; + + let account = AccountRow { + id: row.id, + name: row.name, + }; + + if row.old_id.is_some() { + Ok(Upsert::Updated(account)) + } else { + Ok(Upsert::Created(account)) + } +} + +pub async fn delete_by_id<'e, E>(executor: E, id: Uuid) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let deleted = sqlx::query!("DELETE FROM accounts WHERE id = $1 RETURNING id", id) + .fetch_optional(executor) + .await?; + + Ok(if deleted.is_some() { + Delete::Deleted + } else { + Delete::NotFound + }) +} diff --git a/server/src/database/dtos.rs b/server/src/database/dtos.rs index a9963b0..e933320 100644 --- a/server/src/database/dtos.rs +++ b/server/src/database/dtos.rs @@ -1,7 +1,9 @@ +mod account; mod recurring_transaction; mod results; mod transaction; +pub use account::*; pub use recurring_transaction::*; pub use results::*; pub use transaction::*; diff --git a/server/src/database/dtos/account.rs b/server/src/database/dtos/account.rs new file mode 100644 index 0000000..c6d9ed5 --- /dev/null +++ b/server/src/database/dtos/account.rs @@ -0,0 +1,6 @@ +use uuid::Uuid; + +pub struct AccountRow { + pub id: Uuid, + pub name: String, +} diff --git a/server/src/domain.rs b/server/src/domain.rs index a6fdded..458407b 100644 --- a/server/src/domain.rs +++ b/server/src/domain.rs @@ -1,9 +1,11 @@ +mod account; mod cents; mod direction; mod recurring_transaction; mod schedule; mod transaction; +pub use account::*; pub use cents::*; pub use direction::*; pub use recurring_transaction::*; diff --git a/server/src/domain/account.rs b/server/src/domain/account.rs new file mode 100644 index 0000000..3610f72 --- /dev/null +++ b/server/src/domain/account.rs @@ -0,0 +1,7 @@ +use uuid::Uuid; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Account { + pub id: Uuid, + pub name: String, +} diff --git a/server/src/repository.rs b/server/src/repository.rs index 3bbf9ea..ba57d77 100644 --- a/server/src/repository.rs +++ b/server/src/repository.rs @@ -1,5 +1,6 @@ use crate::domain::{CentsError, ScheduleError}; +pub mod accounts; pub mod dtos; mod encoding; pub mod recurring_transactions; diff --git a/server/src/repository/accounts.rs b/server/src/repository/accounts.rs new file mode 100644 index 0000000..94eff60 --- /dev/null +++ b/server/src/repository/accounts.rs @@ -0,0 +1,119 @@ +use uuid::Uuid; + +use super::{ + DecodeError, QueryConversionError, RepositoryError, + dtos::{Delete, Upsert}, +}; +use crate::{ + database::{accounts as db, dtos::AccountRow}, + domain::Account, +}; + +pub struct Query { + pub limit: Option, + pub offset: Option, +} + +impl TryFrom for db::Query { + type Error = QueryConversionError; + + fn try_from(query: Query) -> Result { + Ok(db::Query { + limit: query + .limit + .map(|l| i64::try_from(l).map_err(|_| QueryConversionError::Limit(l))) + .transpose()?, + offset: query + .offset + .map(|o| i64::try_from(o).map_err(|_| QueryConversionError::Offset(o))) + .transpose()?, + }) + } +} + +pub async fn list<'e, E>(executor: E, query: Query) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let accounts = db::query(executor, query.try_into()?) + .await? + .into_iter() + .map(decode) + .collect::>()?; + + Ok(accounts) +} + +pub async fn get<'e, E>(executor: E, id: Uuid) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let account = db::get_by_id(executor, id).await?.map(decode).transpose()?; + + Ok(account) +} + +pub async fn upsert<'e, E>( + executor: E, + account: Account, +) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let account = db::upsert(executor, encode(account)) + .await? + .try_map(decode)?; + + Ok(account.into()) +} + +pub async fn delete<'e, E>(executor: E, id: Uuid) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + Ok(db::delete_by_id(executor, id).await?.into()) +} + +fn decode(row: AccountRow) -> Result { + Ok(Account { + id: row.id, + name: row.name, + }) +} + +fn encode(account: Account) -> AccountRow { + AccountRow { + id: account.id, + name: account.name, + } +} + +#[cfg(test)] +mod tests { + use uuid::Uuid; + + use super::*; + + fn row() -> AccountRow { + AccountRow { + id: Uuid::new_v4(), + name: "Savings".to_owned(), + } + } + + #[test] + fn decodes_valid_rows() { + let row = row(); + let id = row.id; + let account = decode(row).unwrap(); + + assert_eq!(account.id, id); + assert_eq!(account.name, "Savings"); + } + + #[test] + fn round_trips_through_rows() { + let account = decode(row()).unwrap(); + assert_eq!(decode(encode(account.clone())).unwrap(), account); + } +} diff --git a/server/src/routes.rs b/server/src/routes.rs index de24aa7..5b23fe9 100644 --- a/server/src/routes.rs +++ b/server/src/routes.rs @@ -2,16 +2,19 @@ use axum::{http::StatusCode, routing::get}; use crate::error::AppError; +pub mod accounts; pub mod dtos; pub mod extractors; pub mod scheduled_transactions; pub mod transactions; pub fn create_router(pool: sqlx::PgPool) -> axum::Router { + let accounts = accounts::create_router(); let scheduled_transactions = scheduled_transactions::create_router(); let transactions = transactions::create_router(); let api = axum::Router::new() + .nest("/accounts", accounts) .nest("/scheduled-transactions", scheduled_transactions) .nest("/transactions", transactions); diff --git a/server/src/routes/accounts.rs b/server/src/routes/accounts.rs new file mode 100644 index 0000000..44aaa91 --- /dev/null +++ b/server/src/routes/accounts.rs @@ -0,0 +1,101 @@ +use axum::{extract::State, http::StatusCode}; +use serde::Deserialize; +use sqlx::PgPool; +use uuid::Uuid; + +use super::{ + dtos::{AccountRequest, AccountResponse}, + extractors::{json::Json, path::Path, query::Query}, +}; +use crate::{ + error::AppError, + repository::{ + accounts as repository, + dtos::{Delete, Upsert}, + }, +}; + +pub fn create_router() -> axum::Router { + axum::Router::new() + .route("/", axum::routing::get(query_accounts)) + .route( + "/{id}", + axum::routing::get(get_account) + .put(upsert_account) + .delete(delete_account), + ) +} + +#[derive(Debug, Deserialize)] +pub struct QueryParams { + pub limit: Option, + pub offset: Option, +} + +impl TryFrom for repository::Query { + type Error = AppError; + + fn try_from(query: QueryParams) -> Result { + Ok(repository::Query { + limit: Some(query.limit.unwrap_or(20)), + offset: query.offset, + }) + } +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn query_accounts( + State(pool): State, + Query(query): Query, +) -> Result>, AppError> { + let accounts = repository::list(&pool, query.try_into()?) + .await? + .into_iter() + .map(AccountResponse::from) + .collect(); + + Ok(Json(accounts)) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn get_account( + State(pool): State, + Path(id): Path, +) -> Result, AppError> { + let account = repository::get(&pool, id) + .await? + .ok_or(AppError::NotFound)?; + + Ok(Json(account.into())) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool, account))] +async fn upsert_account( + State(pool): State, + Path(id): Path, + Json(account): Json, +) -> Result<(StatusCode, Json), AppError> { + let account = account.into_domain(id)?; + + let (status, account) = match repository::upsert(&pool, account).await? { + Upsert::Created(account) => (StatusCode::CREATED, account), + Upsert::Updated(account) => (StatusCode::OK, account), + }; + + Ok((status, Json(account.into()))) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn delete_account( + Path(id): Path, + State(pool): State, +) -> Result { + match repository::delete(&pool, id).await? { + Delete::Deleted => Ok(StatusCode::NO_CONTENT), + Delete::NotFound => Err(AppError::NotFound), + } +} diff --git a/server/src/routes/dtos.rs b/server/src/routes/dtos.rs index 23380f0..a3f8d44 100644 --- a/server/src/routes/dtos.rs +++ b/server/src/routes/dtos.rs @@ -1,7 +1,9 @@ +mod account; mod direction; mod scheduled_transaction; mod transaction; +pub use account::*; pub use direction::*; pub use scheduled_transaction::*; pub use transaction::*; diff --git a/server/src/routes/dtos/account.rs b/server/src/routes/dtos/account.rs new file mode 100644 index 0000000..43f7c1a --- /dev/null +++ b/server/src/routes/dtos/account.rs @@ -0,0 +1,71 @@ +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +use crate::domain; + +#[derive(Debug, Clone, Deserialize)] +pub struct AccountRequest { + pub name: String, +} + +impl AccountRequest { + pub fn into_domain(self, id: Uuid) -> Result { + Ok(domain::Account { + id, + name: self.name, + }) + } +} + +#[derive(Debug, Clone, Serialize)] +pub struct AccountResponse { + pub id: Uuid, + pub name: String, +} + +impl From for AccountResponse { + fn from(account: domain::Account) -> Self { + Self { + id: account.id, + name: account.name, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn request() -> AccountRequest { + AccountRequest { + name: "Savings".to_owned(), + } + } + + #[test] + fn converts_between_dto_and_domain() { + let id = Uuid::new_v4(); + let account = request().into_domain(id).unwrap(); + assert_eq!(account.id, id); + assert_eq!(account.name, "Savings"); + + let response = AccountResponse::from(account); + assert_eq!(response.id, id); + assert_eq!(response.name, "Savings"); + } + + #[test] + fn keeps_account_json_flat() { + let response = AccountResponse { + id: Uuid::nil(), + name: "Savings".to_owned(), + }; + + let response = serde_json::to_value(response).unwrap(); + assert_eq!(response["id"], Uuid::nil().to_string()); + assert_eq!(response["name"], "Savings"); + + let request: AccountRequest = serde_json::from_value(response).unwrap(); + assert_eq!(request.name, "Savings"); + } +}