// 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)
);
}
}