diff --git a/server/.sqlx/query-22d5813be73a45003abd94152c36756917d705c694b36988b1514067d78fa154.json b/server/.sqlx/query-22d5813be73a45003abd94152c36756917d705c694b36988b1514067d78fa154.json new file mode 100644 index 0000000..a41d6b2 --- /dev/null +++ b/server/.sqlx/query-22d5813be73a45003abd94152c36756917d705c694b36988b1514067d78fa154.json @@ -0,0 +1,22 @@ +{ + "db_name": "PostgreSQL", + "query": "\n\t\tSELECT id\n\t\tFROM users\n\t\tWHERE id = $1\n\t\t", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false + ] + }, + "hash": "22d5813be73a45003abd94152c36756917d705c694b36988b1514067d78fa154" +} diff --git a/server/.sqlx/query-58327aa90726e98d2f31a5178c611b22b3177ea71f812c9f53e4164f22cd1f8a.json b/server/.sqlx/query-58327aa90726e98d2f31a5178c611b22b3177ea71f812c9f53e4164f22cd1f8a.json new file mode 100644 index 0000000..2f00e9a --- /dev/null +++ b/server/.sqlx/query-58327aa90726e98d2f31a5178c611b22b3177ea71f812c9f53e4164f22cd1f8a.json @@ -0,0 +1,22 @@ +{ + "db_name": "PostgreSQL", + "query": "DELETE FROM users WHERE id = $1 RETURNING id", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false + ] + }, + "hash": "58327aa90726e98d2f31a5178c611b22b3177ea71f812c9f53e4164f22cd1f8a" +} diff --git a/server/.sqlx/query-87aa6dcbad3e6911c33c93ae02e001ec762ed8877a4a0bc66e195bdb1c113135.json b/server/.sqlx/query-87aa6dcbad3e6911c33c93ae02e001ec762ed8877a4a0bc66e195bdb1c113135.json new file mode 100644 index 0000000..e915fb4 --- /dev/null +++ b/server/.sqlx/query-87aa6dcbad3e6911c33c93ae02e001ec762ed8877a4a0bc66e195bdb1c113135.json @@ -0,0 +1,23 @@ +{ + "db_name": "PostgreSQL", + "query": "\n\t\tSELECT id\n\t\tFROM users\n\t\tORDER BY id DESC\n\t\tLIMIT $1\n\t\tOFFSET $2\n\t\t", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "id", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Int8", + "Int8" + ] + }, + "nullable": [ + false + ] + }, + "hash": "87aa6dcbad3e6911c33c93ae02e001ec762ed8877a4a0bc66e195bdb1c113135" +} diff --git a/server/.sqlx/query-ee3602e86d747b71e9d7c41965c4c7f58e16790af1303adcfe9686bb35fc741a.json b/server/.sqlx/query-ee3602e86d747b71e9d7c41965c4c7f58e16790af1303adcfe9686bb35fc741a.json new file mode 100644 index 0000000..1ce739f --- /dev/null +++ b/server/.sqlx/query-ee3602e86d747b71e9d7c41965c4c7f58e16790af1303adcfe9686bb35fc741a.json @@ -0,0 +1,28 @@ +{ + "db_name": "PostgreSQL", + "query": "\n\t\tINSERT INTO users (id)\n\t\tVALUES ($1)\n\t\tON CONFLICT (id) DO UPDATE SET\n id = EXCLUDED.id\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", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "old_id?", + "type_info": "Uuid" + }, + { + "ordinal": 1, + "name": "id!", + "type_info": "Uuid" + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false, + false + ] + }, + "hash": "ee3602e86d747b71e9d7c41965c4c7f58e16790af1303adcfe9686bb35fc741a" +} diff --git a/server/migrations/20260916000000_create_users.sql b/server/migrations/20260916000000_create_users.sql new file mode 100644 index 0000000..4d8a759 --- /dev/null +++ b/server/migrations/20260916000000_create_users.sql @@ -0,0 +1,3 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid () +); \ No newline at end of file diff --git a/server/migrations/20260928000000_seed_demo_data.sql b/server/migrations/20260928000000_seed_demo_data.sql index 693d4b2..0ec8de2 100644 --- a/server/migrations/20260928000000_seed_demo_data.sql +++ b/server/migrations/20260928000000_seed_demo_data.sql @@ -1,3 +1,9 @@ +INSERT INTO + users (id) +VALUES ( + '00000000-0000-0000-0000-000000000001' + ); + INSERT INTO accounts (id, name) VALUES ( diff --git a/server/src/database.rs b/server/src/database.rs index 9b05eff..8c05388 100644 --- a/server/src/database.rs +++ b/server/src/database.rs @@ -3,6 +3,7 @@ pub mod dtos; mod error_codes; pub mod recurring_transactions; pub mod transactions; +pub mod users; use error_codes::PG_FOREIGN_KEY_VIOLATION; diff --git a/server/src/database/dtos.rs b/server/src/database/dtos.rs index e933320..c8f61d8 100644 --- a/server/src/database/dtos.rs +++ b/server/src/database/dtos.rs @@ -2,8 +2,10 @@ mod account; mod recurring_transaction; mod results; mod transaction; +mod user; pub use account::*; pub use recurring_transaction::*; pub use results::*; pub use transaction::*; +pub use user::*; diff --git a/server/src/database/dtos/user.rs b/server/src/database/dtos/user.rs new file mode 100644 index 0000000..7b22b61 --- /dev/null +++ b/server/src/database/dtos/user.rs @@ -0,0 +1,5 @@ +use uuid::Uuid; + +pub struct UserRow { + pub id: Uuid, +} diff --git a/server/src/database/users.rs b/server/src/database/users.rs new file mode 100644 index 0000000..e37f020 --- /dev/null +++ b/server/src/database/users.rs @@ -0,0 +1,104 @@ +use uuid::Uuid; + +use super::{ + DatabaseError, + dtos::{Delete, Upsert, UserRow}, +}; + +pub struct Query { + pub limit: Option, + pub offset: Option, +} + +impl Default for Query { + fn default() -> Self { + Self { + limit: None, + offset: None, + } + } +} + +pub async fn query<'e, E>(executor: E, query: Query) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_as!( + UserRow, + r#" + SELECT id + FROM users + ORDER BY id DESC + LIMIT $1 + OFFSET $2 + "#, + query.limit, + query.offset, + ) + .fetch_all(executor) + .await + .map_err(DatabaseError::from) +} + +pub async fn get_by_id<'e, E>(executor: E, id: Uuid) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + sqlx::query_as!( + UserRow, + r#" + SELECT id + FROM users + WHERE id = $1 + "#, + id, + ) + .fetch_optional(executor) + .await + .map_err(DatabaseError::from) +} + +pub async fn upsert<'e, E>(executor: E, user: UserRow) -> Result, DatabaseError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let row = sqlx::query!( + r#" + INSERT INTO users (id) + VALUES ($1) + ON CONFLICT (id) DO UPDATE SET + id = EXCLUDED.id + RETURNING WITH (OLD AS old_row, NEW AS new_row) + old_row.id AS "old_id?", + new_row.id AS "id!" + "#, + user.id, + ) + .fetch_one(executor) + .await + .map_err(DatabaseError::from)?; + + let user = UserRow { id: row.id }; + + if row.old_id.is_some() { + Ok(Upsert::Updated(user)) + } else { + Ok(Upsert::Created(user)) + } +} + +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 users WHERE id = $1 RETURNING id", id) + .fetch_optional(executor) + .await + .map_err(DatabaseError::from)?; + + Ok(if deleted.is_some() { + Delete::Deleted + } else { + Delete::NotFound + }) +} diff --git a/server/src/domain.rs b/server/src/domain.rs index 458407b..af301bb 100644 --- a/server/src/domain.rs +++ b/server/src/domain.rs @@ -4,6 +4,7 @@ mod direction; mod recurring_transaction; mod schedule; mod transaction; +mod user; pub use account::*; pub use cents::*; @@ -11,6 +12,7 @@ pub use direction::*; pub use recurring_transaction::*; pub use schedule::*; pub use transaction::*; +pub use user::*; #[derive(Debug, thiserror::Error)] pub enum DomainError { diff --git a/server/src/domain/user.rs b/server/src/domain/user.rs new file mode 100644 index 0000000..19ad5e9 --- /dev/null +++ b/server/src/domain/user.rs @@ -0,0 +1,6 @@ +use uuid::Uuid; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct User { + pub id: Uuid, +} diff --git a/server/src/repository.rs b/server/src/repository.rs index 1b6d110..fcdc672 100644 --- a/server/src/repository.rs +++ b/server/src/repository.rs @@ -8,6 +8,7 @@ pub mod dtos; mod encoding; pub mod recurring_transactions; pub mod transactions; +pub mod users; #[derive(Debug, thiserror::Error)] pub enum RepositoryError { diff --git a/server/src/repository/users.rs b/server/src/repository/users.rs new file mode 100644 index 0000000..c694f6b --- /dev/null +++ b/server/src/repository/users.rs @@ -0,0 +1,140 @@ +use uuid::Uuid; + +use super::{ + DecodeError, QueryConversionError, RepositoryError, + dtos::{Delete, Upsert}, +}; +use crate::{ + database::{DatabaseError, dtos::UserRow, users as db}, + domain::User, +}; + +pub struct Query { + pub limit: Option, + pub offset: Option, +} + +impl Default for Query { + fn default() -> Self { + Self { + limit: None, + offset: None, + } + } +} + +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()?, + ..Default::default() + }) + } +} + +pub async fn list<'e, E>(executor: E, query: Query) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let users = db::query(executor, query.try_into()?) + .await? + .into_iter() + .map(decode) + .collect::>()?; + + Ok(users) +} + +pub async fn get<'e, E>(executor: E, id: Uuid) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let user = db::get_by_id(executor, id).await?.map(decode).transpose()?; + + Ok(user) +} + +pub async fn upsert<'e, E>(executor: E, user: User) -> Result, RepositoryError> +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let user = db::upsert(executor, encode(user)).await?.try_map(decode)?; + + Ok(user.into()) +} + +pub async fn delete<'e, E>(executor: E, id: Uuid) -> Result +where + E: sqlx::Executor<'e, Database = sqlx::Postgres>, +{ + let deleted = db::delete_by_id(executor, id) + .await + .map_err(classify_delete_error)?; + + Ok(deleted.into()) +} + +fn classify_delete_error(error: DatabaseError) -> RepositoryError { + match &error { + _ => RepositoryError::Database(error), + } +} + +fn decode(row: UserRow) -> Result { + Ok(User { id: row.id }) +} + +fn encode(user: User) -> UserRow { + UserRow { id: user.id } +} + +#[cfg(test)] +mod tests { + use uuid::Uuid; + + use crate::database::Constraint; + + use super::*; + + fn foreign_key_violation(constraint: Constraint) -> DatabaseError { + DatabaseError::ForeignKeyViolation { + constraint, + source: sqlx::Error::Protocol("test database cause".to_owned()), + } + } + + #[test] + fn keeps_unknown_user_delete_foreign_keys_generic() { + let error = classify_delete_error(foreign_key_violation(Constraint::Unnamed)); + + assert!(matches!(error, RepositoryError::Database(_))); + } + + fn row() -> UserRow { + UserRow { id: Uuid::new_v4() } + } + + #[test] + fn decodes_valid_rows() { + let row = row(); + let id = row.id; + let user = decode(row).unwrap(); + + assert_eq!(user.id, id); + } + + #[test] + fn round_trips_through_rows() { + let user = decode(row()).unwrap(); + assert_eq!(decode(encode(user.clone())).unwrap(), user); + } +} diff --git a/server/src/routes.rs b/server/src/routes.rs index 5b23fe9..69aca4f 100644 --- a/server/src/routes.rs +++ b/server/src/routes.rs @@ -7,16 +7,19 @@ pub mod dtos; pub mod extractors; pub mod scheduled_transactions; pub mod transactions; +pub mod users; 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 users = users::create_router(); let api = axum::Router::new() .nest("/accounts", accounts) .nest("/scheduled-transactions", scheduled_transactions) - .nest("/transactions", transactions); + .nest("/transactions", transactions) + .nest("/users", users); axum::Router::new() .nest("/api", api) diff --git a/server/src/routes/dtos.rs b/server/src/routes/dtos.rs index 790a204..618d194 100644 --- a/server/src/routes/dtos.rs +++ b/server/src/routes/dtos.rs @@ -2,3 +2,4 @@ pub mod account; pub mod direction; pub mod scheduled_transaction; pub mod transaction; +pub mod user; diff --git a/server/src/routes/dtos/user.rs b/server/src/routes/dtos/user.rs new file mode 100644 index 0000000..eed6b56 --- /dev/null +++ b/server/src/routes/dtos/user.rs @@ -0,0 +1,59 @@ +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +use crate::domain; + +#[derive(Debug, Clone, Deserialize)] +pub struct UserRequest {} + +impl UserRequest { + pub fn into_domain(self, id: Uuid) -> Result { + Ok(domain::User { id }) + } +} + +#[derive(Debug, Clone, Serialize)] +pub struct UserResponse { + pub id: Uuid, +} + +impl From for UserResponse { + fn from(user: domain::User) -> Self { + Self { id: user.id } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn request() -> UserRequest { + UserRequest {} + } + + #[test] + fn serializes_user_response() { + let id = Uuid::nil(); + let user = request().into_domain(id).unwrap(); + let response = serde_json::to_value(UserResponse::from(user)).unwrap(); + + assert_eq!(response["id"], id.to_string()); + } + + #[test] + fn deserializes_user_response_as_request() { + let user = request().into_domain(Uuid::nil()).unwrap(); + let response = serde_json::to_value(UserResponse::from(user)).unwrap(); + let _request: UserRequest = serde_json::from_value(response).unwrap(); + } + + #[test] + fn converts_between_dto_and_domain() { + let id = Uuid::new_v4(); + let user = request().into_domain(id).unwrap(); + assert_eq!(user.id, id); + + let response = UserResponse::from(user); + assert_eq!(response.id, id); + } +} diff --git a/server/src/routes/users.rs b/server/src/routes/users.rs new file mode 100644 index 0000000..8ca93ec --- /dev/null +++ b/server/src/routes/users.rs @@ -0,0 +1,102 @@ +use axum::{extract::State, http::StatusCode}; +use serde::Deserialize; +use sqlx::PgPool; +use uuid::Uuid; + +use super::{ + dtos::user::{UserRequest, UserResponse}, + extractors::{json::Json, path::Path, query::Query}, +}; +use crate::{ + error::AppError, + repository::{ + dtos::{Delete, Upsert}, + users as repository, + }, +}; + +pub fn create_router() -> axum::Router { + axum::Router::new() + .route("/", axum::routing::get(list_users)) + .route( + "/{id}", + axum::routing::get(get_user) + .put(upsert_user) + .delete(delete_user), + ) +} + +#[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, + ..Default::default() + }) + } +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn list_users( + State(pool): State, + Query(query): Query, +) -> Result>, AppError> { + let users = repository::list(&pool, query.try_into()?) + .await? + .into_iter() + .map(UserResponse::from) + .collect(); + + Ok(Json(users)) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn get_user( + State(pool): State, + Path(id): Path, +) -> Result, AppError> { + let user = repository::get(&pool, id) + .await? + .ok_or(AppError::NotFound)?; + + Ok(Json(user.into())) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool, user))] +async fn upsert_user( + State(pool): State, + Path(id): Path, + Json(user): Json, +) -> Result<(StatusCode, Json), AppError> { + let user = user.into_domain(id)?; + + let (status, user) = match repository::upsert(&pool, user).await? { + Upsert::Created(user) => (StatusCode::CREATED, user), + Upsert::Updated(user) => (StatusCode::OK, user), + }; + + Ok((status, Json(user.into()))) +} + +#[axum::debug_handler] +#[tracing::instrument(skip(pool))] +async fn delete_user( + Path(id): Path, + State(pool): State, +) -> Result { + match repository::delete(&pool, id).await? { + Delete::Deleted => Ok(StatusCode::NO_CONTENT), + Delete::NotFound => Err(AppError::NotFound), + } +}