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 async_trait::async_trait;
use chrono::{DateTime, Utc};
use sqlx::PgPool;
use uuid::Uuid;

use dominio_usuario::{
    modelo::{Usuario, IdUsuario},
    repositorio::RepositorioUsuario,
};
use puerto_nucleo::ErrorRepositorio;

use puerto_sqlx::mapear_error_sqlx;

/// Consultas comprobadas en tiempo de ejecución (`query_as`, no `query_as!`): `puerto nuevo`
/// escribe este fichero antes de que haya una base de datos de la que sacar la caché de consultas,
/// y el proyecto compila sin conexión.
pub struct RepositorioUsuarioPostgres {
    pub pool: PgPool,
}

impl RepositorioUsuarioPostgres {
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }
}

#[derive(sqlx::FromRow)]
struct FilaUsuario {
    id: Uuid,
    emisor: String,
    sujeto: String,
    email: Option<String>,
    nombre: Option<String>,
    roles: Vec<String>,
    creado_en: DateTime<Utc>,
    actualizado_en: DateTime<Utc>,
}

impl From<FilaUsuario> for Usuario {
    fn from(fila: FilaUsuario) -> Self {
        Usuario::from_repositorio(Usuario {
            id: IdUsuario::from_uuid(fila.id),
            emisor: fila.emisor,
            sujeto: fila.sujeto,
            email: fila.email,
            nombre: fila.nombre,
            roles: fila.roles,
            creado_en: fila.creado_en,
            actualizado_en: fila.actualizado_en,
        })
    }
}

const COLUMNAS: &str = "id, emisor, sujeto, email, nombre, roles, creado_en, actualizado_en";

#[async_trait]
impl RepositorioUsuario for RepositorioUsuarioPostgres {
    async fn buscar_por_sujeto(
        &self,
        emisor: &str,
        sujeto: &str,
    ) -> Result<Option<Usuario>, ErrorRepositorio> {
        let fila = sqlx::query_as::<_, FilaUsuario>(&format!(
            "SELECT {COLUMNAS} FROM usuarios WHERE emisor = $1 AND sujeto = $2"
        ))
        .bind(emisor)
        .bind(sujeto)
        .fetch_optional(&self.pool)
        .await
        .map_err(|e| {
            tracing::error!(error = %e, "find_by_subject falló");
            mapear_error_sqlx(&e)
        })?;
        Ok(fila.map(Usuario::from))
    }

    async fn buscar_por_id(&self, id: IdUsuario) -> Result<Option<Usuario>, ErrorRepositorio> {
        tracing::debug!(%id, "buscar_por_id");
        let fila = sqlx::query_as::<_, FilaUsuario>(&format!("SELECT {COLUMNAS} FROM usuarios WHERE id = $1"))
            .bind(id.valor())
            .fetch_optional(&self.pool)
            .await
            .map_err(|e| {
                tracing::error!(error = %e, "buscar_por_id falló");
                mapear_error_sqlx(&e)
            })?;
        Ok(fila.map(Usuario::from))
    }

    async fn guardar(&self, usuario: &Usuario) -> Result<(), ErrorRepositorio> {
        tracing::debug!(id = %usuario.id, "guardar");
        sqlx::query(
            "INSERT INTO usuarios (id, emisor, sujeto, email, nombre, roles, creado_en, actualizado_en)
             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
             ON CONFLICT (id) DO UPDATE SET
                 email = EXCLUDED.email,
                 nombre = EXCLUDED.nombre,
                 roles = EXCLUDED.roles,
                 actualizado_en = EXCLUDED.actualizado_en",
        )
        .bind(usuario.id.valor())
        .bind(&usuario.emisor)
        .bind(&usuario.sujeto)
        .bind(&usuario.email)
        .bind(&usuario.nombre)
        .bind(&usuario.roles)
        .bind(usuario.creado_en)
        .bind(usuario.actualizado_en)
        .execute(&self.pool)
        .await
        .map_err(|e| {
            tracing::error!(error = %e, "guardar falló");
            mapear_error_sqlx(&e)
        })?;
        Ok(())
    }
}

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

    fn ada() -> Usuario {
        Usuario::aprovisionar("emisor", "ada", Some("ada@example.com".into()), None)
    }

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_encontrar_un_usuario_guardado_cuando_se_busca_por_sujeto_o_por_id(pool: PgPool) {
        // Preparar
        let repositorio = RepositorioUsuarioPostgres::new(pool);
        let usuario = ada();
        repositorio.guardar(&usuario).await.expect("guardado");

        // Actuar
        let por_sujeto = repositorio
            .buscar_por_sujeto("emisor", "ada")
            .await
            .expect("leído");
        let por_id = repositorio.buscar_por_id(usuario.id).await.expect("leído");

        // Comprobar
        assert_eq!(por_sujeto.map(|u| u.id), Some(usuario.id));
        assert_eq!(por_id.map(|u| u.sujeto), Some("ada".to_string()));
    }

    #[sqlx::test(migrator = "migrador::MIGRADOR")]
    async fn deberia_rechazar_un_segundo_usuario_cuando_el_sujeto_esta_ocupado(pool: PgPool) {
        // Preparar
        let repositorio = RepositorioUsuarioPostgres::new(pool);
        repositorio.guardar(&ada()).await.expect("guardado");

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

        // Comprobar
        assert_eq!(resultado, Err(ErrorRepositorio::Duplicado));
    }
}