JAFSJosé Antonio Fuentes Santiago

DDD en un apocalipsis zombi. Parte 3

06-03-2026

En la primera parte establecimos los cimientos: el lenguaje ubicuo que hace que la líder del grupo y el desarrollador hablen el mismo idioma, los Bounded Contexts para que Sanidad, Logística y Comando no se pisen entre sí, y los Agregados que actúan como guardián en la puerta del refugio. En la segunda parte conectamos ese núcleo con el exterior: Servicios de Dominio para lógica que involucra a varios actores, Repositorios que mantienen el dominio ajeno a la base de datos, la capa de Aplicación como directora de orquesta y los Eventos de Dominio que permiten que todo el sistema reaccione sin dependencias directas.

Pero hay tres preguntas que todavía están en el aire: ¿qué pasa cuando una sola transacción no basta para coordinar una evacuación completa? ¿Cuáles son los errores más graves que puedes cometer implementando DDD, y cómo los evitas? ¿Y cómo pruebas que todas esas piezas funcionan de verdad antes de que llegue la horda?

En esta tercera entrega veremos: consistencia y Sagas, los antipatrones que más daño hacen en producción, y testing del dominio.

Centro de mando coordinando la evacuación

1. Consistencia, transacciones y Sagas

Hasta ahora hemos conocido operaciones que afectan a un solo agregado: admitir un superviviente, añadir suministros, calcular riesgos de contagio. Operaciones limpias y acotadas. Pero en medio del apocalipsis zombi rara vez tenemos el lujo de mantener las cosas simples. ¿Qué pasa cuando una horda rodea el Refugio A y hay que mover a todos sus supervivientes al Refugio B mientras los suministros se redistribuyen entre varios puntos? ¿Qué pasa cuando una sola transacción no basta para coordinar todo eso?

La regla de oro: un agregado = una transacción

Los agregados definen límites transaccionales. Cuando modificas un agregado, todos los cambios dentro de él se hacen de forma atómica (todo o nada). Pero esta garantía solo aplica dentro de un agregado.

Pensemos en el caso más sencillo: mover un superviviente del Refugio A al Refugio B. La operación involucra dos agregados:

  1. Refugio A debe "hacer salir" al superviviente
  2. Refugio B debe "admitirlo"

Aunque técnicamente podrías envolver ambos en una misma transacción de base de datos si comparten infraestructura (y de hecho veremos cuándo puede tener sentido hacerlo), llevarlo a cabo introduce un acoplamiento entre agregados que DDD recomienda evitar. Y si los refugios están en servicios distribuidos distintos, directamente no hay transacción que los cubra a los dos. De todas formas, recordad que hay veces que nos podemos saltar las normas siempre con cuidado, si no, provocaremos una serie de catastróficas desdichas que nos llevarán a ser rodeados por una horda.

NOTA EN LA CABAÑA

Recordemos que cada agregado es dueño de su propio estado y no debería necesitar al otro para confirmar sus cambios. Si los metes en la misma transacción, los estás atando: si uno falla, arrastra al otro. Y eso es exactamente lo que queríamos evitar cuando les pusimos una frontera.

Solución 1: Transacciones locales simples

Cuando la operación es simple y los agregados comparten base de datos, puedes usar una transacción local con cuidado:

async transferSurvivor(
  fromShelterId: string,
  toShelterId: string,
  survivorId: string
): Promise<void> {
  await db.transaction(async (trx) => {
    // Cargar ambos agregados dentro de la misma transacción
    const fromShelter = await repo.findById(fromShelterId, trx);
    const toShelter = await repo.findById(toShelterId, trx);

    // Operaciones del dominio: las reglas se siguen aplicando
    const survivor = fromShelter.removeSurvivor(survivorId);
    toShelter.admit(survivor);

    // Si algo falla, la transacción revierte ambos cambios
    await repo.save(fromShelter, trx);
    await repo.save(toShelter, trx);
  });
}

Esto introduce un acoplamiento que quizás no deseamos. Pero, funciona bien cuando la operación es rápida y los dos refugios están en la misma base de datos. Si no, necesitas algo más robusto.

