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