puerto 0.22.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;

use dominio_{{ snake }}::{
    eventos::Evento{{ pascal }},
    modelo::{{ pascal }},
    unit_of_work::{{ "{" }}UnitOfWork{{ pascal }}, UnitOfWorkFactory{{ pascal }}},
};
use puerto_nucleo::ErrorRepositorio;
use puerto_sqlx::uow::TransaccionPostgres;
{% if references %}use puerto_sqlx::{ClaveForanea, mapear_error_sqlx_con};
{% else %}use puerto_sqlx::mapear_error_sqlx;
{% endif %}
use crate::fila::Fila{{ pascal }};

/// Abre una transacción de Postgres por escritura: la fila de {{ snake }} y su evento del outbox
/// hacen commit juntos.
pub struct UnitOfWorkFactory{{ pascal }}Postgres {
    pub pool: PgPool,
}

impl UnitOfWorkFactory{{ pascal }}Postgres {
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }
}
{% if references %}{% include "infrastructure/references.tera" %}{% endif %}
#[async_trait]
impl UnitOfWorkFactory{{ pascal }} for UnitOfWorkFactory{{ pascal }}Postgres {
    async fn begin(&self) -> Result<Box<dyn UnitOfWork{{ pascal }}>, ErrorRepositorio> {
        let tx = TransaccionPostgres::begin(&self.pool).await?;
        Ok(Box::new(UnitOfWork{{ pascal }}Postgres { tx }))
    }
}

struct UnitOfWork{{ pascal }}Postgres {
    tx: TransaccionPostgres,
}

#[async_trait]
impl UnitOfWork{{ pascal }} for UnitOfWork{{ pascal }}Postgres {
    async fn guardar(&mut self, entidad: &{{ pascal }}) -> Result<(), ErrorRepositorio> {
        tracing::debug!(id = %entidad.id, "guardar");
        let db = Fila{{ pascal }}::from(entidad);
        sqlx::query!(
            "INSERT INTO {{ plural }} ({{ all_cols }})
             VALUES ({{ all_params }})
             ON CONFLICT (id) DO UPDATE
             SET {{ all_updates }}",
            db.id,
            db.creado_en,
            db.actualizado_en,
            db.borrado,
            db.borrado_en,
{% 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.tx.tx())
        .await
        .map_err(|e| {
            tracing::error!(error = %e, "guardar falló");
            {% if references %}mapear_error_sqlx_con(&e, REFERENCES){% else %}mapear_error_sqlx(&e){% endif %}
        })?;
        Ok(())
    }

    async fn registrar(&mut self, evento: Evento{{ pascal }}) -> Result<(), ErrorRepositorio> {
        self.tx.registrar(&evento).await
    }

    async fn commit(self: Box<Self>) -> Result<(), ErrorRepositorio> {
        self.tx.commit().await
    }
}

#[cfg(test)]
mod pruebas_integracion {
    use super::*;
    use dominio_{{ snake }}::{eventos::Snapshot{{ pascal }}, repositorio::Repositorio{{ pascal }}};

    use crate::pruebas::siembra::construir;
    use crate::repositorio::Repositorio{{ pascal }}Postgres;
{% if update_vo_import %}    use {{ update_vo_import }};
{% endif %}{% for import in reference_imports %}    use {{ import }};
{% endfor %}
    /// Lo que hace un caso de uso de creación: guardar, registrar, commit.
    async fn crear(pool: &PgPool, entidad: &{{ pascal }}) -> Result<(), ErrorRepositorio> {
        let mut uow = UnitOfWorkFactory{{ pascal }}Postgres::new(pool.clone()).begin().await?;
        uow.guardar(entidad).await?;
        uow.registrar(Evento{{ pascal }}::Creado(Snapshot{{ pascal }}::from_entidad(entidad))).await?;
        uow.commit().await
    }

    async fn contar(pool: &PgPool, sql: &str) -> i64 {
        sqlx::query_scalar(sql).fetch_one(pool).await.unwrap()
    }

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_escribir_{{ snake }}_y_su_evento_cuando_hace_commit(pool: PgPool) {
        // Preparar
        let entidad = construir({% if seeds_references %}&pool).await{% else %}){% endif %};

        // Actuar
        crear(&pool, &entidad).await.unwrap();

        // Comprobar
        let encontrado = Repositorio{{ pascal }}Postgres::new(pool.clone()).buscar_por_id(entidad.id).await.unwrap();
        assert!(encontrado.is_some());
        let (tipo_evento, id_agregado): (String, uuid::Uuid) =
            sqlx::query_as("SELECT tipo_evento, id_agregado FROM outbox")
                .fetch_one(&pool)
                .await
                .unwrap();
        assert_eq!(tipo_evento, "{{ snake }}_creado");
        assert_eq!(id_agregado, entidad.id.valor());
    }

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn no_deberia_escribir_nada_cuando_se_libera_sin_commit(pool: PgPool) {
        // Preparar
        let entidad = construir({% if seeds_references %}&pool).await{% else %}){% endif %};