Solución 2: Sagas / Process Managers

Las Sagas son el mecanismo para operaciones largas o distribuidas. La idea es sencilla: en lugar de una gran transacción que lo envuelva todo, usamos una secuencia de transacciones pequeñas coordinadas mediante eventos. Y si algo falla en el camino, las compensaciones intentan corregir el estado para que el sistema siga siendo coherente.

En cuanto a dónde vive en el código: la Saga es una clase de la capa de aplicación, igual que los handlers de comandos que vimos en la segunda parte. La diferencia es que un handler gestiona una operación puntual, mientras que la Saga orquesta un proceso que puede durar minutos u horas y atravesar varios agregados. No contiene reglas de negocio —eso sigue siendo responsabilidad del dominio— sino que decide qué comando enviar a continuación en función de los eventos que recibe.

Imagina la evacuación del Refugio A: los zombis han superado el perímetro exterior y hay que mover a todo el mundo al Refugio B antes de que sea demasiado tarde. El proceso tiene varios pasos:

  1. Verificar capacidad en Refugio B (consulta, no modifica nada)
  2. Marcar Refugio A como "en evacuación" → emite EvacuacionIniciada
  3. Por cada superviviente:
    • Reservar plaza en Refugio B → emite PlazaReservada
    • Retirar al superviviente de A → emite SupervivienteRetirado
    • Admitir en B → emite SupervivienteAdmitido
    • Si B no tiene plaza → compensación: cancelar la evacuación (PlazaNoDisponible)
  4. Transferir suministros críticos
  5. Marcar Refugio A como "evacuado" → emite RefugioEvacuado
sequenceDiagram
    participant A as Refugio A
    participant Saga as Saga / Process Manager
    participant B as Refugio B

    A->>Saga: EvacuacionIniciada

    Note over A,B: Superviviente 1 — transferencia exitosa
    Saga->>B: ReservarPlaza
    B->>Saga: PlazaReservada ✅
    Saga->>A: RetirarSuperviviente
    A->>Saga: SupervivienteRetirado
    Saga->>B: AdmitirSuperviviente
    B->>Saga: SupervivienteAdmitido ✅

    Note over A,B: Superviviente 2 — transferencia exitosa
    Saga->>B: ReservarPlaza
    B->>Saga: PlazaReservada ✅
    Saga->>A: RetirarSuperviviente
    A->>Saga: SupervivienteRetirado
    Saga->>B: AdmitirSuperviviente
    B->>Saga: SupervivienteAdmitido ✅

    Note over A,B: Superviviente 3 — Refugio B lleno
    Saga->>B: ReservarPlaza
    B->>Saga: PlazaNoDisponible ❌
    Saga->>A: Compensación: CancelarEvacuacion
    Note over A,B: Evacuación cancelada. Supervivientes 1 y 2 ya están en B.

Cada paso es una transacción local en un único agregado. La Saga suele mantener su propio estado —qué supervivientes se han transferido, en qué fase está la evacuación— para poder decidir el siguiente paso del proceso. Escucha los eventos y reacciona con el comando correspondiente. Cuando el Refugio B no puede reservar más plaza, la evacuación se cancela: los supervivientes ya transferidos se quedan en B y el resto permanece en A. No hay vuelta atrás para los que ya cruzaron el páramo, pero el sistema queda en un estado coherente y conocido.

Mapa táctico mostrando dos refugios conectados por una ruta de evacuación

¿Cuándo usar cada opción?

  • Transacción local simple: dos agregados en la misma base de datos, operación rápida.
  • Sagas: operación larga, múltiples agregados, sistemas distribuidos o necesidad de compensaciones ante fallos parciales.

Y una cosa importante: DDD no siempre garantiza consistencia inmediata global. A veces el sistema tarda un momento en llegar a un estado consistente, y eso está bien. Se llama consistencia eventual. Imagina que el sistema esperase confirmación de todos los refugios antes de iniciar la evacuación. Mientras tanto, los zombis están cruzando el perímetro. En sistemas reales —y en apocalipsis reales— la consistencia eventual es un precio razonable por mantener el sistema operativo.

2. Antipatrones y errores comunes

