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, } pub async fn list<'e, E>(executor: E, query: Query) -> Result, RepositoryError> where E: sqlx::Executor<'e, Database = sqlx::Postgres>, { let query = 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()?, }; let users = db::list(executor, query) .await? .into_iter() .map(decode) .collect::>()?; Ok(users) } pub async fn get_by_id<'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)? .into(); Ok(user) } pub async fn delete_by_id<'e, E>(executor: E, id: Uuid) -> Result where E: sqlx::Executor<'e, Database = sqlx::Postgres>, { let result = db::delete_by_id(executor, id) .await .map_err(classify_delete_error)? .into(); Ok(result) } fn classify_delete_error(error: DatabaseError) -> RepositoryError { 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); } }