@archi-code/ddd 3.0.0-alpha.1 → 3.0.0-alpha.2

package/ddd-skills/ddd-event-sourcing-cqrs/references/event-sourcing-ts.md

@@ -4,7 +4,7 @@
 
 ## Eventos del stream
 
-Cada evento es una subclase de `EventBase` con `static readonly eventName`, el id del agregado en `super(...)` y una carga de primitivos tomados de los value objects (el dinero como `{ amount, currency }`), nunca value objects: el evento se serializa tal cual con `toJSON()` [IDDD cap. 8].
+Cada evento es una subclase de `EventBase` con `static readonly eventName` y, como campos `readonly` del constructor, el id del agregado y los datos primitivos que necesita, tomados de los value objects (el dinero como `{ amount, currency }`), nunca value objects: el evento no tiene métodos y se serializa tal cual (`{ ...event }`) [IDDD cap. 8].
 
 ```ts
 import { EventBase } from '@archi-code/ddd/domain';
@@ -14,12 +14,12 @@ export class PaymentRequested extends EventBase {
   static readonly eventName = 'PaymentRequested';
 
   constructor(
-    paymentId: string,
+    readonly paymentId: string,
     readonly orderId: string,
     readonly amount: { amount: number; currency: string },
     metadata?: EventMetadata,
   ) {
-    super(paymentId, metadata);
+    super(metadata);
   }
 }
 
@@ -27,12 +27,12 @@ export class PaymentAuthorized extends EventBase {
   static readonly eventName = 'PaymentAuthorized';
 
   constructor(
-    paymentId: string,
+    readonly paymentId: string,
     readonly authorizationCode: string,
     readonly expiresAt: string,
     metadata?: EventMetadata,
   ) {
-    super(paymentId, metadata);
+    super(metadata);
   }
 }
 
@@ -40,22 +40,29 @@ export class PaymentRejected extends EventBase {
   static readonly eventName = 'PaymentRejected';
 
   constructor(
-    paymentId: string,
+    readonly paymentId: string,
     readonly reason: string,
     metadata?: EventMetadata,
   ) {
-    super(paymentId, metadata);
+    super(metadata);
   }
 }
 
 export class PaymentCaptured extends EventBase {
   static readonly eventName = 'PaymentCaptured';
+
+  constructor(
+    readonly paymentId: string,
+    metadata?: EventMetadata,
+  ) {
+    super(metadata);
+  }
 }
 
 export type PaymentEvent = PaymentRequested | PaymentAuthorized | PaymentRejected | PaymentCaptured;
 ```
 
-`EventBase` pone `eventId`, `aggregateId` y un `occurredOn` inmutable (del `clock` que recibe el método del agregado), y `toJSON()` escribe `eventName`, `eventVersion`, `eventId`, `aggregateId`, `occurredOn` en ISO y la carga: esa es la fila del stream.
+`EventBase` pone `eventName`, `eventId` y `occurredOn` (texto ISO en UTC, del `clock` que recibe el método del agregado); la identidad del pago es un campo más del evento (`paymentId`), declarado por cada clase. `{ ...event }` da `eventName`, `eventId`, `occurredOn` y los campos, todos datos primitivos (regla del paquete, no comprobada en ejecución): esa es la fila del stream.
 
 ## Agregado con decidir y aplicar
 
@@ -72,7 +79,7 @@ import {
   Required,
   StringType,
 } from '@archi-code/ddd/domain';
-import { DomainException } from '@archi-code/ddd/exceptions';
+import { DomainException } from '@archi-code/ddd/domain';
 import { Validations } from '@archi-code/validation';
 
 export class PaymentId extends IdType<'PaymentId'> {}
@@ -211,7 +218,7 @@ Reglas:
 * `fromHistory` aplica sin `record`: reconstituir no genera eventos nuevos.
 * El reloj se recibe como `{ now(): Date }` y se pasa a cada evento (`{ clock }`), para que reconstruir no dependa de la hora actual; en pruebas, `FixedClock`.
 * IDDD propone separar estado y comportamiento en dos clases que solo colaboran a través de `apply` [IDDD apéndice A]; aquí el estado son campos privados de value objects que solo `apply` escribe. Si el agregado crece, extrae ese estado a una clase propia con su `apply`.