Como todo en ingeniería de software, DDD se puede hacer mal. Muy mal. Y lo peor es que estos errores no explotan de forma inmediata: se van acumulando hasta que el sistema es tan difícil de cambiar que cualquier pequeña modificación provoca efectos inesperados en cadena. Exactamente lo que menos quieres cuando tienes una horda a las puertas.

Refugio caótico

Los antipatrones serían el símil a que haya supervivientes accediendo directamente al almacén sin pasar por el guardia, con la puerta de acceso completamente ignorada y suministros esparcidos por el suelo.

A. Modelo anémico: el zombi del código

El nombre lo dice todo. Un modelo anémico tiene aspecto de clase con lógica de negocio, pero por dentro está vacío: solo getters, setters y ninguna regla que proteger.

// ❌ MAL: Modelo anémico
class Shelter {
  public id: string;
  public capacity: number;
  public currentCount: number;
  public survivors: Survivor[] = [];

  public getSurvivors() { return this.survivors; }
  public setSurvivors(s: Survivor[]) { this.survivors = s; }
  public getCurrentCount() { return this.currentCount; }
  public setCurrentCount(n: number) { this.currentCount = n; }
}

// Toda la lógica vive en un servicio aparte
class ShelterService {
  admitSurvivor(shelter: Shelter, survivor: Survivor) {
    // ¿Y si alguien llama a setSurvivors() directamente sin pasar por aquí?
    if (shelter.getCurrentCount() + 1 > shelter.capacity) {
      throw new Error("Refugio lleno");
    }
    shelter.getSurvivors().push(survivor);
    shelter.setCurrentCount(shelter.getCurrentCount() + 1);
  }
}

El problema no es solo estético. Con setSurvivors() público, cualquier parte del código puede saltarse la validación de capacidad. Alguien añade supervivientes directamente al array, el refugio queda sobresaturado y en el apocalipsis eso puede significar un brote de infección.

La confusión habitual es: "si para transferir suministros entre dos refugios necesito un Servicio de Dominio, ¿no acabo igual de anémico?". No, porque la diferencia está en qué hace el servicio. Si llama a métodos con lógica de negocio, el dominio está sano. Si modifica el estado directamente saltándose esas reglas, el dominio es anémico aunque los métodos tengan nombres bonitos.

// ✅ BIEN: El agregado protege sus invariantes
class Shelter {
  // No existe setSurvivors(). En su lugar:
  public admit(survivor: Survivor): void {
    if (this.currentCount + 1 > this.capacity) {
      throw new DomainError("Refugio lleno: no podemos admitir más supervivientes");
    }
    this.survivors.push(survivor);
    this.currentCount++;
  }

  // No existe setSupplies(). En su lugar:
  public receiveSupplies(supply: Supply): void {
    if (this.isStorageFull()) {
      throw new DomainError("Almacén lleno");
    }
    // Los Value Objects son inmutables: si existe el suministro, creamos uno nuevo con la suma
    const idx = this.supplies.findIndex(s => s.name === supply.name);
    if (idx >= 0) {
      this.supplies[idx] = new Supply(supply.name, this.supplies[idx].amount + supply.amount);
    } else {
      this.supplies.push(supply);
    }
  }

  public sendSupplies(supply: Supply): void {
    const idx = this.supplies.findIndex(s => s.name === supply.name);
    if (idx < 0 || this.supplies[idx].amount < supply.amount) {
      throw new DomainError(`Suministros insuficientes: ${supply.name}`);
    }
    // Value Object inmutable: reemplazamos con la cantidad reducida
    this.supplies[idx] = new Supply(supply.name, this.supplies[idx].amount - supply.amount);
  }
}

// El Servicio de Dominio coordina agregados LLAMANDO a sus métodos, nunca con setters:
class SupplyTransferService {
  public static transfer(supply: Supply, from: Shelter, to: Shelter): void {
    from.sendSupplies(supply);   // ← El origen aplica sus reglas
    to.receiveSupplies(supply);  // ← El destino aplica las suyas
  }
}

