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 %}}