-* `[Fuera de los libros: convención de @archi-code/ddd]` La `version` de `AggregateRoot` cuenta guardados, no eventos (crece 1 por `save`), así que este agregado lleva su propia versión de stream (`streamVersion()`, los eventos que se aplicaron al cargar) y no se guarda como instantánea: no necesita `toPrimitives()`/`fromPrimitives()` ni getters para sus campos, porque lo que se persiste son los eventos.
+* `[Fuera de los libros: convención de @archi-code/ddd]` `AggregateRoot` no tiene versión, y la que recuerda un repositorio de instantáneas en su `WeakMap` cuenta guardados, no eventos (crece 1 por `save`), así que este agregado lleva su propia versión de stream (`streamVersion()`, los eventos que se aplicaron al cargar) y no se guarda como instantánea: no necesita `toPrimitives()`/`fromPrimitives()` ni getters para sus campos, porque lo que se persiste son los eventos.
 
 ## Event store
 
@@ -227,7 +234,7 @@ CREATE TABLE event_streams (
 );
 ```
 
-La clave primaria `(stream_id, version)` impide dos escrituras con la misma versión; `global_seq` da el orden global que necesitan la publicación y la reconstrucción de proyecciones. `body` es el `toJSON()` del evento.
+La clave primaria `(stream_id, version)` impide dos escrituras con la misma versión; `global_seq` da el orden global que necesitan la publicación y la reconstrucción de proyecciones. `body` es la copia plana del evento (`{ ...event }`).
 
 El dominio declara el contrato del stream (solo tipos, como los contratos de repositorio del paquete) `[Fuera de los libros: convención de @archi-code/ddd]`: no es `AggregateFinder`/`AggregateSaver`, porque guardar necesita los cambios que el caso de uso ya sacó con `pullDomainEvents()` para publicarlos.
 
@@ -242,15 +249,15 @@ La infraestructura lo implementa: reconstruye cada fila con `EventRegistry.fromJ
 
 ```ts
 import type { SerializedEvent } from '@archi-code/ddd/domain';
-import { EventRegistry } from '@archi-code/ddd/infrastructure';
-import { ConcurrencyException, InternalErrorException } from '@archi-code/ddd/exceptions';
+import { EventRegistry, InternalErrorException } from '@archi-code/ddd/infrastructure';
+import { ConcurrencyException } from '@archi-code/ddd/application';
 
 export const paymentEvents = new EventRegistry<PaymentEvent>()
   .register(
     PaymentRequested,
     (json) =>
       new PaymentRequested(
-        json.aggregateId,
+        json.paymentId as string,
         json.orderId as string,
         json.amount as { amount: number; currency: string },
         json,
@@ -260,7 +267,7 @@ export const paymentEvents = new EventRegistry<PaymentEvent>()
     PaymentAuthorized,
     (json) =>
       new PaymentAuthorized(
-        json.aggregateId,
+        json.paymentId as string,
         json.authorizationCode as string,
         json.expiresAt as string,
         json,
@@ -268,9 +275,9 @@ export const paymentEvents = new EventRegistry<PaymentEvent>()
   )
   .register(
     PaymentRejected,
-    (json) => new PaymentRejected(json.aggregateId, json.reason as string, json),
+    (json) => new PaymentRejected(json.paymentId as string, json.reason as string, json),
   )
-  .register(PaymentCaptured, (json) => new PaymentCaptured(json.aggregateId, json));
+  .register(PaymentCaptured, (json) => new PaymentCaptured(json.paymentId as string, json));
 
 interface SqlClient {
   query<Row>(text: string, values: readonly unknown[]): Promise<{ rows: Row[] }>;
@@ -312,7 +319,7 @@ export class PgPaymentStream implements PaymentStream {
       for (const [index, event] of changes.entries()) {
         await client.query(
           'INSERT INTO event_streams (stream_id, version, body) VALUES ($1, $2, $3)',
-          [payment.id.value, expected + index + 1, JSON.stringify(event.toJSON())],
+          [payment.id.value, expected + index + 1, JSON.stringify(event)],
         );
       }
       await client.query('COMMIT', []);
@@ -333,12 +340,11 @@ export class PgPaymentStream implements PaymentStream {
 
 ## Caso de uso y reintento
 
-El caso de uso carga, decide, anexa y publica; no abre transacciones ni recibe un puerto para ello. Ante un conflicto puede reintentar recargando y reejecutando el comando contra el estado nuevo, como propone IDDD [IDDD apéndice A]; si el comando ya no es válido, el error de negocio sale normalmente. `[Fuera de los libros: convención de @archi-code/ddd]` El stream solo carga y anexa; el bucle de reintento va en el `handle` del caso de uso, cada intento vuelve a cargar y vuelve a anexar, unos pocos intentos y después relanza la `ConcurrencyException` (HTTP 409 con `HttpErrorMapper`). Reintenta solo comandos seguros de repetir; un caso de uso que lanza un listener no lleva este bucle: el reintento lo hace la reentrega del canal.
+El caso de uso carga, decide, anexa y publica; no abre transacciones ni recibe un puerto para ello. Ante un conflicto puede reintentar recargando y reejecutando el comando contra el estado nuevo, como propone IDDD [IDDD apéndice A]; si el comando ya no es válido, el error de negocio sale normalmente. `[Fuera de los libros: convención de @archi-code/ddd]` El stream solo carga y anexa; el bucle de reintento va en el `handle` del caso de uso, cada intento vuelve a cargar y vuelve a anexar, unos pocos intentos y después relanza la `ConcurrencyException` (`ExceptionKind.Conflict`, 409 en HTTP). Reintenta solo comandos seguros de repetir; un caso de uso que lanza un listener no lleva este bucle: el reintento lo hace la reentrega del canal.
 
 ```ts