El test rápido para saber si tienes dominio anémico: ¿podrías reemplazar receiveSupplies() por setSupplies(newList) sin perder ninguna regla de negocio? Si la respuesta es sí, el agregado está vacío por dentro.

B. Agregados gigantes: el refugio que contiene el mundo entero

El exceso contrario: un único agregado que acumula todo el dominio. Cuanto más crece, más lento se vuelve cargarlo y más probable es que un cambio en un área rompa algo en otra completamente distinta.

// ❌ MAL: Un solo agregado para gobernarlos a todos
class Shelter {
  private survivors: Survivor[];
  private supplies: Supply[];
  private medicalRecords: MedicalRecord[];
  private securityLogs: SecurityLog[];
  private weatherConditions: WeatherData[];
  private nearbyThreats: Zombie[];
  private alliances: Alliance[];
  private historicalEvents: Event[];
  // ... y 20 colecciones más
}

Cada vez que alguien modifica el Shelter, carga toda esa información de base de datos, aunque solo necesite cambiar el nivel de suministros. Los conflictos de concurrencia se multiplican porque cada operación bloquea más datos de los necesarios. Y cuando el médico quiere añadir un campo al historial médico, rompe los tests del módulo de logística porque comparten la misma clase.

Solución: divide en agregados con responsabilidades claras: Refugio (capacidad, ocupación), HistorialMedico (pacientes, tratamientos), SistemaSeguridad (alertas, logs). Cada uno con sus propias invariantes.

C. Bounded Contexts como estructura de carpetas

Un error sutil y muy común: crear carpetas con nombres de contexto pero compartir el mismo modelo de datos entre todas ellas.

/contexts
  /logistics
    LogisticsService.ts  // Usa la clase Survivor global
  /medical
    MedicalService.ts    // Usa la MISMA clase Survivor global
  /command
    CommandService.ts    // Usa la MISMA clase Survivor global

Si Logística, Sanidad y Comando comparten la clase Survivor con 50 propiedades, cualquier cambio que necesite uno afecta a los otros dos. No hay aislamiento real: es acoplamiento disfrazado de organización.

Solución: cada contexto tiene su propio modelo de Survivor con solo las propiedades que le interesan, y se comunican mediante contratos bien definidos (eventos, DTOs, APIs).

D. Persistir el agregado tal cual

Mezclar decoradores de ORM directamente en las clases de dominio es la forma más rápida de que el dominio acabe dependiendo de la infraestructura, justo lo contrario de lo que queremos.

// ❌ MAL: El dominio huele a base de datos
class Shelter {
  @Column()
  public id: string;

  @OneToMany(() => Survivor)
  public survivors: Survivor[];
}

Si mañana cambias de ORM, o decides guardar los supervivientes en una colección de MongoDB en lugar de una tabla SQL, tienes que tocar el dominio. Y testear el dominio requiere levantar la base de datos.

Solución: el agregado es puro. El repositorio (en infraestructura) sabe cómo mapear entre el estado del agregado y lo que necesita la base de datos. En la siguiente entrega veremos exactamente cómo hacer ese mapeo sin comprometer esa pureza, con el patrón Snapshot.

E. DDD en aplicaciones CRUD simples

Aplicar todo el arsenal (agregados, bounded contexts, eventos, sagas) a una aplicación que básicamente crea, lee, actualiza y borra registros es un error que tiene consecuencias inmediatas y duraderas: el equipo tarda el doble en entregar cualquier cosa, el código es diez veces más complejo de lo necesario y la gente aprende a odiar DDD para siempre.

Si tu sistema es un formulario conectado a una base de datos sin reglas de negocio complejas, un CRUD bien hecho es la solución correcta. DDD brilla cuando hay complejidad de dominio, no complejidad técnica.

3. Pruebas: testear comportamiento, no implementación

Aquí está una de las recompensas silenciosas de haber hecho bien todo lo anterior: el dominio puro es extraordinariamente fácil de testear.

Piénsalo como el ejercicio de revisión que hace el médico del refugio antes de que llegue la siguiente horda. No espera a que los zombis entren para comprobar si el sistema de cuarentena funciona. Lo prueba en condiciones controladas, sin presión, y si algo falla lo arregla antes de que sea demasiado tarde. Eso son los tests unitarios del dominio: condiciones controladas, sin base de datos, sin servicios externos, sin excusas.

