puerto 0.23.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.
// GENERADO por puerto desde puerto.toml — no lo edites a mano. El snapshot sigue los campos de la
// entidad; añade un evento con `puerto generar evento {{ pascal }} <nombre>`.
use puerto_nucleo::EventoDominio;
use serde::{Deserialize, Serialize};
use uuid::Uuid;{% for import in imports %}
use {{ import }};{% endfor %}

use crate::modelo::{{ pascal }};
{% for e in events %}
pub const {{ e.constant }}: &str = "{{ e.event_type }}";{% endfor %}

/// Lo que lleva cada evento de {{ snake }}: sus datos tal como los muestra la API — primitivos, con
/// los objetos valor desenvueltos. Un contrato público: los consumidores lo decodifican con
/// `evento.decodificar::<Snapshot{{ pascal }}>()`.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Snapshot{{ pascal }} {
    pub id: Uuid,
{% for f in fields %}    pub {{ f.name }}: {{ f.field_type }},
{% endfor %}}

impl Snapshot{{ pascal }} {
    pub fn from_entidad(entidad: &{{ pascal }}) -> Self {
        Self {
            id: entidad.id.valor(),
{% for f in fields %}            {{ f.name }}: {{ f.accessor }},
{% endfor %}        }
    }
}

/// Lo que le pasa a cada {{ snake }}. Sus casos de uso de escritura registran uno con su unidad de
/// trabajo.
#[derive(Debug, Clone, PartialEq)]
pub enum Evento{{ pascal }} {
{% for e in events %}    {{ e.variant }}(Snapshot{{ pascal }}),
{% endfor %}}

impl Evento{{ pascal }} {
    pub fn snapshot(&self) -> &Snapshot{{ pascal }} {
        match self {
            {% for e in events %}Self::{{ e.variant }}(snapshot){% if not loop.last %} | {% endif %}{% endfor %} => snapshot,
        }
    }
}

impl EventoDominio for Evento{{ pascal }} {
    fn tipo_evento(&self) -> &'static str {
        match self {
{% for e in events %}            Self::{{ e.variant }}(_) => {{ e.constant }},
{% endfor %}        }
    }

    fn tipo_agregado(&self) -> &'static str {
        "{{ snake }}"
    }

    fn id_agregado(&self) -> Uuid {
        self.snapshot().id
    }

    fn version_esquema(&self) -> u16 {
        1
    }

    fn payload(&self) -> serde_json::Value {
        // Un snapshot solo tiene primitivos: serializarlo no puede fallar.
        serde_json::to_value(self.snapshot()).unwrap_or_default()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::pruebas::madres::Madre{{ pascal }};

    #[test]
    fn deberia_describir_cada_evento_cuando_se_registra() {
        // Preparar
        let entidad = Madre{{ pascal }}::aleatorio();
        let snapshot = Snapshot{{ pascal }}::from_entidad(&entidad);
        let eventos = [
{% for e in events %}            (Evento{{ pascal }}::{{ e.variant }}(snapshot.clone()), "{{ e.event_type }}"),
{% endfor %}        ];

        for (evento, tipo_evento) in eventos {
            // Actuar y comprobar
            assert_eq!(evento.tipo_evento(), tipo_evento);
            assert_eq!(evento.tipo_agregado(), "{{ snake }}");
            assert_eq!(evento.id_agregado(), entidad.id.valor());
            assert_eq!(evento.version_esquema(), 1);
            assert_eq!(evento.snapshot(), &snapshot);
        }
    }

    #[test]
    fn deberia_mantener_el_contrato_json_cuando_se_serializa_el_snapshot() {
        // Preparar
        let snapshot = Snapshot{{ pascal }}::from_entidad(&Madre{{ pascal }}::aleatorio());

        // Actuar
        let payload = Evento{{ pascal }}::{{ events.0.variant }}(snapshot.clone()).payload();

        // Comprobar — una clave renombrada o quitada rompe a cada consumidor de estos eventos.
        let mut claves: Vec<&str> = payload
            .as_object()
            .map(|object| object.keys().map(String::as_str).collect())
            .unwrap_or_default();
        claves.sort_unstable();
        assert_eq!(claves, [{% for key in json_keys %}"{{ key }}"{% if not loop.last %}, {% endif %}{% endfor %}]);
        assert_eq!(
            serde_json::from_value::<Snapshot{{ pascal }}>(payload).ok(),
            Some(snapshot)
        );
    }
}