-import { UseCase } from '@archi-code/ddd/application';
+import { AggregateNotFoundException, ConcurrencyException, UseCase } from '@archi-code/ddd/application';
 import type { Clock, EventBus } from '@archi-code/ddd/application';
-import { AggregateNotFoundException, ConcurrencyException } from '@archi-code/ddd/exceptions';
 
 export class CapturePayment extends UseCase<{ paymentId: string }, PaymentId, void> {
   constructor(
@@ -405,7 +411,7 @@ export class InMemoryPaymentStream implements PaymentStream {
     if (stream.length !== payment.streamVersion()) {
       throw new ConcurrencyException('Payment', payment.id.value, payment.streamVersion());
     }
-    this.streams.set(payment.id.value, [...stream, ...changes.map((event) => event.toJSON())]);
+    this.streams.set(payment.id.value, [...stream, ...changes.map((event) => ({ ...event }))]);
   }
 }
 
@@ -445,12 +451,11 @@ Para streams largos, guarda periódicamente el estado serializado con su versió
 
 `[Fuera de los libros]` Los eventos del stream no se reescriben. Para cambiar su forma, convierte las versiones antiguas al leer ("upcasting") en el deserializador, o añade un tipo de evento nuevo. El apéndice de IDDD trata los serializadores (por ejemplo Protocol Buffers) como apoyo para esta evolución [IDDD apéndice A].
 
-Con el paquete, el evento declara `static readonly eventVersion` (1 si no se declara; `toJSON()` lo escribe) y la fábrica del `EventRegistry` recibe el `eventVersion` con el que se guardó cada fila, así que el upcasting va ahí. Por ejemplo, si una primera versión de `PaymentRequested` guardaba `amountCents` en euros:
+Con el paquete, los eventos no llevan número de versión: la fábrica del `EventRegistry` recibe cada fila tal como se guardó, así que el upcasting va ahí y reconoce la forma antigua por sus campos; un cambio que no se pueda leer así se publica como un evento nuevo con otro `eventName` (`PaymentRequestedV2`). Por ejemplo, si una primera forma de `PaymentRequested` guardaba `amountCents` en euros:
 
 ```ts
 export class PaymentRequested extends EventBase {
   static readonly eventName = 'PaymentRequested';
-  static readonly eventVersion = 2;
   // constructor as above
 }
 
@@ -458,10 +463,10 @@ new EventRegistry<PaymentEvent>().register(
   PaymentRequested,
   (json) =>
     new PaymentRequested(
-      json.aggregateId,
+      json.paymentId as string,
       json.orderId as string,
-      json.eventVersion === 1
-        ? { amount: json.amountCents as number, currency: 'EUR' }
+      typeof json.amountCents === 'number'
+        ? { amount: json.amountCents, currency: 'EUR' }
         : (json.amount as { amount: number; currency: string }),
       json,
     ),

package/ddd-skills/ddd-event-sourcing-cqrs/references/proyecciones-cqrs-ts.md

@@ -64,7 +64,7 @@ La implementación registra el `eventId` en `projection_inbox` y aplica el cambi
 
 ```ts
 import type { EventBase } from '@archi-code/ddd/domain';
-import { InfrastructureException } from '@archi-code/ddd/exceptions';
+import { InfrastructureException } from '@archi-code/ddd/infrastructure';
 
 interface Sql {
   query<Row>(text: string, values: readonly unknown[]): Promise<{ rows: Row[]; rowCount: number }>;
@@ -87,7 +87,7 @@ export class PgOrderSummaryProjection implements OrderSummaryProjection {
            (order_id, customer, line_count, units, total_cents, currency, updated_at)
          VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (order_id) DO NOTHING`,
         [
-          event.aggregateId,
+          event.orderId,
           event.customerId,
           event.lines.length,
           event.lines.reduce((units, line) => units + line.quantity, 0),
@@ -107,7 +107,7 @@ export class PgOrderSummaryProjection implements OrderSummaryProjection {
              updated_at = GREATEST(updated_at, $4)
          WHERE order_id = $1`,
         [
-          event.aggregateId,
+          event.orderId,
           event.quantity,
           event.quantity * event.unitPrice.amount,
           event.occurredOn,
@@ -115,7 +115,7 @@ export class PgOrderSummaryProjection implements OrderSummaryProjection {
       );
       if (rowCount === 0) {
         throw new InfrastructureException(
-          `${this.table}: order ${event.aggregateId} is not projected yet`,
+          `${this.table}: order ${event.orderId} is not projected yet`,
         );
       }
     });
@@ -149,7 +149,7 @@ export const orderEvents = new EventRegistry<OrderEvent>()
     OrderPlaced,
     (json) =>
       new OrderPlaced(
-        json.aggregateId,
+        json.orderId as string,
         json.customerId as string,
         json.lines as OrderLineData[],
         json.total as MoneyData,
@@ -160,7 +160,7 @@ export const orderEvents = new EventRegistry<OrderEvent>()
     OrderLineAdded,
     (json) =>
       new OrderLineAdded(
-        json.aggregateId,
+        json.orderId as string,
         json.sku as string,
         json.quantity as number,
         json.unitPrice as MoneyData,
@@ -220,7 +220,7 @@ export async function rebuild(
 Una consulta de lectura es una interfaz de la aplicación que devuelve DTOs, implementada en infraestructura directamente sobre la base de datos:
 
 ```ts
-import { InternalErrorException } from '@archi-code/ddd/exceptions';
+import { InternalErrorException } from '@archi-code/ddd/infrastructure';
 
 export interface OrderSummary {
   readonly id: string;

package/ddd-skills/ddd-eventos-dominio/GUIA.md

@@ -8,7 +8,7 @@
 
 [Fuera de los libros: convención de @archi-code/ddd]
 
-* Los eventos extienden `EventBase`, declaran `static readonly eventName` con el nombre de su clase en pasado (`'OrderPlaced'`) y `static readonly eventVersion` cuando sus datos cambian de forma incompatible (1 si no se declara); llaman a `super(aggregateId, { clock })` y la base pone `eventId` (UUID v4) y `occurredOn`. El payload son primitivos sacados de los value objects (el dinero como `{ amount, currency }`), nunca value objects ni `toPrimitives()` del agregado.
+* Los eventos extienden `EventBase`, declaran `static readonly eventName` con el nombre de su clase en pasado (`'OrderPlaced'`); llaman a `super(metadata)` (con `{ clock }` dentro del agregado) y la base copia el nombre en el campo `eventName` y pone `eventId` (UUID v4) y `occurredOn` (texto ISO en UTC). Un evento es un objeto de datos primitivos sin métodos: `{ ...event }` y `JSON.stringify(event)` dan `{ eventName, eventId, occurredOn, ...campos }`. La identidad del agregado es un campo más que declara cada evento (`readonly orderId: string`). Regla, no comprobada en ejecución: cada evento declara como campos `readonly` del constructor solo los datos primitivos que necesita (texto, números finitos, booleanos, `null`, listas y objetos planos de ellos), sacados de los value objects (`.value`, el dinero como `{ amount, currency }`, las fechas en ISO), nunca value objects, `Date` ni `toPrimitives()` del agregado. Los eventos no llevan número de versión: un cambio incompatible de sus datos es un evento nuevo con otro `eventName`, o una fábrica del `EventRegistry` que lee las dos formas `[Fuera de los libros: convención de @archi-code/ddd]`.
 * El agregado registra con `record()` (que congela el evento) y el caso de uso publica con `await this.events.publish(order.pullDomainEvents())` justo después de `await this.orders.save(order)`. La aplicación nunca abre, une ni cierra transacciones y no hay puerto para ello: cada `save` es una escritura atómica que garantiza el repositorio. Si `publish` falla después de `save`, el evento se puede perder; cuando un evento no puede perderse, el adaptador del repositorio escribe el agregado y sus eventos pendientes en la misma escritura atómica (un outbox en el mismo documento o en la misma transacción de base de datos de `save`) y un reenviador los entrega después por un `EventChannel`. Es persistencia, así que va en el repositorio, y el caso de uso no cambia. Fuera de ese caso, el repositorio no toca los eventos.
 * La aplicación solo tiene el contrato de eventos, en `@archi-code/ddd/application`: para publicar, el puerto `EventBus` (lo único que ve el caso de uso); para escuchar, `EventListener` + `@ListensTo` (`ListensTo.subscriptionOf(listener)` da `{ eventName, consumer }`). Lo que mueve los eventos es infraestructura y lo usa solo el composition root, desde `@archi-code/ddd/infrastructure`: `DomainEventBus(channel, registry)` implementa `EventBus` sobre un `EventChannel` (con `ChannelHandler` y `ChannelSubscription`), que es lo único que implementa cada tecnología (`InMemoryEventChannel` en el paquete; un outbox o un broker en tu infraestructura). Los listeners reciben siempre el evento reconstruido desde su JSON por `EventRegistry`, cuya fábrica pasa el JSON como metadatos para conservar `eventId` y `occurredOn`.
 * Un listener extiende `EventListener<Event>`, escucha un único evento con `@ListensTo(EventClass, { consumer })` (un nombre de consumidor estable y explícito, su identidad en el canal), se llama `<Acción>On<Evento>` y solo traduce el evento a la entrada de un caso de uso.
@@ -63,7 +63,7 @@ export class PrepareShipmentOnOrderLineAdded extends EventListener<OrderLineAdde
   async handle(event: OrderLineAdded): Promise<void> {
     await this.prepareShipment.execute({
       eventId: event.eventId,
-      orderId: event.aggregateId,
+      orderId: event.orderId,
       sku: event.sku,
       quantity: event.quantity,
     });
@@ -82,7 +82,7 @@ export class PrepareShipmentOnOrderLineAdded extends EventListener<OrderLineAdde
 | Puede cambiar | Con el modelo | Solo con versión nueva y compatibilidad |
 | Contenido | Lo que el modelo necesita | Lo que el contrato promete; sin datos personales innecesarios |
 
-No publiques las clases de dominio ni su `toJSON()` tal cual hacia fuera. Traduce el evento serializado (`SerializedEvent`) al contrato publicado en el adaptador que habla con el broker, con `messageId` = `eventId` [IDDD cap. 13]; el paquete no trae esa traducción (ver "Lenguaje publicado en el adaptador del broker" en `ddd-skills/ddd-eventos-dominio/references/publicacion-ts.md`).
+No publiques los eventos de dominio tal cual (`{ ...event }`) hacia fuera. Traduce el evento serializado (`SerializedEvent`) al contrato publicado en el adaptador que habla con el broker, con `messageId` = `eventId` [IDDD cap. 13]; el paquete no trae esa traducción (ver "Lenguaje publicado en el adaptador del broker" en `ddd-skills/ddd-eventos-dominio/references/publicacion-ts.md`).
 
 ## Señales de alarma
 

package/ddd-skills/ddd-eventos-dominio/references/diseno-eventos.md

@@ -21,7 +21,7 @@
 Pregunta guía: ¿qué estimuló la publicación del evento? Normalmente un comando, y el evento debería llevar las propiedades que llevaba ese comando [Destilado cap. 6]. IDDD añade [IDDD cap. 8]:
 
 * Marca de tiempo de cuándo ocurrió (`occurredOn`, que pone `EventBase`).
-* Lo necesario para "volver a disparar" el evento: identidad del agregado (`aggregateId`, el primer argumento de `super`) y de los agregados implicados.
+* Lo necesario para "volver a disparar" el evento: identidad del agregado (un campo del payload que declara el evento, como `orderId`; `EventBase` no la pone) y de los agregados implicados.
 * Parámetros del comando si se demuestran útiles.
 * Valores del estado resultante que ayuden a los suscriptores.
 * En entornos multi-tenant, siempre el `tenantId`, aunque no viniera en el comando.
@@ -51,11 +51,11 @@ export class OrderConfirmed extends EventBase {
   static readonly eventName = 'OrderConfirmed';
 
   constructor(
-    orderId: string,
+    readonly orderId: string,
     readonly total: MoneyData,
     metadata?: EventMetadata,
   ) {
-    super(orderId, metadata);
+    super(metadata);
   }
 }
 ```
@@ -71,13 +71,13 @@ private tryToConfirm(clock: { now(): Date }): void {
 }
 ```
 
-`EventBase` pone `eventId` (UUID v4) y `occurredOn` (del `clock`, o la hora del sistema), y `record()` congela el evento: inmutable y con constructor completo [IDDD cap. 8]. No generes tú el id ni la fecha de un evento nuevo; pasa `{ eventId, occurredOn }` (o el JSON entero) solo al reconstruir uno que entregó un canal. `toJSON()` da la forma que viaja:
+`EventBase` pone `eventName`, `eventId` (UUID v4) y `occurredOn` (texto ISO en UTC, del `clock` o de la hora del sistema), y `record()` congela el evento: inmutable y con constructor completo [IDDD cap. 8]. No generes tú el id ni la fecha de un evento nuevo; pasa `{ eventId, occurredOn }` (o el JSON entero) solo al reconstruir uno que entregó un canal. El evento ya es la forma que viaja:
 
 ```ts
 const [confirmed] = order.pullDomainEvents();
-confirmed.toJSON();
-// { eventName: 'OrderConfirmed', eventVersion: 1, eventId: '…', aggregateId: '9b2f6c1e-…',
-//   occurredOn: '2026-03-01T09:30:00.000Z', total: { amount: 7000, currency: 'EUR' } }
+({ ...confirmed });
+// { eventName: 'OrderConfirmed', eventId: '…', occurredOn: '2026-03-01T09:30:00.000Z',
+//   orderId: '9b2f6c1e-…', total: { amount: 7000, currency: 'EUR' } }
 ```
 
 ## Identidad del evento
@@ -93,7 +93,7 @@ A veces un evento no resulta de un comando sobre un agregado sino que un usuario
 
 * Los eventos publicados llevan versión. Diseñados con cuidado, muchos consumidores pueden leer cualquier versión como si fuera la 1 [IDDD cap. 13].
 * Cambios compatibles `[Fuera de los libros]`: añadir campos opcionales. Incompatibles: renombrar, quitar o cambiar el significado → nueva versión o nuevo evento, publicando ambas durante la transición.
-* Con el paquete, la versión de la forma interna es `static readonly eventVersion` (1 si no se declara; `toJSON()` la escribe). Los eventos guardados conservan la versión con la que se escribieron, así que la fábrica del `EventRegistry` lee las formas antiguas a partir de `json.eventVersion`:
+* Con el paquete, los eventos no llevan número de versión `[Fuera de los libros: convención de @archi-code/ddd]`. Un cambio incompatible de la forma interna se publica como un evento nuevo con otro `eventName` (`OrderCancelledV2`), o la fábrica del `EventRegistry`, que recibe cada evento guardado tal como se escribió, reconoce la forma antigua por sus campos:
 
 ```ts
 import { EventBase } from '@archi-code/ddd/domain';
@@ -102,30 +102,29 @@ import { EventRegistry } from '@archi-code/ddd/infrastructure';
 
 export class OrderCancelled extends EventBase {
   static readonly eventName = 'OrderCancelled';
-  static readonly eventVersion = 2;
 
   constructor(
-    orderId: string,
+    readonly orderId: string,
     readonly reason: string,
     readonly refund: MoneyData,
     metadata?: EventMetadata,
   ) {
-    super(orderId, metadata);
+    super(metadata);
   }
 }
 
 export const cancellations = new EventRegistry<OrderCancelled>().register(
   OrderCancelled,
   (json) =>
-    json.eventVersion === 1
+    typeof json.refundCents === 'number'
       ? new OrderCancelled(
-          json.aggregateId,
+          json.orderId as string,
           json.reason as string,
-          { amount: json.refundCents as number, currency: 'EUR' },
+          { amount: json.refundCents, currency: 'EUR' },
           json,
         )
-      : new OrderCancelled(json.aggregateId, json.reason as string, json.refund as MoneyData, json),
+      : new OrderCancelled(json.orderId as string, json.reason as string, json.refund as MoneyData, json),
 );
 ```
 
-La versión del contrato publicado a otros contextos es otra cosa: la decide el adaptador del broker, que puede seguir emitiendo la v1 del contrato aunque el evento interno esté en la v2 (ver `ddd-skills/ddd-eventos-dominio/references/publicacion-ts.md`).
+La versión del contrato publicado a otros contextos es otra cosa: la decide el adaptador del broker, que puede seguir emitiendo la v1 del contrato aunque cambie la forma del evento interno (ver `ddd-skills/ddd-eventos-dominio/references/publicacion-ts.md`).

package/ddd-skills/ddd-eventos-dominio/references/ejemplo-ecommerce.md

@@ -44,13 +44,13 @@ export class OrderPlaced extends EventBase {
   static readonly eventName = 'OrderPlaced';
 
   constructor(
-    orderId: string,
+    readonly orderId: string,
     readonly customerId: string,
     readonly lines: readonly OrderLineData[],
     readonly total: MoneyData,
     metadata?: EventMetadata,
   ) {
-    super(orderId, metadata);
+    super(metadata);
   }
 }
 
@@ -58,14 +58,14 @@ export class OrderLineAdded extends EventBase {
   static readonly eventName = 'OrderLineAdded';
 
   constructor(
-    orderId: string,
+    readonly orderId: string,
     readonly sku: string,
     readonly quantity: number,
     readonly unitPrice: MoneyData,
     readonly total: MoneyData,
     metadata?: EventMetadata,
   ) {
-    super(orderId, metadata);
+    super(metadata);
   }
 }
 
@@ -73,11 +73,11 @@ export class OrderConfirmed extends EventBase {
   static readonly eventName = 'OrderConfirmed';
 
   constructor(
-    orderId: string,
+    readonly orderId: string,
     readonly total: MoneyData,
     metadata?: EventMetadata,
   ) {
-    super(orderId, metadata);
+    super(metadata);
   }
 }
 
@@ -154,7 +154,7 @@ export const orderEvents = new EventRegistry<OrderEvent>()
     OrderPlaced,
     (json) =>
       new OrderPlaced(
-        json.aggregateId,
+        json.orderId as string,
         json.customerId as string,
         json.lines as OrderLineData[],
         json.total as MoneyData,
@@ -165,7 +165,7 @@ export const orderEvents = new EventRegistry<OrderEvent>()
     OrderLineAdded,
     (json) =>
       new OrderLineAdded(
-        json.aggregateId,
+        json.orderId as string,
         json.sku as string,
         json.quantity as number,
         json.unitPrice as MoneyData,
@@ -175,13 +175,13 @@ export const orderEvents = new EventRegistry<OrderEvent>()
   )
   .register(
     OrderConfirmed,
-    (json) => new OrderConfirmed(json.aggregateId, json.total as MoneyData, json),
+    (json) => new OrderConfirmed(json.orderId as string, json.total as MoneyData, json),
   )
   .register(
     OrderCancelled,
     (json) =>
       new OrderCancelled(
-        json.aggregateId,
+        json.orderId as string,
         json.reason as string,
         json.reservationId as string | null,
         json.paymentId as string | null,
@@ -192,7 +192,7 @@ export const orderEvents = new EventRegistry<OrderEvent>()
     PaymentAuthorizationInsufficient,
     (json) =>
       new PaymentAuthorizationInsufficient(
-        json.aggregateId,
+        json.orderId as string,
         json.paymentId as string,
         json.authorized as MoneyData,
         json.required as MoneyData,