Superviviente verificando metódicamente las cerraduras, alarmas y capacidad del refugio

Testea invariantes, no detalles de persistencia

Las invariantes (las reglas que nunca pueden romperse) son el corazón de tus tests. No importa si usas SQL o un cuaderno lleno de barro, eso es responsabilidad de los tests de integración. En el dominio, testea que las reglas de negocio se cumplan.

import { describe, test, expect } from "vitest"; // o jest, o lo que uses

describe("Refugio - Gestión de capacidad", () => {
  test("debería admitir supervivientes si hay capacidad", () => {
    // Arrange (preparar)
    const shelter = new Shelter("refugio-1", 3);
    const survivor = new Survivor("1", "Ana", 100);

    // Act (actuar)
    shelter.admit(survivor);

    // Assert (verificar)
    expect(shelter.getSurvivors()).toHaveLength(1);
    expect(shelter.getSurvivors()[0].name).toBe("Ana");
  });

  test("debería rechazar admisión si el refugio está lleno", () => {
    // Arrange
    const shelter = new Shelter("refugio-1", 2);
    shelter.admit(new Survivor("1", "Ana", 100));
    shelter.admit(new Survivor("2", "Borja", 100));

    // Act & Assert: la invariante debe protegernos
    expect(() => {
      shelter.admit(new Survivor("3", "Carmen", 100));
    }).toThrow("Refugio lleno: no podemos admitir más supervivientes");
  });

  test("debería consolidar suministros del mismo tipo", () => {
    // Arrange
    const shelter = new Shelter("refugio-1", 5);

    // Act
    shelter.receiveSupplies(new Supply("vendas", 10));
    shelter.receiveSupplies(new Supply("antibióticos", 5));
    shelter.receiveSupplies(new Supply("vendas", 7)); // Mismo tipo que el primero

    // Assert
    const supplies = shelter.getSupplies();
    expect(supplies).toHaveLength(2); // No 3: las vendas se consolidaron
    const vendas = supplies.find(s => s.name === "vendas");
    expect(vendas?.amount).toBe(17); // 10 + 7
  });
});

describe("InfectionSpreadService - Cálculo de riesgo", () => {
  const service = new InfectionSpreadService();

  test("debería calcular alto riesgo con poca distancia y mucho tiempo", () => {
    const risk = service.chanceOfInfection(2, 120);
    expect(risk).toBeGreaterThan(0.8); // Más del 80% de riesgo: Luis está perdido
  });

  test("debería calcular riesgo cero fuera del rango de contagio", () => {
    const risk = service.chanceOfInfection(25, 30);
    expect(risk).toBe(0); // A 25 metros no hay peligro
  });
});

Ventajas de testear el dominio puro

  1. Tests rápidos: sin base de datos, sin APIs externas. Tests unitarios puros que corren en milisegundos.
  2. Tests claros: cada test verifica una regla de negocio concreta. Si falla, sabes exactamente qué invariante se rompió.
  3. Refactoring seguro: puedes cambiar la implementación interna del agregado sin tocar los tests, mientras las invariantes se mantengan.
  4. Documentación viva: leyendo los tests, cualquiera entiende qué se puede y qué no se puede hacer en el dominio.

Tests de repositorios (integración)

Para los repositorios sí necesitas tests de integración, porque interactúan con infraestructura real:

describe("PostgreSQLShelterRepository - Integración", () => {
  test("debería persistir y recuperar un refugio con sus supervivientes", async () => {
    const repo = new PostgreSQLShelterRepository(db);
    const shelter = new Shelter("refugio-test", 10);
    shelter.admit(new Survivor("1", "Ana", 100));

    await repo.save(shelter);
    const retrieved = await repo.findById("refugio-test");

    expect(retrieved).not.toBeNull();
    expect(retrieved?.getSurvivors()).toHaveLength(1);
  });
});

