use async_trait::async_trait;
use sqlx::PgPool;
{% if has_map %}use sqlx::types::Json;
use std::collections::HashMap;
{% endif %}
{% set refs = fields | filter(attribute="is_ref", value=true) %}use business::domain::{{ snake }}::{
model::{{ "{" }}{{ pascal }}, {{ pascal }}Id},
repository::{% if refs %}{{ "{" }}{{ pascal }}Filter, {{ pascal }}RepositoryTrait}{% else %}{{ pascal }}RepositoryTrait{% endif %},
};
use puerto_core::{Page, PageRequest, RepositoryError};
use super::entity::{{ pascal }}Db;
{% if references and not events %}use crate::db::{ForeignKey, map_sqlx_error, map_sqlx_error_with};
{% else %}use crate::db::map_sqlx_error;
{% endif %}
pub struct Pg{{ pascal }}Repository {
pub pool: PgPool,
}
impl Pg{{ pascal }}Repository {
pub fn new(pool: PgPool) -> Self {
Self { pool }
}
}
{% if references and not events %}{% include "infrastructure/references.tera" %}{% endif %}
/// A row as the domain's entity. A row the domain rejects is stored data gone bad, not the
/// caller's fault: it is logged with the domain's reason and reported as `InvalidData`.
fn to_domain(row: {{ pascal }}Db) -> Result<{{ pascal }}, RepositoryError> {
{{ pascal }}::try_from(row).map_err(|e| {
tracing::error!(error = %e, "stored row is not a valid {{ snake }}");
RepositoryError::InvalidData
})
}
#[async_trait]
impl {{ pascal }}RepositoryTrait for Pg{{ pascal }}Repository {
async fn find_all(&self, page: PageRequest{% if refs %}, filter: {{ pascal }}Filter{% endif %}) -> Result<Page<{{ pascal }}>, RepositoryError> {
tracing::debug!(limit = page.limit(), offset = page.offset(), "find_all");
{% if refs %} // One static query whatever the filter: an unset id is NULL and matches every row.
{% for r in refs %} let {{ r.name }} = filter.{{ r.name }}.map(|id| id.value());
{% endfor %}{% endif %} let rows = sqlx::query_as!(
{{ pascal }}Db,
"SELECT {{ select_cols }}
FROM {{ plural }} WHERE {{ page_where }}
ORDER BY created_at DESC, id LIMIT $1 OFFSET $2",
i64::from(page.limit()),
i64::from(page.offset()){% for r in refs %},
{{ r.name }}{% endfor %}
)
.fetch_all(&self.pool)
.await
.map_err(|e| {
tracing::error!(error = %e, "find_all failed");
map_sqlx_error(&e)
})?;
let total = sqlx::query_scalar!(
r#"SELECT COUNT(*) AS "total!" FROM {{ plural }} WHERE {{ count_where }}"#{% for r in refs %},
{{ r.name }}{% endfor %}
)
.fetch_one(&self.pool)
.await
.map_err(|e| {
tracing::error!(error = %e, "find_all count failed");
map_sqlx_error(&e)
})?;
let items = rows.into_iter().map(to_domain).collect::<Result<Vec<_>, _>>()?;
// COUNT(*) is never negative.
let total = u64::try_from(total).unwrap_or_default();
Ok(Page::new(items, total, page))
}
async fn find_by_id(&self, id: {{ pascal }}Id) -> Result<Option<{{ pascal }}>, RepositoryError> {
tracing::debug!(%id, "find_by_id");
let row = sqlx::query_as!(
{{ pascal }}Db,
"SELECT {{ select_cols }}
FROM {{ plural }} WHERE id = $1 AND deleted = false",
id.value()
)
.fetch_optional(&self.pool)
.await
.map_err(|e| {
tracing::error!(error = %e, "find_by_id failed");
map_sqlx_error(&e)
})?;
row.map(to_domain).transpose()
}
{% if not events %}
async fn save(&self, entity: &{{ pascal }}) -> Result<(), RepositoryError> {
tracing::debug!(id = %entity.id, "save");
let db = {{ pascal }}Db::from(entity);
sqlx::query!(
"INSERT INTO {{ plural }} ({{ all_cols }})
VALUES ({{ all_params }})
ON CONFLICT (id) DO UPDATE
SET {{ all_updates }}",
db.id,
db.created_at,
db.updated_at,
db.deleted,
db.deleted_at,
{% for f in fields %} {% if f.is_array %}&db.{{ f.name }}{% elif f.is_map %}db.{{ f.name }} as _{% else %}db.{{ f.name }}{% endif %},
{% endfor %} )
.execute(&self.pool)
.await
.map_err(|e| {
tracing::error!(error = %e, "save failed");
{% if references %}map_sqlx_error_with(&e, REFERENCES){% else %}map_sqlx_error(&e){% endif %}
})?;
Ok(())
}
{% endif %}}
/// `pub(crate)`: an entity that references {{ pascal }} seeds its rows with this module's `seed`.
#[cfg(test)]
pub(crate) mod integration_tests {
use super::*;
use business::domain::{{ snake }}::model::{{ pascal }}Props;
{% if events %} use business::domain::{{ snake }}::unit_of_work::{{ pascal }}UnitOfWorkFactory;
use crate::{{ snake }}::unit_of_work::Pg{{ pascal }}UnitOfWorkFactory;
{% endif %}
{% for import in test_imports %} use {{ import }};
{% endfor %}{% if not events %}{% for import in reference_imports %} use {{ import }};
{% endfor %}{% endif %}
fn test_repo(pool: PgPool) -> Pg{{ pascal }}Repository {
Pg{{ pascal }}Repository::new(pool)
}
{% if events %}
/// The repository only reads: rows are written through the unit of work.
async fn store(pool: &PgPool, entity: &{{ pascal }}) {
let mut uow = Pg{{ pascal }}UnitOfWorkFactory::new(pool.clone()).begin().await.unwrap();
uow.save(entity).await.unwrap();
uow.commit().await.unwrap();
}
{% endif %}
/// A valid {{ snake }}, not stored{% if seeds_references %}: the rows it references are seeded first{% endif %}.
{% if seeds_references %}async fn build(pool: &PgPool){% else %}fn build(){% endif %} -> {{ pascal }} {
{{ pascal }}::new({{ pascal }}Props {
{% for f in fields %} {{ f.name }}: {{ f.seed_literal }},
{% endfor %} }).unwrap()
}
/// A stored {{ snake }}.
pub(crate) async fn seed(pool: &PgPool) -> {{ pascal }} {
let entity = build({% if seeds_references %}pool).await{% else %}){% endif %};
{% if events %}store(pool, &entity).await;{% else %}test_repo(pool.clone()).save(&entity).await.unwrap();{% endif %}
entity
}
#[sqlx::test(migrations = "./migrations")]
async fn should_persist_and_retrieve_by_id(pool: PgPool) {
// Arrange
let entity = seed(&pool).await;
// Act
let found = test_repo(pool).find_by_id(entity.id).await.unwrap().unwrap();
// Assert
assert_eq!(found.id, entity.id);
{% for f in fields %} assert_eq!(found.{{ f.name }}, entity.{{ f.name }});
{% endfor %} assert!(!found.deleted);
}
#[sqlx::test(migrations = "./migrations")]
async fn should_return_none_for_nonexistent_id(pool: PgPool) {
// Act
let result = test_repo(pool).find_by_id({{ pascal }}Id::generate()).await.unwrap();
// Assert
assert!(result.is_none());
}
{% if not events %} #[sqlx::test(migrations = "./migrations")]
async fn should_update_entity_on_save_conflict(pool: PgPool) {
// Arrange
{% set required = fields | filter(attribute="required_string", value=true) %}{% set string_vos = fields | filter(attribute="string_vo", value=true) %}{% if required or string_vos %}{% if required %}{% set f = required.0 %}{% else %}{% set f = string_vos.0 %}{% endif %} let mut entity = seed(&pool).await;
entity.{{ f.name }} = {% if f.is_vo %}{{ f.vo }}::new("updated".to_string()).unwrap(){% else %}"updated".to_string(){% endif %};
entity.updated_at = chrono::Utc::now();
// Act
test_repo(pool.clone()).save(&entity).await.unwrap();
// Assert
let found = test_repo(pool).find_by_id(entity.id).await.unwrap().unwrap();
assert_eq!(found.{{ f.name }}{% if f.is_vo %}.value(){% endif %}, "updated");
{% else %} let entity = seed(&pool).await;
// Act
test_repo(pool.clone()).save(&entity).await.unwrap();
// Assert
let found = test_repo(pool).find_by_id(entity.id).await.unwrap();
assert!(found.is_some());
{% endif %} }
{% endif %} #[sqlx::test(migrations = "./migrations")]
async fn should_list_all_{{ plural }}_excluding_deleted(pool: PgPool) {
// Arrange
seed(&pool).await;
let mut deleted = seed(&pool).await;
deleted.deleted = true;
deleted.deleted_at = Some(deleted.updated_at);
{% if events %}store(&pool, &deleted).await;{% else %}test_repo(pool.clone()).save(&deleted).await.unwrap();{% endif %}
// Act
let page = test_repo(pool).find_all(PageRequest::default(){% if refs %}, {{ pascal }}Filter::default(){% endif %}).await.unwrap();
// Assert
assert_eq!(page.items.len(), 1);
assert_eq!(page.total, 1);
}
#[sqlx::test(migrations = "./migrations")]
async fn should_return_the_requested_page_of_a_larger_list(pool: PgPool) {
// Arrange
for _ in 0..3 {
seed(&pool).await;
}
// Act
let page = test_repo(pool)
.find_all(PageRequest::new(Some(2), Some(2)){% if refs %}, {{ pascal }}Filter::default(){% endif %})
.await
.unwrap();
// Assert
assert_eq!(page.items.len(), 1);
assert_eq!(page.total, 3);
assert_eq!((page.limit, page.offset), (2, 2));
}
{% set uniques = fields | filter(attribute="unique", value=true) %}{% if uniques and not events %}{% set u = uniques.0 %}
#[sqlx::test(migrations = "./migrations")]
async fn should_reject_a_duplicate_{{ u.name }}(pool: PgPool) {
// Arrange
let first = seed(&pool).await;
let mut second = build({% if seeds_references %}&pool).await{% else %}){% endif %};
second.{{ u.name }} = first.{{ u.name }}{% if u.needs_clone %}.clone(){% endif %};
// Act
let result = test_repo(pool).save(&second).await;
// Assert
assert_eq!(result.unwrap_err(), RepositoryError::Duplicate);
}
{% endif %}{% if not events %}{% for r in references %}
#[sqlx::test(migrations = "./migrations")]
async fn should_reject_a_missing_{{ r.field }}(pool: PgPool) {
// Arrange: a {{ r.field }} no row has.
let mut entity = build({% if seeds_references %}&pool).await{% else %}){% endif %};
entity.{{ r.field }} = {% if r.optional %}Some({{ r.id }}::generate()){% else %}{{ r.id }}::generate(){% endif %};
// Act
let result = test_repo(pool).save(&entity).await;
// Assert
assert_eq!(result.unwrap_err(), RepositoryError::MissingReference("{{ r.field }}"));
}
{% endfor %}{% endif %}{% for r in refs %}
#[sqlx::test(migrations = "./migrations")]
async fn should_list_only_the_{{ plural }}_of_the_requested_{{ r.name }}(pool: PgPool) {
// Arrange: one {{ snake }} with this {{ r.name }}, one without.
let target = crate::{{ r.ref_target_snake }}::repository::integration_tests::seed(&pool).await;
let mut wanted = build({% if seeds_references %}&pool).await{% else %}){% endif %};
wanted.{{ r.name }} = {% if r.field_type is starting_with("Option<") %}Some(target.id){% else %}target.id{% endif %};
{% if events %}store(&pool, &wanted).await;{% else %}test_repo(pool.clone()).save(&wanted).await.unwrap();{% endif %}
seed(&pool).await;
// Act
let page = test_repo(pool)
.find_all(
PageRequest::default(),
{{ pascal }}Filter {
{% for o in refs %} {{ o.name }}: {% if o.name == r.name %}Some(target.id){% else %}None{% endif %},
{% endfor %} },
)
.await
.unwrap();
// Assert
assert_eq!(page.items.iter().map(|row| row.id).collect::<Vec<_>>(), vec![wanted.id]);
assert_eq!(page.total, 1);
}
{% endfor %}}