puerto 0.20.0

Puerto — Rust full-stack DDD framework CLI. Scaffolds Clean Architecture projects with auto-wired DI, SQLx support, and zero manual wiring. Formerly puerto-framework.
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 %}}