Estos tests son más lentos y requieren setup/teardown de base de datos, así que son menos frecuentes. La estrategia habitual es muchos tests de dominio puro (rápidos, sin dependencias) y pocos tests de integración (lentos, con infraestructura real).

NOTA EN LA CABAÑA

No siempre hace falta levantar la base de datos de producción para estos tests. Puedes usar una versión en memoria (SQLite in-memory, bases de datos embebidas como H2 en Java) o un repositorio stub que guarde los agregados en un simple Map. Sería como repasar el protocolo de evacuación en una maqueta del refugio, en lugar de hacerlo en el refugio real: más rápido, más seguro, y si hay errores no pierdes a nadie.

Qué más tiene sentido testear

El dominio puro y los repositorios no son lo único que merece atención:

Handlers de la capa de aplicación: no verifican reglas de negocio (eso ya lo hacen los tests del dominio), sino que la orquestación es correcta: que el handler carga el agregado, llama al método adecuado y persiste el resultado. El repositorio se sustituye por un mock.

Servicios de Dominio: se testean igual que los agregados, sin dependencias externas. El InfectionSpreadService del ejemplo anterior es un caso típico: entradas conocidas, salida esperada, sin base de datos ni red de por medio.

Sagas: son las más difíciles de testear porque implican secuencias de eventos y compensaciones. Lo que interesa verificar es que ante cada evento la Saga reacciona con el comando correcto, y que ante un fallo emite la compensación adecuada. Se prueban enviando eventos directamente a la Saga y comprobando qué comandos produce.

Tests end-to-end: el flujo completo, por ejemplo en aplicaciones web, esto nos llevaría desde la petición HTTP hasta la base de datos. Son los más lentos y los menos numerosos, pero dan la confianza final de que todo el sistema encaja. El equivalente a un simulacro general con todos los refugios y todas las rutas activas.

Podríamos poner ejemplos y extendernos en esta parte, pero daría prácticamente para otro artículo completo. Aún así, si os interesa comentad en LinkedIn y lo vemos.

Continuará

En esta tercera parte hemos visto cómo mantener la coherencia cuando una sola transacción no basta, con las Sagas coordinando operaciones distribuidas mediante eventos y compensaciones. Hemos repasado los antipatrones más peligrosos: el modelo anémico que vacía el dominio de lógica, los agregados gigantes que lo concentran todo, los bounded contexts que son solo carpetas con nombre bonito. Y vimos cómo testear el dominio puro sin levantar ninguna base de datos.

En la siguiente entrega aterrizaremos los tres problemas que aparecen cuando intentas llevar este diseño a producción: cómo garantizar que los eventos de dominio llegan aunque el sistema falle a mitad de camino, por qué modificar dos agregados en la misma transacción te va a dar problemas a escala y qué pasa cuando los datos del dominio son privados de verdad y el repositorio necesita guardarlos sin saltarse esa privacidad. Y después de eso, veremos todo el sistema funcionando de principio a fin con un checklist para saber si realmente estás haciendo DDD o solo organizando carpetas.

Otros artículos de la serie

  • Parte 1: Lenguaje ubicuo, bounded contexts, entidades, objetos de valor y agregados.
  • Parte 2: Servicios de dominio, repositorios, capa de aplicación y eventos de dominio.
  • Parte 4: Patrón Outbox, consistencia eventual entre agregados, el patrón Snapshot.
  • F.A.Q.: Preguntas frecuentes.
ESTO SIGUE EN EL REFUGIO

Si te has quedado con ganas de más arquitectura, en Domain-Driven Design en un Apocalipsis Zombi lo cuento entero: entidades, agregados, contextos delimitados y un refugio que aguanta cuando el proyecto crece. En tapa blanda y Kindle, y gratis si tienes Kindle Unlimited.

Si quieres seguir por donde lo deja este artículo, en el libro tienes:

  • Capítulo 11, «Sagas»: la Saga que sobrevive a los reinicios, las Sagas atascadas y la coreografía.
  • Capítulo 12, «Antipatrones y errores comunes»: entre ellos, aplicar DDD de golpe: el error del día cero.
  • Capítulo 13, «Pruebas»: ejemplos de código para cada tipo de test, incluidos los de contrato entre contextos.