puerto 0.21.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 std::collections::HashMap;
use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};

{% set refs = fields | filter(attribute="is_ref", value=true) %}use async_trait::async_trait;
use dominio_{{ snake }}::{
    modelo::{{ "{" }}{{ pascal }}, Id{{ pascal }}},
    repositorio::{% if refs %}{{ "{" }}Filtro{{ pascal }}, Repositorio{{ pascal }}}{% else %}Repositorio{{ pascal }}{% endif %},
};
use puerto_nucleo::{Pagina, PeticionPagina, ErrorRepositorio};

/// Guarda {{ plural }} en la memoria del proceso: se pierden cuando el proceso se para.
/// Como el adaptador de Postgres, oculta las filas borradas y lista primero las más recientes{% set uniques = fields | filter(attribute="unique", value=true) %}{% if uniques %};
/// un valor único que ya tiene otra fila viva es `Duplicado`{% endif %}.
/// Cubre el hueco hasta que haya base de datos (`puerto nuevo --db` genera repositorios Postgres).
#[derive(Default)]
pub struct Repositorio{{ pascal }}EnMemoria {
    filas: RwLock<HashMap<Id{{ pascal }}, {{ pascal }}>>,
}

impl Repositorio{{ pascal }}EnMemoria {
    pub fn new() -> Self {
        Self::default()
    }

    // Un cerrojo envenenado significa que un escritor hizo panic; cada escritura es un solo
    // insert, así que el mapa sigue entero y se usa tal cual.
    fn leer(&self) -> RwLockReadGuard<'_, HashMap<Id{{ pascal }}, {{ pascal }}>> {
        self.filas.read().unwrap_or_else(PoisonError::into_inner)
    }

    fn escribir(&self) -> RwLockWriteGuard<'_, HashMap<Id{{ pascal }}, {{ pascal }}>> {
        self.filas.write().unwrap_or_else(PoisonError::into_inner)
    }
}

