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;
{% if has_map %}use sqlx::types::Json;
use std::collections::HashMap;
{% endif %}
{% set refs = fields | filter(attribute="is_ref", value=true) %}use dominio_{{ snake }}::{
    modelo::{{ "{" }}{{ pascal }}, Id{{ pascal }}},
    repositorio::{% if refs %}{{ "{" }}Filtro{{ pascal }}, Repositorio{{ pascal }}}{% else %}Repositorio{{ pascal }}{% endif %},
};
use puerto_nucleo::{Pagina, PeticionPagina, ErrorRepositorio};
{% if references and not events %}use puerto_sqlx::{ClaveForanea, mapear_error_sqlx, mapear_error_sqlx_con};
{% else %}use puerto_sqlx::mapear_error_sqlx;
{% endif %}
use crate::fila::Fila{{ pascal }};

pub struct Repositorio{{ pascal }}Postgres {
    pub pool: PgPool,
}

impl Repositorio{{ pascal }}Postgres {
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }
}
{% if references and not events %}{% include "infrastructure/references.tera" %}{% endif %}
/// Una fila como entidad del dominio. Una fila que el dominio rechaza es un dato guardado que se ha
/// estropeado, no culpa de quien llama: va al log con el motivo del dominio y se devuelve como
/// `DatosInvalidos`.
fn to_dominio(fila: Fila{{ pascal }}) -> Result<{{ pascal }}, ErrorRepositorio> {
    {{ pascal }}::try_from(fila).map_err(|e| {
        tracing::error!(error = %e, "la fila guardada no es una entidad {{ snake }} válida");
        ErrorRepositorio::DatosInvalidos
    })
}

#[async_trait]
impl Repositorio{{ pascal }} for Repositorio{{ pascal }}Postgres {
    async fn buscar_todos(&self, pagina: PeticionPagina{% if refs %}, filtro: Filtro{{ pascal }}{% endif %}) -> Result<Pagina<{{ pascal }}>, ErrorRepositorio> {
        tracing::debug!(limite = pagina.limite(), desplazamiento = pagina.desplazamiento(), "buscar_todos");
{% if refs %}        // Una sola consulta estática sea cual sea el filtro: un id sin valor es NULL y casa con
        // todas las filas.
{% for r in refs %}        let {{ r.name }} = filtro.{{ r.name }}.map(|id| id.valor());
{% endfor %}{% endif %}        let filas = sqlx::query_as!(
            Fila{{ pascal }},
            "SELECT {{ select_cols }}
             FROM {{ plural }} WHERE {{ page_where }}
             ORDER BY {{ order_by }} LIMIT $1 OFFSET $2",
            i64::from(pagina.limite()),
            i64::from(pagina.desplazamiento()){% for r in refs %},
            {{ r.name }}{% endfor %}
        )
        .fetch_all(&self.pool)
        .await
        .map_err(|e| {
            tracing::error!(error = %e, "buscar_todos falló");
            mapear_error_sqlx(&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, "falló el COUNT de buscar_todos");
            mapear_error_sqlx(&e)
        })?;

        let elementos = filas.into_iter().map(to_dominio).collect::<Result<Vec<_>, _>>()?;
        // COUNT(*) nunca es negativo.
        let total = u64::try_from(total).unwrap_or_default();
        Ok(Pagina::new(elementos, total, pagina))
    }

    async fn buscar_por_id(&self, id: Id{{ pascal }}) -> Result<Option<{{ pascal }}>, ErrorRepositorio> {
        tracing::debug!(%id, "buscar_por_id");
        let fila = sqlx::query_as!(
            Fila{{ pascal }},
            "SELECT {{ select_cols }}
             FROM {{ plural }} WHERE id = $1 AND borrado = false",
            id.valor()
        )
        .fetch_optional(&self.pool)
        .await
        .map_err(|e| {
            tracing::error!(error = %e, "buscar_por_id falló");
            mapear_error_sqlx(&e)
        })?;

        fila.map(to_dominio).transpose()
    }
{% if not events %}
    async fn guardar(&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.pool)
        .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(())
    }
{% endif %}}

#[cfg(test)]
mod pruebas_integracion {
    use super::*;
{% set uniques = fields | filter(attribute="unique", value=true) %}    use crate::pruebas::siembra::{{ "{" }}{% if refs or ((uniques or unique_groups) and not events) %}construir, {% endif %}sembrar{% if events %}, guardar{% endif %}};
{% if not events %}{% if update_vo_import %}    use {{ update_vo_import }};
{% endif %}{% for import in reference_imports %}    use {{ import }};
{% endfor %}{% endif %}
    fn repositorio_de_prueba(pool: PgPool) -> Repositorio{{ pascal }}Postgres {
        Repositorio{{ pascal }}Postgres::new(pool)
    }

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_guardar_y_recuperar_por_id(pool: PgPool) {
        // Preparar
        let entidad = sembrar(&pool).await;

        // Actuar
        let encontrado = repositorio_de_prueba(pool).buscar_por_id(entidad.id).await.unwrap().unwrap();

        // Comprobar
        assert_eq!(encontrado.id, entidad.id);
{% for f in fields %}        assert_eq!(encontrado.{{ f.name }}, entidad.{{ f.name }});
{% endfor %}        assert!(!encontrado.borrado);
    }

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_devolver_none_cuando_el_id_no_existe(pool: PgPool) {
        // Actuar
        let resultado = repositorio_de_prueba(pool).buscar_por_id(Id{{ pascal }}::generar()).await.unwrap();

        // Comprobar
        assert!(resultado.is_none());
    }

