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 chrono::{DateTime, Utc};
use uuid::Uuid;{% for import in imports %}
use {{ import }};{% endfor %}

use crate::errores::Error{{ pascal }};

/// El id de cada `{{ pascal }}`: un `Uuid` que no se puede pasar donde se espera el id de otra
/// entidad.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Id{{ pascal }}(Uuid);

impl Id{{ pascal }} {
    /// Un id nuevo y aleatorio — para una entidad que se está creando.
    pub fn generar() -> Self {
        Self(Uuid::new_v4())
    }

    /// Un id leído de fuera (un parámetro de ruta, una fila) — sin validar: cualquier `Uuid` es un
    /// id.
    pub fn from_uuid(valor: Uuid) -> Self {
        Self(valor)
    }

    pub fn valor(&self) -> Uuid {
        self.0
    }
}

impl std::fmt::Display for Id{{ pascal }} {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

#[derive(Debug, Clone)]
pub struct Props{{ pascal }} {
{% for f in fields %}    pub {{ f.name }}: {{ f.rust_type }},
{% endfor %}}

#[derive(Debug, Clone)]
pub struct {{ pascal }} {
    pub id: Id{{ pascal }},
    pub creado_en: DateTime<Utc>,
    pub actualizado_en: DateTime<Utc>,
    pub borrado: bool,
    pub borrado_en: Option<DateTime<Utc>>,
{% for f in fields %}    pub {{ f.name }}: {{ f.rust_type }},
{% endfor %}}

impl {{ pascal }} {
    pub fn new(props: Props{{ pascal }}) -> Result<Self, Error{{ pascal }}> {
        Self::validar(&props)?;
        let ahora = chrono::Utc::now();
        Ok(Self {
            id: Id{{ pascal }}::generar(),
            creado_en: ahora,
            actualizado_en: ahora,
            borrado: false,
            borrado_en: None,
{% for f in fields %}            {{ f.name }}: props.{{ f.name }},
{% endfor %}        })
    }

    /// Cambia los campos propios, con las mismas reglas que `new`.
    pub fn actualizar(&mut self, props: Props{{ pascal }}) -> Result<(), Error{{ pascal }}> {
        Self::validar(&props)?;
{% for f in fields %}        self.{{ f.name }} = props.{{ f.name }};
{% endfor %}        self.actualizado_en = chrono::Utc::now();
        Ok(())
    }

    pub fn from_repositorio(datos: {{ pascal }}) -> Self {
        datos
    }

    /// Las reglas de los campos propios: las comprueban `new` y `actualizar`, así que una regla nueva
    /// se escribe solo aquí.
    fn validar({% if fields | filter(attribute="required_string", value=true) %}props{% else %}_props{% endif %}: &Props{{ pascal }}) -> Result<(), Error{{ pascal }}> {
{% for f in fields | filter(attribute="required_string", value=true) %}        if props.{{ f.name }}.trim().is_empty() {
            return Err(Error{{ pascal }}::Validacion("{{ f.name }}_vacio".into()));
        }
{% endfor %}        Ok(())
    }
}
{% set required = fields | filter(attribute="required_string", value=true) %}{% set string_vos = fields | filter(attribute="string_vo", value=true) %}{% set enum_vos = fields | filter(attribute="is_enum_vo", value=true) %}
#[cfg(test)]
mod tests {
    use super::*;
    use crate::pruebas::madres::Madre{{ pascal }};

    #[test]
    fn deberia_crear_{{ snake }}_cuando_{% if fields | length == 1 and required | length == 1 and fields.0.name == "nombre" %}el_nombre_es_valido{% else %}los_campos_son_validos{% endif %}() {
        let resultado = {{ pascal }}::new(Madre{{ pascal }}::new().construir_props());{% if required | length > 0 %}
        assert_eq!(
            resultado.unwrap().{{ required.0.name }},
            Madre{{ pascal }}::new().construir_props().{{ required.0.name }}
        );{% else %}
        assert!(resultado.is_ok());{% endif %}
    }{% if required or string_vos or enum_vos %}
{% endif %}{% for sf in required %}

    #[test]
    fn deberia_rechazar_{{ snake }}_cuando_{{ sf.name }}_es_una_cadena_vacia() {
        let resultado = {{ pascal }}::new(Madre{{ pascal }}::new().con_{{ sf.name }}_vacio().construir_props());
        assert!(resultado.is_err());
        assert_eq!(
            resultado.unwrap_err().to_string(),
            "{{ snake }}.validacion.{{ sf.name }}_vacio"
        );
    }

    #[test]
    fn deberia_rechazar_{{ snake }}_cuando_{{ sf.name }}_solo_tiene_espacios() {
        let resultado = {{ pascal }}::new(Madre{{ pascal }}::new().con_{{ sf.name }}("   ").construir_props());
        assert!(resultado.is_err());
    }{% endfor %}{% if required %}

    #[test]
    fn deberia_rechazar_actualizar_{{ snake }}_cuando_{{ required.0.name }}_es_una_cadena_vacia() {
        let mut entidad = Madre{{ pascal }}::aleatorio();
        let resultado = entidad.actualizar(Madre{{ pascal }}::new().con_{{ required.0.name }}_vacio().construir_props());
        assert_eq!(
            resultado.unwrap_err().to_string(),
            "{{ snake }}.validacion.{{ required.0.name }}_vacio"
        );
    }{% endif %}{% for f in string_vos %}

    #[test]
    fn deberia_rechazar_{{ snake }}_cuando_{{ f.vo_snake }}_es_una_cadena_vacia() {
        let resultado = {{ f.vo }}::new("".to_string());
        assert!(resultado.is_err());
        assert_eq!(
            resultado.unwrap_err().to_string(),
            "{% if f.is_shared_vo %}nucleo.{{ f.vo_snake }}_invalido{% else %}{{ snake }}.{{ f.vo_snake }}_invalido{% endif %}"
        );
    }{% endfor %}{% for f in enum_vos %}

    #[test]
    fn deberia_rechazar_{{ snake }}_cuando_{{ f.vo_snake }}_no_es_una_variante_conocida() {
        let resultado = "VarianteInvalida".parse::<{{ f.vo }}>();
        assert!(resultado.is_err());
        assert_eq!(
            resultado.unwrap_err().to_string(),
            "{% if f.is_shared_vo %}nucleo.{{ f.vo_snake }}_invalido{% else %}{{ snake }}.{{ f.vo_snake }}_invalido{% endif %}"
        );
    }{% endfor %}
}