        // Actuar
        {
            let mut uow = UnitOfWorkFactory{{ pascal }}Postgres::new(pool.clone()).begin().await.unwrap();
            uow.guardar(&entidad).await.unwrap();
            uow.registrar(Evento{{ pascal }}::Creado(Snapshot{{ pascal }}::from_entidad(&entidad))).await.unwrap();
        }

        // Comprobar
        assert_eq!(contar(&pool, "SELECT COUNT(*) FROM {{ plural }}").await, 0);
        assert_eq!(contar(&pool, "SELECT COUNT(*) FROM outbox").await, 0);
    }

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_actualizar_{{ snake }}_cuando_se_guarda_de_nuevo(pool: PgPool) {
        // Preparar
{% 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 entidad = construir({% if seeds_references %}&pool).await{% else %}){% endif %};
        crear(&pool, &entidad).await.unwrap();
        entidad.{{ f.name }} = {% if f.is_vo %}{{ f.vo }}::new("updated".to_string()).unwrap(){% else %}"updated".to_string(){% endif %};
        entidad.actualizado_en = chrono::Utc::now();

        // Actuar
        let mut uow = UnitOfWorkFactory{{ pascal }}Postgres::new(pool.clone()).begin().await.unwrap();
        uow.guardar(&entidad).await.unwrap();
        uow.commit().await.unwrap();

        // Comprobar
        let encontrado = Repositorio{{ pascal }}Postgres::new(pool).buscar_por_id(entidad.id).await.unwrap().unwrap();
        assert_eq!(encontrado.{{ f.name }}{% if f.is_vo %}.valor(){% endif %}, "updated");
{% else %}        let entidad = construir({% if seeds_references %}&pool).await{% else %}){% endif %};
        crear(&pool, &entidad).await.unwrap();

        // Actuar
        let mut uow = UnitOfWorkFactory{{ pascal }}Postgres::new(pool.clone()).begin().await.unwrap();
        uow.guardar(&entidad).await.unwrap();
        uow.commit().await.unwrap();

        // Comprobar
        assert_eq!(contar(&pool, "SELECT COUNT(*) FROM {{ plural }}").await, 1);
{% endif %}    }
{% set uniques = fields | filter(attribute="unique", value=true) %}{% if uniques %}{% set u = uniques.0 %}

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn no_deberia_escribir_fila_ni_evento_cuando_{{ u.name }}_ya_esta_en_uso(pool: PgPool) {
        // Preparar
        let primero = construir({% if seeds_references %}&pool).await{% else %}){% endif %};
        crear(&pool, &primero).await.unwrap();
        let mut segundo = construir({% if seeds_references %}&pool).await{% else %}){% endif %};
        segundo.{{ u.name }} = primero.{{ u.name }}{% if u.needs_clone %}.clone(){% endif %};

        // Actuar
        let resultado = crear(&pool, &segundo).await;

        // Comprobar
        assert_eq!(resultado.unwrap_err(), ErrorRepositorio::Duplicado);
        assert_eq!(contar(&pool, "SELECT COUNT(*) FROM {{ plural }}").await, 1);
        assert_eq!(contar(&pool, "SELECT COUNT(*) FROM outbox").await, 1);
    }
{% endif %}{% for g in unique_groups %}

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn no_deberia_escribir_fila_ni_evento_cuando_{{ g.suffix }}_ya_estan_en_uso(pool: PgPool) {
        // Preparar
        let primero = construir({% if seeds_references %}&pool).await{% else %}){% endif %};
        crear(&pool, &primero).await.unwrap();
        let mut segundo = construir({% if seeds_references %}&pool).await{% else %}){% endif %};
{% for f in g.fields %}        segundo.{{ f.name }} = primero.{{ f.name }}{% if f.needs_clone %}.clone(){% endif %};
{% endfor %}
        // Actuar
        let resultado = crear(&pool, &segundo).await;

        // Comprobar
        assert_eq!(resultado.unwrap_err(), ErrorRepositorio::Duplicado);
        assert_eq!(contar(&pool, "SELECT COUNT(*) FROM {{ plural }}").await, 1);
        assert_eq!(contar(&pool, "SELECT COUNT(*) FROM outbox").await, 1);
    }
{% endfor %}{% for r in references %}

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_rechazar_{{ r.field }}_inexistente(pool: PgPool) {
        // Preparar: un valor de {{ r.field }} que no tiene ninguna fila.
        let mut entidad = construir({% if seeds_references %}&pool).await{% else %}){% endif %};
        entidad.{{ r.field }} = {% if r.optional %}Some({{ r.id }}::generar()){% else %}{{ r.id }}::generar(){% endif %};

        // Actuar
        let resultado = crear(&pool, &entidad).await;

        // Comprobar
        assert_eq!(resultado.unwrap_err(), ErrorRepositorio::ReferenciaInexistente("{{ r.field }}"));
        assert_eq!(contar(&pool, "SELECT COUNT(*) FROM outbox").await, 0);
    }
{% endfor %}}