use std::{fs, path::Path};
pub const SNIPPETS_JSON: &str = r##"{
"Dominio — modelo.rs": {
"prefix": "domain-model",
"body": [
"use chrono::{DateTime, Utc};",
"use uuid::Uuid;",
"",
"use crate::errores::Error${1:Entidad};",
"",
"/// El id de `${1:Entidad}`: 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${1:Entidad}(Uuid);",
"",
"impl Id${1:Entidad} {",
"\tpub fn generar() -> Self {",
"\t\tSelf(Uuid::new_v4())",
"\t}",
"",
"\tpub fn from_uuid(valor: Uuid) -> Self {",
"\t\tSelf(valor)",
"\t}",
"",
"\tpub fn valor(&self) -> Uuid {",
"\t\tself.0",
"\t}",
"}",
"",
"impl std::fmt::Display for Id${1:Entidad} {",
"\tfn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {",
"\t\tself.0.fmt(f)",
"\t}",
"}",
"",
"#[derive(Debug, Clone)]",
"pub struct Props${1:Entidad} {",
"\tpub nombre: String,",
"\t$0",
"}",
"",
"#[derive(Debug, Clone)]",
"pub struct ${1:Entidad} {",
"\tpub id: Id${1:Entidad},",
"\tpub creado_en: DateTime<Utc>,",
"\tpub actualizado_en: DateTime<Utc>,",
"\tpub borrado: bool,",
"\tpub borrado_en: Option<DateTime<Utc>>,",
"\tpub nombre: String,",
"}",
"",
"impl ${1:Entidad} {",
"\tpub fn new(props: Props${1:Entidad}) -> Result<Self, Error${1:Entidad}> {",
"\t\tif props.nombre.trim().is_empty() {",
"\t\t\treturn Err(Error${1:Entidad}::Validacion(\"nombre_vacio\".into()));",
"\t\t}",
"\t\tlet ahora = Utc::now();",
"\t\tOk(Self {",
"\t\t\tid: Id${1:Entidad}::generar(),",
"\t\t\tcreado_en: ahora,",
"\t\t\tactualizado_en: ahora,",
"\t\t\tborrado: false,",
"\t\t\tborrado_en: None,",
"\t\t\tnombre: props.nombre,",
"\t\t})",
"\t}",
"",
"\tpub fn from_repositorio(datos: ${1:Entidad}) -> Self {",
"\t\tdatos",
"\t}",
"}"
],
"description": "Modelo del dominio: el newtype IdEntidad, PropsEntidad, la entidad, new(props) y from_repositorio()."
},
"Dominio — errores.rs": {
"prefix": "domain-errors",
"body": [
"use puerto_nucleo::ErrorRepositorio;",
"use thiserror::Error;",
"",
"#[derive(Debug, Error)]",
"pub enum Error${1:Entidad} {",
"\t#[error(\"${2:entidad}.validacion.{0}\")]",
"\tValidacion(String),",
"\t#[error(\"${2:entidad}.no_encontrado\")]",
"\tNoEncontrado,",
"\t#[error(\"${2:entidad}.duplicado\")]",
"\tDuplicado,",
"\t#[error(\"${2:entidad}.repositorio\")]",
"\tRepositorio,",
"\t#[error(\"${2:entidad}.desconocido\")]",
"\tDesconocido,",
"}",
"",
"impl From<ErrorRepositorio> for Error${1:Entidad} {",
"\tfn from(err: ErrorRepositorio) -> Self {",
"\t\tmatch err {",
"\t\t\tErrorRepositorio::Duplicado => Self::Duplicado,",
"\t\t\tErrorRepositorio::DatosInvalidos | ErrorRepositorio::NoDisponible => Self::Repositorio,",
"\t\t\t_ => Self::Repositorio,",
"\t\t}",
"\t}",
"}"
],
"description": "Enum de errores del dominio con códigos legibles por máquina + From<ErrorRepositorio>."
},
"Dominio — repositorio.rs: trait + doble": {
"prefix": "repository-trait",
"body": [
"use async_trait::async_trait;",
"use puerto_nucleo::{Pagina, PeticionPagina, ErrorRepositorio};",
"",
"use crate::modelo::{${1:Entidad}, Id${1:Entidad}};",
"",
"#[async_trait]",
"pub trait Repositorio${1:Entidad}: Send + Sync {",
"\tasync fn buscar_todos(&self, pagina: PeticionPagina) -> Result<Pagina<${1:Entidad}>, ErrorRepositorio>;",
"\tasync fn buscar_por_id(&self, id: Id${1:Entidad}) -> Result<Option<${1:Entidad}>, ErrorRepositorio>;",
"\tasync fn guardar(&self, entidad: &${1:Entidad}) -> Result<(), ErrorRepositorio>;",
"}",
"",
"#[cfg(any(test, feature = \"pruebas\"))]",
"pub mod dobles {",
"\tuse mockall::mock;",
"\tuse super::*;",
"",
"\tmock! {",
"\t\tpub Repositorio${1:Entidad} {}",
"",
"\t\t#[async_trait]",
"\t\timpl Repositorio${1:Entidad} for Repositorio${1:Entidad} {",
"\t\t\tasync fn buscar_todos(&self, pagina: PeticionPagina) -> Result<Pagina<${1:Entidad}>, ErrorRepositorio>;",
"\t\t\tasync fn buscar_por_id(&self, id: Id${1:Entidad}) -> Result<Option<${1:Entidad}>, ErrorRepositorio>;",
"\t\t\tasync fn guardar(&self, entidad: &${1:Entidad}) -> Result<(), ErrorRepositorio>;",
"\t\t}",
"\t}",
"}"
],
"description": "El trait del repositorio (buscar_todos, buscar_por_id, guardar), que devuelve ErrorRepositorio, + su doble de mockall en pub mod dobles. En un proyecto con eventos solo lee: quita guardar, las escrituras van por la unidad de trabajo (uow-write)."
},
"Aplicación — <accion>.rs: contrato": {
"prefix": "domain-use-case",
"body": [
"use async_trait::async_trait;",
"",
"use dominio_${1:entidad}::{errores::Error${2:Entidad}, modelo::${2:Entidad}};",
"",
"#[derive(Debug, Clone)]",
"pub struct Params${3:Accion}${2:Entidad} {",
"\tpub nombre: String,",
"\t$0",
"}",
"",
"#[async_trait]",
"pub trait ${3:Accion}${2:Entidad}: Send + Sync {",
"\tasync fn ejecutar(&self, params: Params${3:Accion}${2:Entidad}) -> Result<${2:Entidad}, Error${2:Entidad}>;",
"}",
"",
"#[cfg(any(test, feature = \"pruebas\"))]",
"pub mod dobles {",
"\tuse mockall::mock;",
"",
"\tuse super::*;",
"",
"\tmock! {",
"\t\tpub ${3:Accion}${2:Entidad} {}",
"",
"\t\t#[async_trait]",
"\t\timpl ${3:Accion}${2:Entidad} for ${3:Accion}${2:Entidad} {",
"\t\t\tasync fn ejecutar(&self, params: Params${3:Accion}${2:Entidad}) -> Result<${2:Entidad}, Error${2:Entidad}>;",
"\t\t}",
"\t}",
"}"
],
"description": "El contrato con el que empieza el fichero de un caso de uso en el crate de aplicación: struct Params + el trait del caso de uso + su doble de mockall en pub mod dobles (lo usan los tests de rutas y la exportación de la spec). La impl y sus tests siguen en el mismo fichero (app-use-case)."
},
"Aplicación — impl del caso de uso + tests": {
"prefix": "app-use-case",
"body": [
"use std::sync::Arc;",
"",
"use async_trait::async_trait;",
"",
"use dominio_${1:entidad}::{",
"\terrores::Error${2:Entidad},",
"\tmodelo::{${2:Entidad}, Props${2:Entidad}},",
"\trepositorio::Repositorio${2:Entidad},",
"};",
"",
"pub struct ${4:Accion}${2:Entidad}Impl {",
"\tpub repositorio: Arc<dyn Repositorio${2:Entidad}>,",
"}",
"",
"#[async_trait]",
"impl ${4:Accion}${2:Entidad} for ${4:Accion}${2:Entidad}Impl {",
"\tasync fn ejecutar(&self, params: Params${4:Accion}${2:Entidad}) -> Result<${2:Entidad}, Error${2:Entidad}> {",
"\t\ttracing::info!(\"${3:accion}: inicio\");",
"\t\tlet entidad = ${2:Entidad}::new(Props${2:Entidad} { nombre: params.nombre })",
"\t\t\t.inspect_err(|e| tracing::warn!(error = %e, \"${3:accion}: rechazado\"))?;",
"\t\tself.repositorio",
"\t\t\t.guardar(&entidad)",
"\t\t\t.await",
"\t\t\t.inspect_err(|e| tracing::error!(error = %e, \"${3:accion}: fallo del repositorio\"))?;",
"\t\ttracing::info!(id = %entidad.id, \"${3:accion}: fin\");",
"\t\tOk(entidad)",
"\t}",
"}",
"",
"#[cfg(test)]",
"mod tests {",
"\tuse super::*;",
"\tuse dominio_${1:entidad}::repositorio::dobles::MockRepositorio${2:Entidad};",
"",
"\t#[tokio::test]",
"\tasync fn deberia_crear_${1:entidad}_cuando_el_nombre_es_valido() {",
"\t\t// Preparar",
"\t\tlet mut repositorio_doble = MockRepositorio${2:Entidad}::new();",
"\t\trepositorio_doble.expect_guardar().returning(|_| Ok(()));",
"\t\tlet caso_de_uso = ${4:Accion}${2:Entidad}Impl {",
"\t\t\trepositorio: Arc::new(repositorio_doble),",
"\t\t};",
"",
"\t\t// Actuar",
"\t\tlet resultado = caso_de_uso",
"\t\t\t.ejecutar(Params${4:Accion}${2:Entidad} { nombre: \"example\".into() })",
"\t\t\t.await;",
"",
"\t\t// Comprobar",
"\t\tassert!(resultado.is_ok());",
"\t\tassert_eq!(resultado.unwrap().nombre, \"example\");",
"\t}",
"}"
],
"description": "Impl de un caso de uso: el repositorio inyectado, logs de inicio y fin con tracing + un test unitario."
},
"Test — camino de error del caso de uso": {
"prefix": "app-use-case-error-test",
"body": [
"#[tokio::test]",
"async fn deberia_devolver_error_de_repositorio_cuando_no_se_puede_guardar_${1:entidad}() {",
"\t// Preparar",
"\tlet mut repositorio_doble = MockRepositorio${2:Entidad}::new();",
"\trepositorio_doble",
"\t\t.expect_guardar()",
"\t\t.returning(|_| Err(puerto_nucleo::ErrorRepositorio::NoDisponible));",
"\tlet caso_de_uso = ${4:Accion}${2:Entidad}Impl {",
"\t\trepositorio: Arc::new(repositorio_doble),",
"\t};",
"",
"\t// Actuar",
"\tlet resultado = caso_de_uso",
"\t\t.ejecutar(Params${4:Accion}${2:Entidad} { nombre: \"example\".into() })",
"\t\t.await;",
"",
"\t// Comprobar",
"\tassert_eq!(resultado.unwrap_err().to_string(), \"${1:entidad}.repositorio\");",
"}"
],
"description": "Test del camino de fallo de un caso de uso: el repositorio doble falla y el código se propaga."
},
"Aplicación — escritura por la unidad de trabajo (eventos)": {
"prefix": "uow-write",
"body": [
"let fallido = |e: &ErrorRepositorio| tracing::error!(error = %e, \"${1:accion}: fallo del repositorio\");",
"let mut uow = self.uow_factory.begin().await.inspect_err(fallido)?;",
"uow.guardar(&entidad).await.inspect_err(fallido)?;",
"uow.registrar(Evento${2:Entidad}::${3:Actualizado}(Snapshot${2:Entidad}::from_entidad(&entidad)))",
"\t.await",
"\t.inspect_err(fallido)?;",
"uow.commit().await.inspect_err(fallido)?;"
],
"description": "Proyectos con eventos: escribir por la unidad de trabajo — begin, guardar, registrar el evento, commit. Soltarla sin commit la deshace."
},
"Aplicación — impl del caso de uso sobre la unidad de trabajo (eventos)": {
"prefix": "app-use-case-uow",
"body": [
"use std::sync::Arc;",
"",
"use async_trait::async_trait;",
"use puerto_nucleo::ErrorRepositorio;",
"",
"use dominio_${1:entidad}::{",
"\terrores::Error${2:Entidad},",
"\teventos::{Evento${2:Entidad}, Snapshot${2:Entidad}},",
"\tmodelo::${2:Entidad},",
"\trepositorio::Repositorio${2:Entidad},",
"\tunit_of_work::UnitOfWorkFactory${2:Entidad},",
"};",
"",
"pub struct ${4:Accion}${2:Entidad}Impl {",
"\tpub repositorio: Arc<dyn Repositorio${2:Entidad}>,",
"\tpub uow_factory: Arc<dyn UnitOfWorkFactory${2:Entidad}>,",
"}",
"",
"#[async_trait]",
"impl ${4:Accion}${2:Entidad} for ${4:Accion}${2:Entidad}Impl {",
"\tasync fn ejecutar(&self, params: Params${4:Accion}${2:Entidad}) -> Result<${2:Entidad}, Error${2:Entidad}> {",
"\t\ttracing::info!(id = %params.id, \"${3:accion}: inicio\");",
"\t\tlet fallido = |e: &ErrorRepositorio| tracing::error!(error = %e, \"${3:accion}: fallo del repositorio\");",
"\t\tlet mut entidad = self",
"\t\t\t.repositorio",
"\t\t\t.buscar_por_id(params.id)",
"\t\t\t.await",
"\t\t\t.inspect_err(fallido)?",
"\t\t\t.ok_or(Error${2:Entidad}::NoEncontrado)?;",
"\t\t$0",
"\t\tentidad.actualizado_en = chrono::Utc::now();",
"\t\tlet mut uow = self.uow_factory.begin().await.inspect_err(fallido)?;",
"\t\tuow.guardar(&entidad).await.inspect_err(fallido)?;",
"\t\tuow.registrar(Evento${2:Entidad}::${5:Publicado}(Snapshot${2:Entidad}::from_entidad(&entidad)))",
"\t\t\t.await",
"\t\t\t.inspect_err(fallido)?;",
"\t\tuow.commit().await.inspect_err(fallido)?;",
"\t\ttracing::info!(id = %entidad.id, \"${3:accion}: fin\");",
"\t\tOk(entidad)",
"\t}",
"}",
"",
"#[cfg(test)]",
"mod tests {",
"\tuse super::*;",
"\tuse dominio_${1:entidad}::{",
"\t\tmodelo::Id${2:Entidad}, repositorio::dobles::MockRepositorio${2:Entidad},",
"\t\tunit_of_work::dobles::UnitOfWorkFactoryGrabadora,",
"\t};",
"\tuse dominio_${1:entidad}::pruebas::madres::Madre${2:Entidad};",
"\tuse puerto_nucleo::EventoDominio;",
"",
"\t#[tokio::test]",
"\tasync fn deberia_registrar_${6:evento}_cuando_${1:entidad}_existe() {",
"\t\t// Preparar",
"\t\tlet entidad = Madre${2:Entidad}::aleatorio();",
"\t\tlet id = entidad.id;",
"\t\tlet mut repositorio_doble = MockRepositorio${2:Entidad}::new();",
"\t\trepositorio_doble.expect_buscar_por_id().returning(move |_| Ok(Some(entidad.clone())));",
"\t\tlet uow_factory = UnitOfWorkFactoryGrabadora::new();",
"\t\tlet caso_de_uso = ${4:Accion}${2:Entidad}Impl {",
"\t\t\trepositorio: Arc::new(repositorio_doble),",
"\t\t\tuow_factory: Arc::new(uow_factory.clone()),",
"\t\t};",
"",
"\t\t// Actuar",
"\t\tlet resultado = caso_de_uso.ejecutar(Params${4:Accion}${2:Entidad} { id }).await;",
"",
"\t\t// Comprobar",
"\t\tassert!(resultado.is_ok());",
"\t\tlet grabado = uow_factory.grabado();",
"\t\tassert!(grabado.confirmado);",
"\t\tassert_eq!(grabado.eventos.len(), 1);",
"\t\tassert_eq!(grabado.eventos[0].tipo_evento(), \"${6:evento}\");",
"\t}",
"",
"\t#[tokio::test]",
"\tasync fn deberia_devolver_no_encontrado_sin_registrar_nada_cuando_${1:entidad}_no_existe() {",
"\t\t// Preparar",
"\t\tlet mut repositorio_doble = MockRepositorio${2:Entidad}::new();",
"\t\trepositorio_doble.expect_buscar_por_id().returning(|_| Ok(None));",
"\t\tlet uow_factory = UnitOfWorkFactoryGrabadora::new();",
"\t\tlet caso_de_uso = ${4:Accion}${2:Entidad}Impl {",
"\t\t\trepositorio: Arc::new(repositorio_doble),",
"\t\t\tuow_factory: Arc::new(uow_factory.clone()),",
"\t\t};",
"",
"\t\t// Actuar",
"\t\tlet resultado = caso_de_uso",
"\t\t\t.ejecutar(Params${4:Accion}${2:Entidad} { id: Id${2:Entidad}::generar() })",
"\t\t\t.await;",
"",
"\t\t// Comprobar",
"\t\tassert_eq!(resultado.unwrap_err().to_string(), \"${1:entidad}.no_encontrado\");",
"\t\tassert!(uow_factory.grabado().eventos.is_empty());",
"\t}",
"}"
],
"description": "Proyectos con eventos: un caso de uso sobre una entidad que ya existe — lee por el repositorio, escribe por la unidad de trabajo y registra el evento; tests con UnitOfWorkFactoryGrabadora."
},
"Infraestructura — repositorio.rs (en memoria)": {
"prefix": "inmemory-repo",
"body": [
"use std::collections::HashMap;",
"use std::sync::{PoisonError, RwLock};",
"",
"use async_trait::async_trait;",
"use dominio_${1:entidad}::{",
"\tmodelo::{${2:Entidad}, Id${2:Entidad}},",
"\trepositorio::Repositorio${2:Entidad},",
"};",
"use puerto_nucleo::{Pagina, PeticionPagina, ErrorRepositorio};",
"",
"/// Guarda en la memoria del proceso lo que recibe: se pierde cuando el proceso se detiene.",
"#[derive(Default)]",
"pub struct Repositorio${2:Entidad}EnMemoria {",
"\tfilas: RwLock<HashMap<Id${2:Entidad}, ${2:Entidad}>>,",
"}",
"",
"impl Repositorio${2:Entidad}EnMemoria {",
"\tpub fn new() -> Self {",
"\t\tSelf::default()",
"\t}",
"}",
"",
"#[async_trait]",
"impl Repositorio${2:Entidad} for Repositorio${2:Entidad}EnMemoria {",
"\tasync fn buscar_todos(&self, pagina: PeticionPagina) -> Result<Pagina<${2:Entidad}>, ErrorRepositorio> {",
"\t\ttracing::debug!(limite = pagina.limite(), desplazamiento = pagina.desplazamiento(), \"buscar_todos\");",
"\t\tlet filas = self.filas.read().unwrap_or_else(PoisonError::into_inner);",
"\t\tlet mut vivos: Vec<&${2:Entidad}> = filas.values().filter(|fila| !fila.borrado).collect();",
"\t\tvivos.sort_by(|a, b| b.creado_en.cmp(&a.creado_en).then_with(|| a.id.valor().cmp(&b.id.valor())));",
"\t\tlet total = vivos.len() as u64;",
"\t\tlet elementos = vivos.into_iter().skip(pagina.desplazamiento() as usize).take(pagina.limite() as usize).cloned().collect();",
"\t\tOk(Pagina::new(elementos, total, pagina))",
"\t}",
"",
"\tasync fn buscar_por_id(&self, id: Id${2:Entidad}) -> Result<Option<${2:Entidad}>, ErrorRepositorio> {",
"\t\ttracing::debug!(%id, \"buscar_por_id\");",
"\t\tlet filas = self.filas.read().unwrap_or_else(PoisonError::into_inner);",
"\t\tOk(filas.get(&id).filter(|fila| !fila.borrado).cloned())",
"\t}",
"",
"\tasync fn guardar(&self, entidad: &${2:Entidad}) -> Result<(), ErrorRepositorio> {",
"\t\ttracing::debug!(id = %entidad.id, \"guardar\");",
"\t\tlet mut filas = self.filas.write().unwrap_or_else(PoisonError::into_inner);",
"\t\tfilas.insert(entidad.id, entidad.clone());",
"\t\tOk(())",
"\t}",
"}"
],
"description": "Adaptador de repositorio en memoria (el de por defecto sin --db): guarda las filas en un mapa, oculta las borradas y pagina de la más reciente a la más antigua."
},
"Infraestructura — fila.rs (la fila de la base de datos)": {
"prefix": "persistence-entity",
"body": [
"use chrono::{DateTime, Utc};",
"use serde::{Deserialize, Serialize};",
"use sqlx::FromRow;",
"use uuid::Uuid;",
"",
"use dominio_${1:entidad}::{errores::Error${2:Entidad}, modelo::{${2:Entidad}, Id${2:Entidad}}};",
"",
"#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]",
"pub struct Fila${2:Entidad} {",
"\tpub id: Uuid,",
"\tpub creado_en: DateTime<Utc>,",
"\tpub actualizado_en: DateTime<Utc>,",
"\tpub borrado: bool,",
"\tpub borrado_en: Option<DateTime<Utc>>,",
"\tpub nombre: String,",
"\t$0",
"}",
"",
"impl TryFrom<Fila${2:Entidad}> for ${2:Entidad} {",
"\ttype Error = Error${2:Entidad};",
"",
"\tfn try_from(fila: Fila${2:Entidad}) -> Result<Self, Self::Error> {",
"\t\tOk(Self::from_repositorio(${2:Entidad} {",
"\t\t\tid: Id${2:Entidad}::from_uuid(fila.id),",
"\t\t\tcreado_en: fila.creado_en,",
"\t\t\tactualizado_en: fila.actualizado_en,",
"\t\t\tborrado: fila.borrado,",
"\t\t\tborrado_en: fila.borrado_en,",
"\t\t\tnombre: fila.nombre,",
"\t\t}))",
"\t}",
"}",
"",
"impl From<&${2:Entidad}> for Fila${2:Entidad} {",
"\tfn from(entidad: &${2:Entidad}) -> Self {",
"\t\tSelf {",
"\t\t\tid: entidad.id.valor(),",
"\t\t\tcreado_en: entidad.creado_en,",
"\t\t\tactualizado_en: entidad.actualizado_en,",
"\t\t\tborrado: entidad.borrado,",
"\t\t\tborrado_en: entidad.borrado_en,",
"\t\t\tnombre: entidad.nombre.clone(),",
"\t\t}",
"\t}",
"}"
],
"description": "Struct de la fila (FromRow) + las conversiones TryFrom<FilaEntidad> y From<&Entidad>."
},
"Infraestructura — repositorio.rs (SQLx/Postgres)": {
"prefix": "persistence-repo",
"body": [
"use async_trait::async_trait;",
"use dominio_${1:entidad}::{",
"\tmodelo::{${2:Entidad}, Id${2:Entidad}},",
"\trepositorio::Repositorio${2:Entidad},",
"};",
"use puerto_nucleo::{Pagina, PeticionPagina, ErrorRepositorio};",
"use sqlx::PgPool;",
"",
"use crate::fila::Fila${2:Entidad};",
"use puerto_sqlx::mapear_error_sqlx;",
"",
"pub struct Repositorio${2:Entidad}Postgres {",
"\tpub pool: PgPool,",
"}",
"",
"impl Repositorio${2:Entidad}Postgres {",
"\tpub fn new(pool: PgPool) -> Self {",
"\t\tSelf { pool }",
"\t}",
"}",
"",
"/// Una fila que el dominio rechaza es un dato guardado que se ha estropeado: va al log y se devuelve como `DatosInvalidos`.",
"fn to_dominio(fila: Fila${2:Entidad}) -> Result<${2:Entidad}, ErrorRepositorio> {",
"\t${2:Entidad}::try_from(fila).map_err(|e| {",
"\t\ttracing::error!(error = %e, \"la fila guardada no es una entidad ${1:entidad} válida\");",
"\t\tErrorRepositorio::DatosInvalidos",
"\t})",
"}",
"",
"#[async_trait]",
"impl Repositorio${2:Entidad} for Repositorio${2:Entidad}Postgres {",
"\tasync fn buscar_todos(&self, pagina: PeticionPagina) -> Result<Pagina<${2:Entidad}>, ErrorRepositorio> {",
"\t\ttracing::debug!(limite = pagina.limite(), desplazamiento = pagina.desplazamiento(), \"buscar_todos\");",
"\t\tlet filas = sqlx::query_as!(",
"\t\t\tFila${2:Entidad},",
"\t\t\t\"SELECT id, creado_en, actualizado_en, borrado, borrado_en, nombre FROM ${1:entidad}s WHERE borrado = false ORDER BY creado_en DESC, id LIMIT \\$1 OFFSET \\$2\",",
"\t\t\ti64::from(pagina.limite()),",
"\t\t\ti64::from(pagina.desplazamiento())",
"\t\t)",
"\t\t.fetch_all(&self.pool)",
"\t\t.await",
"\t\t.map_err(|e| {",
"\t\t\ttracing::error!(error = %e, \"buscar_todos falló\");",
"\t\t\tmapear_error_sqlx(&e)",
"\t\t})?;",
"\t\tlet total = sqlx::query_scalar!(",
"\t\t\tr#\"SELECT COUNT(*) AS \"total!\" FROM ${1:entidad}s WHERE borrado = false\"#",
"\t\t)",
"\t\t.fetch_one(&self.pool)",
"\t\t.await",
"\t\t.map_err(|e| {",
"\t\t\ttracing::error!(error = %e, \"buscar_todos falló al contar\");",
"\t\t\tmapear_error_sqlx(&e)",
"\t\t})?;",
"\t\tlet elementos = filas.into_iter().map(to_dominio).collect::<Result<Vec<_>, _>>()?;",
"\t\tOk(Pagina::new(elementos, u64::try_from(total).unwrap_or_default(), pagina))",
"\t}",
"",
"\tasync fn buscar_por_id(&self, id: Id${2:Entidad}) -> Result<Option<${2:Entidad}>, ErrorRepositorio> {",
"\t\ttracing::debug!(%id, \"buscar_por_id\");",
"\t\tlet fila = sqlx::query_as!(",
"\t\t\tFila${2:Entidad},",
"\t\t\t\"SELECT id, creado_en, actualizado_en, borrado, borrado_en, nombre FROM ${1:entidad}s WHERE id = \\$1 AND borrado = false\",",
"\t\t\tid.valor()",
"\t\t)",
"\t\t.fetch_optional(&self.pool)",
"\t\t.await",
"\t\t.map_err(|e| {",
"\t\t\ttracing::error!(error = %e, \"buscar_por_id falló\");",
"\t\t\tmapear_error_sqlx(&e)",
"\t\t})?;",
"\t\tfila.map(to_dominio).transpose()",
"\t}",
"",
"\tasync fn guardar(&self, entidad: &${2:Entidad}) -> Result<(), ErrorRepositorio> {",
"\t\ttracing::debug!(id = %entidad.id, \"guardar\");",
"\t\tlet db = Fila${2:Entidad}::from(entidad);",
"\t\tsqlx::query!(",
"\t\t\t\"INSERT INTO ${1:entidad}s (id, creado_en, actualizado_en, borrado, borrado_en, nombre) VALUES (\\$1, \\$2, \\$3, \\$4, \\$5, \\$6) ON CONFLICT (id) DO UPDATE SET actualizado_en = \\$3, borrado = \\$4, borrado_en = \\$5, nombre = \\$6\",",
"\t\t\tdb.id, db.creado_en, db.actualizado_en, db.borrado, db.borrado_en, db.nombre",
"\t\t)",
"\t\t.execute(&self.pool)",
"\t\t.await",
"\t\t.map_err(|e| {",
"\t\t\ttracing::error!(error = %e, \"guardar falló\");",
"\t\t\tmapear_error_sqlx(&e)",
"\t\t})?;",
"\t\tOk(())",
"\t}",
"}",
"$0"
],
"description": "RepositorioEntidadPostgres: buscar_todos, buscar_por_id y guardar con las macros de SQLx, logs con tracing y los errores del driver por puerto_sqlx::mapear_error_sqlx."
},
"Presentación — dto.rs: DTO de respuesta": {
"prefix": "poem-dto",
"body": [
"use dominio_${1:entidad}::modelo::${2:Entidad};",
"use poem_openapi::Object;",
"use uuid::Uuid;",
"",
"#[derive(Debug, Object)]",
"#[oai(rename_all = \"camelCase\")]",
"pub struct Dto${2:Entidad} {",
"\tpub id: Uuid,",
"\tpub nombre: String,",
"\t$0",
"}",
"",
"impl Dto${2:Entidad} {",
"\tpub fn from_dominio(entidad: &${2:Entidad}) -> Self {",
"\t\tSelf {",
"\t\t\tid: entidad.id.valor(),",
"\t\t\tnombre: entidad.nombre.clone(),",
"\t\t}",
"\t}",
"}"
],
"description": "DTO de respuesta de OpenAPI (JSON en camelCase) con el mapeo from_dominio()."
},
"Presentación — dto.rs: DTO de petición": {
"prefix": "poem-request-dto",
"body": [
"#[derive(Debug, Object)]",
"#[oai(rename_all = \"camelCase\")]",
"pub struct Peticion${1:Accion}${2:Entidad} {",
"\tpub nombre: String,",
"\t$0",
"}"
],
"description": "Struct del DTO de petición de OpenAPI (JSON en camelCase)."
},
"Presentación — respuestas.rs: enum ApiResponse": {
"prefix": "poem-response-enum",
"body": [
"use poem::http::StatusCode;",
"use poem_openapi::{ApiResponse, payload::Json};",
"use puerto_web::RespuestaError;",
"",
"use crate::dto::Dto${2:Entidad};",
"",
"#[derive(ApiResponse)]",
"pub enum Respuesta${3:Accion}${2:Entidad} {",
"\t#[oai(status = ${4:201})]",
"\t${5:Creado}(Json<Dto${2:Entidad}>),",
"\t#[oai(status = 422)]",
"\tNoProcesable(Json<RespuestaError>),",
"\t#[oai(status = 404)]",
"\tNoEncontrado(Json<RespuestaError>),",
"\t#[oai(status = 409)]",
"\tConflicto(Json<RespuestaError>),",
"\t#[oai(status = 500)]",
"\tErrorInterno(Json<RespuestaError>),",
"}",
"",
"impl Respuesta${3:Accion}${2:Entidad} {",
"\tpub fn from_status(status: StatusCode, error: Json<RespuestaError>) -> Self {",
"\t\tmatch status {",
"\t\t\tStatusCode::UNPROCESSABLE_ENTITY => Self::NoProcesable(error),",
"\t\t\tStatusCode::NOT_FOUND => Self::NoEncontrado(error),",
"\t\t\tStatusCode::CONFLICT => Self::Conflicto(error),",
"\t\t\t_ => Self::ErrorInterno(error),",
"\t\t}",
"\t}",
"}"
],
"description": "Enum ApiResponse con el helper from_status() (201 Creado; 200 Ok para un endpoint de acción)."
},
"Presentación — errores.rs: el mapeo de errores": {
"prefix": "poem-error-mapper",
"body": [
"use dominio_${1:entidad}::errores::Error${2:Entidad};",
"use poem::http::StatusCode;",
"use poem_openapi::payload::Json;",
"use puerto_web::RespuestaError;",
"",
"",
"pub fn a_respuesta_error(err: Error${2:Entidad}) -> (StatusCode, Json<RespuestaError>) {",
"\tlet status = match &err {",
"\t\tError${2:Entidad}::Validacion(_) => StatusCode::UNPROCESSABLE_ENTITY,",
"\t\tError${2:Entidad}::NoEncontrado => StatusCode::NOT_FOUND,",
"\t\tError${2:Entidad}::Duplicado => StatusCode::CONFLICT,",
"\t\tError${2:Entidad}::Repositorio => StatusCode::INTERNAL_SERVER_ERROR,",
"\t\tError${2:Entidad}::Desconocido => StatusCode::INTERNAL_SERVER_ERROR,",
"\t};",
"\t(status, Json(RespuestaError::from_codigo(err.to_string())))",
"}"
],
"description": "El errores.rs del crate REST: una función libre, un mapeo de estados exhaustivo y el código de error en `codigo` (validación → 422)."
},
"Test — un brazo del mapeo de errores": {
"prefix": "poem-error-mapper-test",
"body": [
"#[test]",
"fn deberia_mapear_${1:no_encontrado}_a_${2:404}_con_su_codigo() {",
"\t// Actuar",
"\tlet (status, Json(cuerpo)) = a_respuesta_error(Error${3:Entidad}::${4:NoEncontrado});",
"",
"\t// Comprobar",
"\tassert_eq!(status, StatusCode::${5:NOT_FOUND});",
"\tassert_eq!(cuerpo.codigo, \"${6:entidad}.${1:no_encontrado}\");",
"}"
],
"description": "Un test por brazo del mapeo de errores: el estado y el código legible por máquina (ADR-0007)."
},
"Presentación — rutas.rs: struct Api + endpoint": {
"prefix": "poem-api-struct",
"body": [
"use std::sync::Arc;",
"",
"use aplicacion_${1:entidad}::${3:accion}::{Params${4:Accion}${2:Entidad}, ${4:Accion}${2:Entidad}};",
"use poem_openapi::{OpenApi, Tags, payload::Json};",
"",
"use crate::dto::{Peticion${4:Accion}${2:Entidad}, Dto${2:Entidad}};",
"use crate::errores::a_respuesta_error;",
"use crate::respuestas::Respuesta${4:Accion}${2:Entidad};",
"",
"#[derive(Tags)]",
"enum ApiTags {",
"\t${2:Entidad},",
"}",
"",
"pub struct Api${2:Entidad} {",
"\tpub ${3:accion}: Arc<dyn ${4:Accion}${2:Entidad}>,",
"}",
"",
"#[OpenApi]",
"impl Api${2:Entidad} {",
"\t/// ${4:Accion}: ${2:Entidad}",
"\t#[oai(path = \"/${1:entidad}s\", method = \"post\", tag = \"ApiTags::${2:Entidad}\")]",
"\tasync fn ${3:accion}(&self, cuerpo: Json<Peticion${4:Accion}${2:Entidad}>) -> Respuesta${4:Accion}${2:Entidad} {",
"\t\tmatch self.${3:accion}.ejecutar(Params${4:Accion}${2:Entidad} { nombre: cuerpo.nombre.clone() }).await {",
"\t\t\tOk(entidad) => Respuesta${4:Accion}${2:Entidad}::Creado(Json(Dto${2:Entidad}::from_dominio(&entidad))),",
"\t\t\tErr(err) => {",
"\t\t\t\tlet (status, error) = a_respuesta_error(err);",
"\t\t\t\ttracing::warn!(codigo = %error.0.codigo, \"${3:accion} falló\");",
"\t\t\t\tRespuesta${4:Accion}${2:Entidad}::from_status(status, error)",
"\t\t\t}",
"\t\t}",
"\t}",
"}"
],
"description": "Struct Api de Poem OpenAPI con el campo del caso de uso y un endpoint POST (con su tag; registra los fallos en el log)."
},
"Presentación — un handler de endpoint": {
"prefix": "poem-endpoint",
"body": [
"/// ${1:descripcion}",
"#[oai(path = \"/${2:entidad}s\", method = \"${3:post}\", tag = \"ApiTags::${6:Entidad}\")]",
"async fn ${4:accion}(&self, cuerpo: Json<Peticion${5:Accion}${6:Entidad}>) -> Respuesta${5:Accion}${6:Entidad} {",
"\tmatch self.${4:accion}.ejecutar(Params${5:Accion}${6:Entidad} { nombre: cuerpo.nombre.clone() }).await {",
"\t\tOk(entidad) => Respuesta${5:Accion}${6:Entidad}::Creado(Json(Dto${6:Entidad}::from_dominio(&entidad))),",
"\t\tErr(err) => {",
"\t\t\tlet (status, error) = a_respuesta_error(err);",
"\t\t\ttracing::warn!(codigo = %error.0.codigo, \"${4:accion} falló\");",
"\t\t\tRespuesta${5:Accion}${6:Entidad}::from_status(status, error)",
"\t\t}",
"\t}",
"}"
],
"description": "Handler de endpoint #[oai]: ejecutar → mapear la respuesta."
},
"Presentación — endpoint GET por id": {
"prefix": "poem-endpoint-get",
"body": [
"/// ${1:Entidad} por id",
"#[oai(path = \"/${2:entidad}s/:id\", method = \"get\", tag = \"ApiTags::${1:Entidad}\")]",
"async fn obtener(&self, id: Path<Uuid>) -> RespuestaObtener${1:Entidad} {",
"\tmatch self.obtener_${2:entidad}.ejecutar(ParamsObtener${1:Entidad} { id: Id${1:Entidad}::from_uuid(id.0) }).await {",
"\t\tOk(entidad) => RespuestaObtener${1:Entidad}::Ok(Json(Dto${1:Entidad}::from_dominio(&entidad))),",
"\t\tErr(err) => {",
"\t\t\tlet (status, error) = a_respuesta_error(err);",
"\t\t\ttracing::warn!(codigo = %error.0.codigo, \"obtener_${2:entidad} falló\");",
"\t\t\tRespuestaObtener${1:Entidad}::from_status(status, error)",
"\t\t}",
"\t}",
"}"
],
"description": "Endpoint GET /entidades/:id: Path<Uuid> → IdEntidad → 200 o el error mapeado."
},
"Presentación — endpoint de acción sobre una entidad": {
"prefix": "poem-endpoint-action",
"body": [
"/// ${1:Accion}: ${2:Entidad}",
"#[oai(path = \"/${3:entidades}/:id/${4:verbo}\", method = \"post\", tag = \"ApiTags::${2:Entidad}\")]",
"async fn ${5:accion}(&self, id: Path<Uuid>) -> Respuesta${1:Accion}${2:Entidad} {",
"\tmatch self",
"\t\t.${5:accion}",
"\t\t.ejecutar(Params${1:Accion}${2:Entidad} { id: Id${2:Entidad}::from_uuid(id.0) })",
"\t\t.await",
"\t{",
"\t\tOk(entidad) => Respuesta${1:Accion}${2:Entidad}::Ok(Json(Dto${2:Entidad}::from_dominio(&entidad))),",
"\t\tErr(err) => {",
"\t\t\tlet (status, error) = a_respuesta_error(err);",
"\t\t\ttracing::warn!(codigo = %error.0.codigo, \"${5:accion} falló\");",
"\t\t\tRespuesta${1:Accion}${2:Entidad}::from_status(status, error)",
"\t\t}",
"\t}",
"}"
],
"description": "POST /entidades/:id/<verbo> para un caso de uso propio: Path<Uuid> → IdEntidad → caso de uso → 200 o el error mapeado. Su enum de respuesta: poem-response-enum con estado 200 y la variante Ok."
},
"Test — test de ruta": {
"prefix": "poem-route-test",
"body": [
"#[tokio::test]",
"async fn deberia_responder_${1:200}_cuando_${2:entidad}_${3:se_publica}() {",
"\t// Preparar",
"\tlet mut dobles = Dobles::default();",
"\tdobles",
"\t\t.${4:accion}",
"\t\t.expect_ejecutar()",
"\t\t.returning(|_| Ok(Madre${5:Entidad}::aleatorio()));",
"",
"\t// Actuar",
"\tlet respuesta = dobles",
"\t\t.cliente()",
"\t\t.post(format!(\"/${6:entidades}/{}/${7:verbo}\", Uuid::new_v4()))",
"\t\t.send()",
"\t\t.await;",
"",
"\t// Comprobar",
"\trespuesta.assert_status(StatusCode::${8:OK});",
"}"
],
"description": "Test de ruta entre los tests de rutas.rs: TestClient sobre el OpenApiService real, un caso de uso doble (`dobles.<accion>`) y una comprobación del estado (ADR-0012)."
},
"Worker — brazo de un consumidor": {
"prefix": "consumer-arm",
"body": [
"${1:ENTIDAD}_${2:VERBO} => match evento.decodificar::<Snapshot${3:Entidad}>() {",
"\tOk(${4:entidad}) => {",
"\t\ttracing::info!(",
"\t\t\tid_evento = %evento.id,",
"\t\t\tid_${4:entidad} = %${4:entidad}.id,",
"\t\t\t\"${5:consumidor}: ${6:evento}\"",
"\t\t);",
"\t\t$0",
"\t\tResultadoManejo::Ack",
"\t}",
"\tErr(err) => ResultadoManejo::descartar(MOTIVO_PAYLOAD_INVALIDO, err.detalle),",
"},"
],
"description": "Un brazo del `match evento.tipo_evento` de un consumidor: decodifica el snapshot, actúa de forma idempotente (con evento.id como clave) y descarta un payload que no se decodifica."
},
"Test — bloque cfg(test)": {
"prefix": "cfg-test",
"body": [
"#[cfg(test)]",
"mod tests {",
"\tuse super::*;",
"",
"\t$0",
"}"
],
"description": "Módulo de tests con los imports habituales."
},
"Test — test asíncrono de tokio (AAA)": {
"prefix": "should-do-test",
"body": [
"#[tokio::test]",
"async fn deberia_${1:resultado}_cuando_${2:escenario}() {",
"\t// Preparar",
"\t$0",
"",
"\t// Actuar",
"",
"\t// Comprobar",
"}"
],
"description": "Test asíncrono de tokio con el patrón AAA y un nombre que describe el negocio."
},
"Test — madre (Object Mother)": {
"prefix": "object-mother",
"body": [
"use crate::modelo::{${2:Entidad}, Props${2:Entidad}};",
"",
"pub struct Madre${2:Entidad} {",
"\tnombre: Option<String>,",
"\t$0",
"}",
"",
"impl Madre${2:Entidad} {",
"\tpub fn new() -> Self {",
"\t\tSelf { nombre: None }",
"\t}",
"",
"\tpub fn con_nombre(mut self, nombre: &str) -> Self {",
"\t\tself.nombre = Some(nombre.to_string());",
"\t\tself",
"\t}",
"",
"\tpub fn con_nombre_vacio(mut self) -> Self {",
"\t\tself.nombre = Some(String::new());",
"\t\tself",
"\t}",
"",
"\tpub fn construir(self) -> ${2:Entidad} {",
"\t\t${2:Entidad}::new(self.construir_props()).expect(\"Madre${2:Entidad}: no se pudo construir una entidad ${2:Entidad} válida\")",
"\t}",
"",
"\tpub fn construir_props(self) -> Props${2:Entidad} {",
"\t\tProps${2:Entidad} {",
"\t\t\tnombre: self.nombre.unwrap_or_else(|| \"example\".to_string()),",
"\t\t}",
"\t}",
"",
"\tpub fn aleatorio() -> ${2:Entidad} {",
"\t\tSelf::new().construir()",
"\t}",
"",
"\tpub fn aleatorios(n: usize) -> Vec<${2:Entidad}> {",
"\t\t(0..n).map(|_| Self::aleatorio()).collect()",
"\t}",
"}",
"",
"impl Default for Madre${2:Entidad} {",
"\tfn default() -> Self {",
"\t\tSelf::new()",
"\t}",
"}"
],
"description": "Madre: new().con_<campo>().construir(), construir_props(), aleatorio(), aleatorios(n)."
},
"Test — test de integración con SQLx": {
"prefix": "sqlx-test",
"body": [
"#[sqlx::test(migrator = \"migrador::MIGRADOR\")]",
"async fn deberia_${1:resultado}_cuando_${2:escenario}(pool: PgPool) {",
"\t// Preparar",
"\tlet repositorio = Repositorio${3:Entidad}Postgres::new(pool.clone());",
"\t$0",
"",
"\t// Actuar",
"",
"\t// Comprobar",
"}"
],
"description": "Test de integración #[sqlx::test] contra un pool de Postgres real, migrado por el MIGRADOR compartido."
},
"Test — módulo de tests del repositorio con SQLx": {
"prefix": "sqlx-repo-test-module",
"body": [
"#[cfg(test)]",
"mod integration_tests {",
"\tuse super::*;",
"\tuse dominio_${1:entidad}::modelo::Props${2:Entidad};",
"",
"\tasync fn sembrar(pool: &PgPool, nombre: &str) -> ${2:Entidad} {",
"\t\tlet entidad = ${2:Entidad}::new(Props${2:Entidad} { nombre: nombre.to_string() }).unwrap();",
"\t\tRepositorio${2:Entidad}Postgres::new(pool.clone()).guardar(&entidad).await.unwrap();",
"\t\tentidad",
"\t}",
"",
"\t#[sqlx::test(migrator = \"migrador::MIGRADOR\")]",
"\tasync fn deberia_guardar_y_recuperar_por_id(pool: PgPool) {",
"\t\t// Preparar",
"\t\tlet entidad = sembrar(&pool, \"example\").await;",
"",
"\t\t// Actuar",
"\t\tlet encontrado = Repositorio${2:Entidad}Postgres::new(pool)",
"\t\t\t.buscar_por_id(entidad.id)",
"\t\t\t.await",
"\t\t\t.unwrap()",
"\t\t\t.unwrap();",
"",
"\t\t// Comprobar",
"\t\tassert_eq!(encontrado.id, entidad.id);",
"\t\tassert_eq!(encontrado.nombre, entidad.nombre);",
"\t}",
"",
"\t#[sqlx::test(migrator = \"migrador::MIGRADOR\")]",
"\tasync fn deberia_devolver_none_cuando_el_id_no_existe(pool: PgPool) {",
"\t\t// Actuar",
"\t\tlet resultado = Repositorio${2:Entidad}Postgres::new(pool)",
"\t\t\t.buscar_por_id(Id${2:Entidad}::generar())",
"\t\t\t.await",
"\t\t\t.unwrap();",
"",
"\t\t// Comprobar",
"\t\tassert!(resultado.is_none());",
"\t}",
"}"
],
"description": "Módulo #[cfg(test)] completo de tests de integración para RepositorioEntidadPostgres, con el helper sembrar."
},
"Dominio — valores.rs: objeto valor String": {
"prefix": "vo-string",
"body": [
"#[derive(Debug, Clone, PartialEq)]",
"pub struct ${1:Nombre} {",
"\tvalor: String,",
"}",
"",
"impl ${1:Nombre} {",
"\tpub fn new(valor: String) -> Result<Self, Error${2:Entidad}> {",
"\t\tlet recortado = valor.trim().to_string();",
"\t\tif recortado.is_empty() {",
"\t\t\treturn Err(Error${2:Entidad}::${1:Nombre}Invalido);",
"\t\t}",
"\t\tOk(Self { valor: recortado })",
"\t}",
"",
"\tpub fn valor(&self) -> &str {",
"\t\t&self.valor",
"\t}",
"}",
"$0"
],
"description": "Objeto valor String: campo privado, recorta y rechaza el vacío, valor() → &str."
},
"Dominio — valores.rs: objeto valor numérico": {
"prefix": "vo-numeric",
"body": [
"#[derive(Debug, Clone, Copy, PartialEq)]",
"pub struct ${1:Nombre}(${2:i64});",
"",
"impl ${1:Nombre} {",
"\tpub fn new(valor: ${2:i64}) -> Result<Self, Error${3:Entidad}> {",
"\t\tOk(Self(valor))",
"\t}",
"",
"\tpub fn valor(&self) -> ${2:i64} {",
"\t\tself.0",
"\t}",
"}",
"$0"
],
"description": "Objeto valor numérico (i64 / f64): struct tupla, new() que lo acepta tal cual, valor() por copia."
},
"Dominio — valores.rs: objeto valor enum": {
"prefix": "vo-enum",
"body": [
"#[derive(Debug, Clone, PartialEq)]",
"pub enum ${1:Nombre} {",
"\t${2:Variante1},",
"\t${3:Variante2},",
"\t$0",
"}",
"",
"impl std::str::FromStr for ${1:Nombre} {",
"\ttype Err = Error${4:Entidad};",
"",
"\tfn from_str(s: &str) -> Result<Self, Self::Err> {",
"\t\tmatch s {",
"\t\t\t\"${2:Variante1}\" => Ok(Self::${2:Variante1}),",
"\t\t\t\"${3:Variante2}\" => Ok(Self::${3:Variante2}),",
"\t\t\t_ => Err(Error${4:Entidad}::${1:Nombre}Invalido),",
"\t\t}",
"\t}",
"}",
"",
"impl ${1:Nombre} {",
"\tpub fn as_str(&self) -> &str {",
"\t\tmatch self {",
"\t\t\tSelf::${2:Variante1} => \"${2:Variante1}\",",
"\t\t\tSelf::${3:Variante2} => \"${3:Variante2}\",",
"\t\t}",
"\t}",
"}"
],
"description": "Objeto valor enum: FromStr (`s.parse::<Nombre>()`) para construirlo, as_str() para extraerlo."
},
"Aplicación — construir un Option<objeto valor>": {
"prefix": "vo-option-construct",
"body": [
"let ${1:campo} = params.${1:campo}.map(${2:ObjetoValor}::new).transpose()?;"
],
"description": "Construir Option<objeto valor> desde Option<primitivo>: map + transpose."
},
"Aplicación — construir un Vec<objeto valor>": {
"prefix": "vo-vec-construct",
"body": [
"let ${1:campo} = params.${1:campo}.into_iter().map(${2:ObjetoValor}::new).collect::<Result<Vec<_>, _>>()?;"
],
"description": "Construir Vec<objeto valor> desde Vec<primitivo>: map + collect a Result."
}
}"##;
pub const SQL_SNIPPETS_JSON: &str = r##"{
"Puerto — Crear tabla": {
"prefix": "migration-create-table",
"scope": "sql",
"body": [
"CREATE TABLE ${1:entidades} (",
" id UUID PRIMARY KEY,",
" nombre TEXT NOT NULL,",
" creado_en TIMESTAMPTZ NOT NULL DEFAULT NOW(),",
" actualizado_en TIMESTAMPTZ NOT NULL DEFAULT NOW(),",
" borrado BOOLEAN NOT NULL DEFAULT FALSE,",
" borrado_en TIMESTAMPTZ",
");",
"$0"
],
"description": "CREATE TABLE con las columnas estándar de Puerto (id, nombre, fechas, borrado lógico)."
},
"Puerto — Añadir columna": {
"prefix": "migration-add-column",
"scope": "sql",
"body": [
"ALTER TABLE ${1:entidades} ADD COLUMN ${2:nombre_columna} ${3:TEXT} NOT NULL${4: DEFAULT ''};",
"$0"
],
"description": "ALTER TABLE ADD COLUMN."
},
"Puerto — Índice único (parcial)": {
"prefix": "migration-unique-index",
"scope": "sql",
"body": [
"-- Parcial: una fila borrada no debe seguir ocupando su valor (ADR-0003).",
"CREATE UNIQUE INDEX ${1:entidades}_${2:columna}_key ON ${1:entidades} (${2:columna}) WHERE borrado = false;",
"$0"
],
"description": "Índice único parcial con nombre, que ignora las filas borradas."
},
"Puerto — Insertar": {
"prefix": "sql-insert",
"scope": "sql",
"body": [
"INSERT INTO ${1:entidades} (id, nombre, creado_en, actualizado_en, borrado, borrado_en)",
"VALUES (\\$1, \\$2, \\$3, \\$4, \\$5, \\$6)",
"ON CONFLICT (id) DO UPDATE",
" SET nombre = \\$2, actualizado_en = \\$4;",
"$0"
],
"description": "INSERT con las columnas estándar de Puerto + upsert."
},
"Puerto — Seleccionar filas vivas": {
"prefix": "sql-select-active",
"scope": "sql",
"body": [
"SELECT id, creado_en, actualizado_en, borrado, borrado_en, ${2:nombre}",
"FROM ${1:entidades}",
"WHERE borrado = false",
"ORDER BY creado_en DESC;",
"$0"
],
"description": "Selecciona las filas vivas (no borradas)."
},
"Puerto — Actualizar": {
"prefix": "sql-update",
"scope": "sql",
"body": [
"UPDATE ${1:entidades}",
"SET ${2:nombre} = \\$2, actualizado_en = NOW()",
"WHERE id = \\$1 AND borrado = false;",
"$0"
],
"description": "UPDATE con la guarda de borrado lógico de Puerto."
},
"Puerto — Borrado lógico": {
"prefix": "sql-soft-delete",
"scope": "sql",
"body": [
"UPDATE ${1:entidades}",
"SET borrado = true, borrado_en = NOW(), actualizado_en = NOW()",
"WHERE id = \\$1 AND borrado = false;",
"$0"
],
"description": "Borrado lógico por id: pone borrado = true y borrado_en."
}
}"##;
pub const WEB_TS_SNIPPETS_JSON: &str = r##"{
"Web — HTTP repository method": {
"prefix": "web-repo-method",
"body": [
"async ${1:method}(id) {",
"\tconst { data, error, response } = await api.${2:GET}(\"/${3:entities}/{id}\", {",
"\t\tparams: { path: { id } },",
"\t});",
"\tif (data === undefined) throw new ${4:Entity}Error(apiErrorCode(error, response));",
"\treturn to${4:Entity}(data);",
"},"
],
"description": "A method of the HTTP repository (infrastructure/<entity>/<entity>-repository-http.ts): an openapi-fetch call, the API's error code as the entity's Error. Declare it on the port (domain/<entity>/repository.ts) and the fake (test-support/<entity>.ts) too."
}
}"##;
pub const WEB_TSX_SNIPPETS_JSON: &str = r##"{
"Web — container + view": {
"prefix": "web-container",
"body": [
"import type { ${1:Entity} } from \"../../../../domain/${2:entity-name}/model\";",
"import { useDependencies } from \"../../../core/dependencies\";",
"import { useAsync } from \"../../../core/hooks/use-async\";",
"import { ErrorAlert } from \"../../../shared/ui/error-alert\";",
"",
"export function ${1:Entity}${3:Summary}Container({ id }: { id: string }) {",
"\tconst { ${4:entity}Repository } = useDependencies();",
"\tconst ${4:entity} = useAsync(() => ${4:entity}Repository.get(id), [${4:entity}Repository, id]);",
"",
"\treturn (",
"\t\t<section className=\"space-y-4\">",
"\t\t\t{${4:entity}.status === \"loading\" && <span className=\"loading loading-spinner\" />}",
"\t\t\t{${4:entity}.status === \"error\" && <ErrorAlert error={${4:entity}.error} />}",
"\t\t\t{${4:entity}.status === \"ok\" && <${1:Entity}${3:Summary}View ${4:entity}={${4:entity}.data} />}",
"\t\t</section>",
"\t);",
"}",
"",
"/** Props only. Move it to `views/` once it grows: containers load, views render. */",
"function ${1:Entity}${3:Summary}View({ ${4:entity} }: { ${4:entity}: ${1:Entity} }) {",
"\treturn <p>{${4:entity}.id}</p>;$0",
"}"
],
"description": "A container (features/<entity>/containers/): loads through useDependencies() + useAsync, renders loading / error / its view."
},
"Web — container test": {
"prefix": "web-container-test",
"body": [
"import { describe, expect, test } from \"bun:test\";",
"import { screen } from \"@testing-library/react\";",
"import { ${1:Entity}Mother, fake${1:Entity}Repository } from \"../../../../test-support/${2:entity-name}\";",
"import { renderScreen } from \"../../../../test-support/render\";",
"import { ${1:Entity}${3:Summary}Container } from \"./${2:entity-name}-${5:summary}-container\";",
"",
"describe(\"${1:Entity}${3:Summary}Container\", () => {",
"\ttest(\"should show the ${6:entity label} when it exists\", async () => {",
"\t\t// Arrange",
"\t\tconst seeded = ${1:Entity}Mother.random();",
"\t\tconst ${4:entity}Repository = fake${1:Entity}Repository([seeded]);",
"",
"\t\t// Act",
"\t\trenderScreen(<${1:Entity}${3:Summary}Container id={seeded.id} />, { ${4:entity}Repository });",
"",
"\t\t// Assert",
"\t\texpect(await screen.findByText(seeded.id)).toBeTruthy();",
"\t});",
"});"
],
"description": "A container test: render it with the in-memory fake repository, assert on what the user sees."
},
"Web — form field": {
"prefix": "web-form-field",
"body": [
"<label className=\"fieldset\">",
"\t<span className=\"fieldset-legend\">${1:Label}</span>",
"\t<input",
"\t\tclassName=\"input w-full\"",
"\t\ttype=\"${2:text}\"",
"\t\trequired",
"\t\taria-invalid={problem?.field === \"${3:field}\"}",
"\t\tvalue={values.${3:field}}",
"\t\tonChange={(event) => onChange({ ...values, ${3:field}: event.target.value })}",
"\t/>",
"</label>",
"<FieldError problem={problem} field=\"${3:field}\" />"
],
"description": "A daisyUI input bound to the form view's values (views/<entity>-form-view.tsx), and the API's message about it underneath; add the field to <Entity>FormValues and its two mappings."
},
"Web — route": {
"prefix": "web-route",
"body": [
"<Route key=\"${1:/entities/:id/summary}\" path=\"${1:/entities/:id/summary}\">",
"\t{(params) => <${2:Entity}${3:Summary}Container id={params.id} />}",
"</Route>,"
],
"description": "A route in customRoutes (presentation/core/routes.tsx — yours; core/generated/routes.tsx is rewritten)."
}
}"##;
fn write_file(path: &Path, content: &str) -> Result<(), std::io::Error> {
if let Some(parent) = path.parent() {
fs::create_dir_all(parent)?;
}
fs::write(path, content)
}
pub fn apply(base: &Path, ide: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
let write_zed = ide.is_none_or(|i| i == "zed");
let write_vscode = ide.is_none_or(|i| i == "vscode");
let web = base.join("web").is_dir();
if write_zed {
write_file(&base.join(".zed/snippets/rust.json"), SNIPPETS_JSON)?;
write_file(&base.join(".zed/snippets/sql.json"), SQL_SNIPPETS_JSON)?;
println!(
"✓ .zed/snippets/rust.json + sql.json (Zed — loaded automatically from project root)"
);
if web {
write_file(
&base.join(".zed/snippets/typescript.json"),
WEB_TS_SNIPPETS_JSON,
)?;
write_file(&base.join(".zed/snippets/tsx.json"), WEB_TSX_SNIPPETS_JSON)?;
println!("✓ .zed/snippets/typescript.json + tsx.json (the web/ frontend)");
}
}
if write_vscode {
write_file(&base.join(".vscode/puerto.code-snippets"), SNIPPETS_JSON)?;
write_file(
&base.join(".vscode/puerto.sql.code-snippets"),
SQL_SNIPPETS_JSON,
)?;
println!(
"✓ .vscode/puerto.code-snippets + puerto.sql.code-snippets (VS Code — loaded automatically)"
);
if web {
write_file(
&base.join(".vscode/puerto.ts.code-snippets"),
&vscode_web_snippets()?,
)?;
println!("✓ .vscode/puerto.ts.code-snippets (the web/ frontend)");
}
println!(
" nvim+LuaSnip: require(\"luasnip.loaders.from_vscode\").lazy_load({{ paths = {{ \"./.vscode\" }} }})"
);
}
Ok(())
}
fn vscode_web_snippets() -> Result<String, serde_json::Error> {
let mut all = serde_json::Map::new();
for (json, scope) in [
(WEB_TS_SNIPPETS_JSON, "typescript"),
(WEB_TSX_SNIPPETS_JSON, "typescriptreact"),
] {
let snippets: serde_json::Map<String, serde_json::Value> = serde_json::from_str(json)?;
for (name, mut snippet) in snippets {
snippet["scope"] = scope.into();
all.insert(name, snippet);
}
}
Ok(serde_json::to_string_pretty(&all)? + "\n")
}
pub fn run(base: &Path, ide: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
if let Some(i) = ide {
if !matches!(i, "zed" | "vscode") {
return Err(format!("unknown IDE '{i}' — supported values: zed, vscode").into());
}
}
apply(base, ide)
}