#[async_trait]
impl Repositorio{{ pascal }} for Repositorio{{ pascal }}EnMemoria {
    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");
        let filas = self.leer();
        let mut vivos: Vec<&{{ pascal }}> = filas
            .values()
            .filter(|fila| !fila.borrado)
{% for r in refs %}            .filter(|fila| filtro.{{ r.name }}.is_none_or(|id| fila.{{ r.name }} == {% if r.field_type is starting_with("Option<") %}Some(id){% else %}id{% endif %}))
{% endfor %}            .collect();
        vivos.sort_by(|a, b| {
            b.creado_en
                .cmp(&a.creado_en)
                .then_with(|| a.id.valor().cmp(&b.id.valor()))
        });
        let total = vivos.len() as u64;
        let elementos = vivos
            .into_iter()
            .skip(pagina.desplazamiento() as usize)
            .take(pagina.limite() as usize)
            .cloned()
            .collect();
        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");
        Ok(self.leer().get(&id).filter(|fila| !fila.borrado).cloned())
    }

    async fn guardar(&self, entidad: &{{ pascal }}) -> Result<(), ErrorRepositorio> {
        tracing::debug!(id = %entidad.id, "guardar");
        let mut filas = self.escribir();
{% if uniques %}        // Como los índices únicos parciales: solo las filas vivas ocupan sus valores.
        let ocupado = !entidad.borrado
            && filas.values().any(|fila| {
                fila.id != entidad.id
                    && !fila.borrado
                    && {% if uniques | length > 1 %}({% endif %}{% for u in uniques %}{% if not loop.first %} || {% endif %}fila.{{ u.name }} == entidad.{{ u.name }}{% endfor %}{% if uniques | length > 1 %}){% endif %}
            });
        if ocupado {
            tracing::warn!(id = %entidad.id, "guardar rechazado: un valor único ya está ocupado");
            return Err(ErrorRepositorio::Duplicado);
        }
{% endif %}        filas.insert(entidad.id, entidad.clone());
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use dominio_{{ snake }}::modelo::Props{{ pascal }};
{% for import in test_imports %}    use {{ import }};
{% endfor %}
    fn nuevo_{{ snake }}() -> {{ pascal }} {
        {{ pascal }}::new(Props{{ pascal }} {
{% for f in fields %}            {{ f.name }}: {{ f.seed_literal }},
{% endfor %}        })
        .unwrap()
    }

    #[tokio::test]
    async fn deberia_encontrar_{{ snake }}_por_id_tras_guardar() {
        // Preparar
        let repositorio = Repositorio{{ pascal }}EnMemoria::new();
        let entidad = nuevo_{{ snake }}();
        repositorio.guardar(&entidad).await.unwrap();

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

        // Comprobar
        assert_eq!(encontrado.map(|fila| fila.id), Some(entidad.id));
    }

    #[tokio::test]
    async fn deberia_actualizar_la_fila_cuando_se_guarda_de_nuevo() {
        // Preparar
        let repositorio = Repositorio{{ pascal }}EnMemoria::new();
        let mut entidad = nuevo_{{ snake }}();
        repositorio.guardar(&entidad).await.unwrap();
        entidad.actualizado_en = chrono::Utc::now();

        // Actuar
        repositorio.guardar(&entidad).await.unwrap();

        // Comprobar
        let pagina = repositorio.buscar_todos(PeticionPagina::default(){% if refs %}, Filtro{{ pascal }}::default(){% endif %}).await.unwrap();
        assert_eq!(pagina.total, 1);
        assert_eq!(pagina.elementos[0].actualizado_en, entidad.actualizado_en);
    }

    #[tokio::test]
    async fn no_deberia_encontrar_{{ snake }}_tras_su_borrado() {
        // Preparar
        let repositorio = Repositorio{{ pascal }}EnMemoria::new();
        let mut entidad = nuevo_{{ snake }}();
        entidad.borrado = true;
        entidad.borrado_en = Some(entidad.actualizado_en);
        repositorio.guardar(&entidad).await.unwrap();

        // Actuar
        let encontrado = repositorio.buscar_por_id(entidad.id).await.unwrap();
        let pagina = repositorio.buscar_todos(PeticionPagina::default(){% if refs %}, Filtro{{ pascal }}::default(){% endif %}).await.unwrap();

        // Comprobar
        assert!(encontrado.is_none());
        assert_eq!(pagina.total, 0);
    }

    #[tokio::test]
    async fn deberia_devolver_la_pagina_pedida_de_una_lista_mayor() {
        // Preparar
        let repositorio = Repositorio{{ pascal }}EnMemoria::new();
        for _ in 0..3 {
            repositorio.guardar(&nuevo_{{ snake }}()).await.unwrap();
        }

        // Actuar
        let pagina = repositorio.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));
    }
{% for u in uniques %}
    #[tokio::test]
    async fn deberia_rechazar_un_duplicado_de_{{ u.name }}() {
        // Preparar
        let repositorio = Repositorio{{ pascal }}EnMemoria::new();
        let primero = nuevo_{{ snake }}();
        repositorio.guardar(&primero).await.unwrap();
        let mut segundo = nuevo_{{ snake }}();
        segundo.{{ u.name }} = primero.{{ u.name }}{% if u.needs_clone %}.clone(){% endif %};

        // Actuar
        let resultado = repositorio.guardar(&segundo).await;

        // Comprobar
        assert_eq!(resultado.unwrap_err(), ErrorRepositorio::Duplicado);
    }
{% endfor %}{% for r in refs %}
    #[tokio::test]
    async fn deberia_listar_solo_{{ plural }}_con_ese_valor_de_{{ r.name }}() {
        // Preparar: una entidad {{ snake }} con este valor de {{ r.name }} y otra sin él.
        let repositorio = Repositorio{{ pascal }}EnMemoria::new();
        let {{ r.name }} = Id{{ r.ref_target }}::generar();
        let mut esperado = nuevo_{{ snake }}();
        esperado.{{ r.name }} = {% if r.field_type is starting_with("Option<") %}Some({{ r.name }}){% else %}{{ r.name }}{% endif %};
        repositorio.guardar(&esperado).await.unwrap();
        repositorio.guardar(&nuevo_{{ snake }}()).await.unwrap();

        // Actuar
        let pagina = repositorio
            .buscar_todos(
                PeticionPagina::default(),
                Filtro{{ pascal }} {
{% for o in refs %}                    {{ o.name }}: {% if o.name == r.name %}Some({{ r.name }}){% 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 %}}