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.
//! Lo escribe una vez `puerto nuevo --auth`; desde entonces es tuyo. Todo el que llama con sesión
//! iniciada es una fila `Usuario` (ADR-0021 § 3 de Puerto): lo que referencian otras entidades
//! (`owner: IdUsuario`), sea cual sea el proveedor con el que inició sesión.

use chrono::{DateTime, Utc};
use uuid::Uuid;
{%- if local %}

use crate::errores::ErrorUsuario;

/// El emisor de las cuentas que guarda la propia API (`POST /auth/registro`).
pub const EMISOR_LOCAL: &str = "local";
{%- endif %}

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

impl IdUsuario {
    /// Un id nuevo y aleatorio, para un usuario 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: todo `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 IdUsuario {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

/// Quien inició sesión, tal como lo conoce este proyecto. `(emisor, sujeto)` es el nombre que da
/// el proveedor a la persona y es único; `email` y `name` son lo que dijo el proveedor la primera
/// vez.
#[derive(Debug, Clone, PartialEq)]
pub struct Usuario {
    pub id: IdUsuario,
    pub emisor: String,
    pub sujeto: String,
    pub email: Option<String>,
    pub nombre: Option<String>,
    /// No se lee en un proyecto OIDC: allí los roles vienen solo del token, para que decida un
    /// único sitio.
    pub roles: Vec<String>,
    pub creado_en: DateTime<Utc>,
    pub actualizado_en: DateTime<Utc>,
}

impl Usuario {
    /// El usuario que crea la primera petición de `(emisor, sujeto)` (alta just-in-time).
    pub fn aprovisionar(
        emisor: impl Into<String>,
        sujeto: impl Into<String>,
        email: Option<String>,
        nombre: Option<String>,
    ) -> Self {
        let ahora = Utc::now();
        Self {
            id: IdUsuario::generar(),
            emisor: emisor.into(),
            sujeto: sujeto.into(),
            email,
            nombre,
            roles: vec![],
            creado_en: ahora,
            actualizado_en: ahora,
        }
    }

{% if local %}    /// Una cuenta local nueva (`registrar_usuario`). Su sujeto es el email tal como lo escribe
    /// [`Usuario::sujeto_local`], así que `UNIQUE (emisor, sujeto)` hace único el email.
    pub fn registrar(email: &str, nombre: Option<String>) -> Result<Self, ErrorUsuario> {
        let email = Self::sujeto_local(email);
        if !es_email(&email) {
            return Err(ErrorUsuario::Validacion("email_invalido".into()));
        }
        let nombre = nombre
            .map(|n| n.trim().to_string())
            .filter(|n| !n.is_empty());
        Ok(Self::aprovisionar(EMISOR_LOCAL, email.clone(), Some(email), nombre))
    }

    /// Cómo se compara el email de una cuenta local: sin espacios alrededor y en minúsculas.
    pub fn sujeto_local(email: &str) -> String {
        email.trim().to_lowercase()
    }

{% endif %}    /// Reconstruye desde la persistencia, sin validar. SOLO lo usa la infraestructura.
    pub fn from_repositorio(datos: Usuario) -> Self {
        datos
    }
}

{% if local %}/// Una `@` entre un nombre no vacío y un dominio con punto, sin espacios. Si la dirección existe lo
/// averiguará un correo de confirmación, no esta comprobación.
fn es_email(email: &str) -> bool {
    let Some((nombre, domain)) = email.split_once('@') else {
        return false;
    };
    !nombre.is_empty()
        && !domain.contains('@')
        && domain.contains('.')
        && !domain.starts_with('.')
        && !domain.ends_with('.')
        && !email.chars().any(char::is_whitespace)
}

{% endif %}#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn deberia_guardar_lo_que_dijo_el_proveedor_cuando_se_da_de_alta() {
        // Actuar
        let usuario = Usuario::aprovisionar(
            "http://localhost:8180/realms/shop",
            "f81d4fae",
            Some("ada@example.com".into()),
            Some("Ada Lovelace".into()),
        );

        // Comprobar
        assert_eq!(usuario.emisor, "http://localhost:8180/realms/shop");
        assert_eq!(usuario.sujeto, "f81d4fae");
        assert_eq!(usuario.email.as_deref(), Some("ada@example.com"));
        assert_eq!(usuario.nombre.as_deref(), Some("Ada Lovelace"));
        assert!(usuario.roles.is_empty());
        assert_eq!(usuario.creado_en, usuario.actualizado_en);
    }

    #[test]
    fn deberia_recibir_un_id_nuevo_cuando_se_dan_de_alta_dos_usuarios() {
        // Actuar
        let ada = Usuario::aprovisionar("issuer", "ada", None, None);
        let bob = Usuario::aprovisionar("issuer", "bob", None, None);

        // Comprobar
        assert_ne!(ada.id, bob.id);
    }
{%- if local %}

    #[test]
    fn deberia_registrar_una_cuenta_local_con_su_email_en_minusculas() {
        // Actuar
        let usuario = Usuario::registrar("  Ada@Example.COM ", Some(" Ada ".into())).expect("cuenta válida");

        // Comprobar
        assert_eq!(usuario.emisor, EMISOR_LOCAL);
        assert_eq!(usuario.sujeto, "ada@example.com");
        assert_eq!(usuario.email.as_deref(), Some("ada@example.com"));
        assert_eq!(usuario.nombre.as_deref(), Some("Ada"));
        assert!(usuario.roles.is_empty());
    }

    #[test]
    fn no_deberia_guardar_nombre_cuando_esta_en_blanco() {
        let usuario = Usuario::registrar("ada@example.com", Some("  ".into())).expect("cuenta válida");
        assert_eq!(usuario.nombre, None);
    }

    #[test]
    fn deberia_rechazar_una_cuenta_cuando_el_email_no_es_valido() {
        for email in ["", "ada", "ada@", "@example.com", "ada@example", "a da@example.com", "a@b@c.com", "ada@.com"] {
            let err = Usuario::registrar(email, None).expect_err(email);
            assert_eq!(err.to_string(), "usuario.validacion.email_invalido", "{email}");
        }
    }
{%- endif %}
}