{% if not events %}    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_actualizar_la_entidad_al_guardar_un_id_existente(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 = sembrar(&pool).await;
        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
        repositorio_de_prueba(pool.clone()).guardar(&entidad).await.unwrap();

        // Comprobar
        let encontrado = repositorio_de_prueba(pool).buscar_por_id(entidad.id).await.unwrap().unwrap();
        assert_eq!(encontrado.{{ f.name }}{% if f.is_vo %}.valor(){% endif %}, "updated");
{% else %}        let entidad = sembrar(&pool).await;

        // Actuar
        repositorio_de_prueba(pool.clone()).guardar(&entidad).await.unwrap();

        // Comprobar
        let encontrado = repositorio_de_prueba(pool).buscar_por_id(entidad.id).await.unwrap();
        assert!(encontrado.is_some());
{% endif %}    }

{% endif %}    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_listar_{{ plural }}_sin_las_filas_borradas(pool: PgPool) {
        // Preparar
        sembrar(&pool).await;
        let mut borrado = sembrar(&pool).await;
        borrado.borrado = true;
        borrado.borrado_en = Some(borrado.actualizado_en);
        {% if events %}guardar(&pool, &borrado).await;{% else %}repositorio_de_prueba(pool.clone()).guardar(&borrado).await.unwrap();{% endif %}

        // Actuar
        let pagina = repositorio_de_prueba(pool).buscar_todos(PeticionPagina::default(){% if refs %}, Filtro{{ pascal }}::default(){% endif %}).await.unwrap();

        // Comprobar
        assert_eq!(pagina.elementos.len(), 1);
        assert_eq!(pagina.total, 1);
    }

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_devolver_la_pagina_pedida_de_una_lista_mayor(pool: PgPool) {
        // Preparar
        for _ in 0..3 {
            sembrar(&pool).await;
        }

        // Actuar
        let pagina = repositorio_de_prueba(pool)
            .buscar_todos(PeticionPagina::new(Some(2), Some(2)){% if refs %}, Filtro{{ pascal }}::default(){% endif %})
            .await
            .unwrap();

        // Comprobar
        assert_eq!(pagina.elementos.len(), 1);
        assert_eq!(pagina.total, 3);
        assert_eq!((pagina.limite, pagina.desplazamiento), (2, 2));
    }
{% set uniques = fields | filter(attribute="unique", value=true) %}{% if uniques and not events %}{% set u = uniques.0 %}

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_rechazar_un_duplicado_de_{{ u.name }}(pool: PgPool) {
        // Preparar
        let primero = sembrar(&pool).await;
        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 = repositorio_de_prueba(pool).guardar(&segundo).await;

        // Comprobar
        assert_eq!(resultado.unwrap_err(), ErrorRepositorio::Duplicado);
    }
{% endif %}{% if not events %}{% for g in unique_groups %}

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_rechazar_un_duplicado_de_{{ g.suffix }}(pool: PgPool) {
        // Preparar
        let primero = sembrar(&pool).await;
        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 = repositorio_de_prueba(pool).guardar(&segundo).await;

        // Comprobar
        assert_eq!(resultado.unwrap_err(), ErrorRepositorio::Duplicado);
    }
{% 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 = repositorio_de_prueba(pool).guardar(&entidad).await;

        // Comprobar
        assert_eq!(resultado.unwrap_err(), ErrorRepositorio::ReferenciaInexistente("{{ r.field }}"));
    }
{% endfor %}{% endif %}{% for r in refs %}

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_listar_solo_{{ plural }}_con_ese_valor_de_{{ r.name }}(pool: PgPool) {
        // Preparar: una entidad {{ snake }} con este valor de {{ r.name }} y otra sin él.
        let destino = infra_{{ r.ref_target_snake }}::pruebas::siembra::sembrar(&pool).await;
        let mut esperado = construir({% if seeds_references %}&pool).await{% else %}){% endif %};
        esperado.{{ r.name }} = {% if r.field_type is starting_with("Option<") %}Some(destino.id){% else %}destino.id{% endif %};
        {% if events %}guardar(&pool, &esperado).await;{% else %}repositorio_de_prueba(pool.clone()).guardar(&esperado).await.unwrap();{% endif %}
        sembrar(&pool).await;

        // Actuar
        let pagina = repositorio_de_prueba(pool)
            .buscar_todos(
                PeticionPagina::default(),
                Filtro{{ pascal }} {
{% for o in refs %}                    {{ o.name }}: {% if o.name == r.name %}Some(destino.id){% else %}None{% endif %},
{% endfor %}                },
            )
            .await
            .unwrap();

        // Comprobar
        assert_eq!(pagina.elementos.iter().map(|fila| fila.id).collect::<Vec<_>>(), vec![esperado.id]);
        assert_eq!(pagina.total, 1);
    }
{% endfor %}}