use std::collections::{HashMap, HashSet}; use axum::{extract::State, http::StatusCode}; use serde::Deserialize; use sqlx::PgPool; use uuid::Uuid; use super::{ dtos::transaction::{TransactionRequest, TransactionResponse}, extractors::{Auth, Json, Path, Query}, }; use crate::{domain, error::AppError, repository}; pub fn create_router() -> axum::Router { axum::Router::new() .route("/", axum::routing::get(list_transactions)) .route( "/{id}", axum::routing::get(get_transaction) .put(upsert_transaction) .delete(delete_transaction), ) } #[derive(Debug, Deserialize)] pub struct QueryParams { pub limit: Option, pub offset: Option, } #[axum::debug_handler] #[tracing::instrument(skip(pool))] async fn list_transactions( Auth(auth): Auth, Query(query): Query, State(pool): State, ) -> Result>, AppError> { let user_id = auth.user_id(); let query = repository::transactions::Query { limit: Some(query.limit.unwrap_or(20)), offset: query.offset, }; let transactions = repository::transactions::list(&pool, user_id, query).await?; let accounts = get_accounts_for_transactions(&pool, user_id, &transactions).await?; let responses = transactions .into_iter() .map(|transaction| create_response(transaction, &accounts)) .collect::, _>>()?; Ok(Json(responses)) } #[axum::debug_handler] #[tracing::instrument(skip(pool))] async fn get_transaction( Auth(auth): Auth, Path(id): Path, State(pool): State, ) -> Result, AppError> { let user_id = auth.user_id(); let transaction = repository::transactions::get_by_id(&pool, user_id, id) .await? .ok_or(AppError::NotFound)?; let account = repository::accounts::get_by_id(&pool, user_id, transaction.account_id) .await? .ok_or(AppError::RaceCondition)?; // Account should be accessible! Ok(Json(create_response( transaction, &HashMap::from([(account.id, account)]), )?)) } #[axum::debug_handler] #[tracing::instrument(skip(pool, transaction))] async fn upsert_transaction( Auth(auth): Auth, Path(id): Path, State(pool): State, Json(transaction): Json, ) -> Result<(StatusCode, Json), AppError> { let user_id = auth.user_id(); let transaction = transaction.into_domain(id)?; let account = repository::accounts::get_by_id(&pool, user_id, transaction.account_id) .await? .ok_or(AppError::AccountNotFound)?; let upserted = repository::transactions::upsert(&pool, user_id, transaction) .await? .ok_or(AppError::TransactionIdAlreadyExists)?; let status = if upserted.previous.is_some() { StatusCode::OK } else { StatusCode::CREATED }; Ok(( status, Json(create_response( upserted.current, &HashMap::from([(account.id, account)]), )?), )) } #[axum::debug_handler] #[tracing::instrument(skip(pool))] async fn delete_transaction( Auth(auth): Auth, Path(id): Path, State(pool): State, ) -> Result { repository::transactions::delete_by_id(&pool, auth.user_id(), id) .await? .ok_or(AppError::NotFound)?; Ok(StatusCode::NO_CONTENT) } async fn get_accounts_for_transactions<'e, E>( executor: E, user_id: Uuid, transactions: &[domain::Transaction], ) -> Result, AppError> where E: sqlx::Executor<'e, Database = sqlx::Postgres>, { let account_ids = transactions .iter() .map(|transaction| transaction.account_id) .collect::>() .into_iter() .collect::>(); Ok(repository::accounts::get_by_ids(executor, user_id, &account_ids).await?) } fn create_response( transaction: domain::Transaction, accounts: &HashMap, ) -> Result { let account = accounts .get(&transaction.account_id) .cloned() .ok_or(AppError::Unknown)?; Ok(TransactionResponse::new(transaction, account)) }