@cosmicdrift/kumiko-framework 0.1.0

package/src/event-store/__tests__/upcaster-dead-letter.integration.ts

@@ -0,0 +1,204 @@
+// Quarantine-Policy für fehlerhafte Upcaster.
+//
+// Die throw-Policy ist bereits in upcaster.integration.ts getestet. Hier:
+//   - quarantine schreibt eine dead-letter-Row
+//   - der Event wird aus der Result-Liste entfernt
+//   - die throw-Policy bleibt unverändert (Regression-Guard)
+//   - listDeadLetters filtert per eventType
+
+import { eq, sql } from "drizzle-orm";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { createTestDb, type TestDb } from "../../stack";
+import type { StoredEvent } from "../event-store";
+import { createEventsTable, eventsTable } from "../events-schema";
+import { type EventUpcasters, makeUpcastCtx, upcastStoredEvents } from "../upcaster";
+import {
+  createUpcasterDeadLetterTable,
+  listDeadLetters,
+  upcasterDeadLetterTable,
+} from "../upcaster-dead-letter";
+
+let testDb: TestDb;
+
+const TENANT_ID = "00000000-0000-4000-8000-0000000000aa";
+
+function makeEvent(overrides: Partial<StoredEvent> = {}): StoredEvent {
+  return {
+    id: "1",
+    aggregateId: "agg-1",
+    aggregateType: "probe",
+    tenantId: TENANT_ID as StoredEvent["tenantId"],
+    version: 1,
+    type: "probe.broken",
+    eventVersion: 1,
+    payload: { legacy: "value" },
+    metadata: {} as StoredEvent["metadata"],
+    createdAt: new Date(0) as unknown as StoredEvent["createdAt"],
+    createdBy: "system",
+    ...overrides,
+  };
+}
+
+// Upcaster chain that deliberately throws at v1→v2. Used for the
+// quarantine path; the throw case rides the same wiring but with the
+// default policy.
+const failingUpcasters: EventUpcasters = new Map([
+  [
+    "probe.broken",
+    {
+      currentVersion: 2,
+      chain: new Map([
+        [
+          1,
+          async () => {
+            throw new Error("payload malformed: missing required field");
+          },
+        ],
+      ]),
+    },
+  ],
+]);
+
+const passthroughUpcasters: EventUpcasters = new Map([
+  [
+    "probe.ok",
+    {
+      currentVersion: 2,
+      chain: new Map([
+        [
+          1,
+          async (payload) => ({
+            ...(payload as Record<string, unknown>),
+            migrated: true,
+          }),
+        ],
+      ]),
+    },
+  ],
+]);
+
+beforeAll(async () => {
+  testDb = await createTestDb();
+  await createEventsTable(testDb.db);
+  await createUpcasterDeadLetterTable(testDb.db);
+});
+
+afterAll(async () => {
+  await testDb.cleanup();
+});
+
+afterEach(async () => {
+  await testDb.db.delete(upcasterDeadLetterTable);
+  await testDb.db.delete(eventsTable);
+});
+
+describe("upcaster error-policy: throw (default)", () => {
+  test("failing transform propagates the thrown error", async () => {
+    const events = [makeEvent()];
+    await expect(
+      upcastStoredEvents(events, failingUpcasters, makeUpcastCtx(testDb.db, TENANT_ID)),
+    ).rejects.toThrow(/payload malformed/);
+  });
+
+  test("failing transform writes NO dead-letter row", async () => {
+    const events = [makeEvent()];
+    await upcastStoredEvents(events, failingUpcasters, makeUpcastCtx(testDb.db, TENANT_ID)).catch(
+      () => {},
+    );
+    const rows = await listDeadLetters(testDb.db);
+    expect(rows).toHaveLength(0);
+  });
+});
+
+describe("upcaster error-policy: quarantine", () => {
+  test("failing transform writes a dead-letter row and is removed from the result list", async () => {
+    const ok = makeEvent({
+      id: "10",
+      type: "probe.ok",
+      payload: { value: 42 },
+      eventVersion: 1,
+    });
+    const broken = makeEvent({ id: "11", type: "probe.broken" });
+
+    // Combined upcaster map — real callers have both registered together.
+    const combined: EventUpcasters = new Map([
+      ...failingUpcasters.entries(),
+      ...passthroughUpcasters.entries(),
+    ]);
+
+    const result = await upcastStoredEvents(
+      [ok, broken],
+      combined,
+      makeUpcastCtx(testDb.db, TENANT_ID),
+      { errorPolicy: "quarantine" },
+    );
+
+    // Only the ok event survives; broken landed in dead-letters.
+    expect(result).toHaveLength(1);
+    expect(result[0]?.id).toBe("10");
+    expect(result[0]?.eventVersion).toBe(2);
+    expect((result[0]?.payload as { migrated?: boolean }).migrated).toBe(true);
+
+    const dl = await listDeadLetters(testDb.db);
+    expect(dl).toHaveLength(1);
+    expect(dl[0]).toMatchObject({
+      eventId: "11",
+      aggregateId: "agg-1",
+      aggregateType: "probe",
+      eventType: "probe.broken",
+      fromVersion: 1,
+      targetVersion: 2,
+    });
+    expect(dl[0]?.errorMessage).toContain("payload malformed");
+    expect(dl[0]?.originalPayload).toEqual({ legacy: "value" });
+  });
+
+  test("listDeadLetters filters by eventType", async () => {
+    await upcastStoredEvents(
+      [
+        makeEvent({ id: "20", type: "probe.broken" }),
+        makeEvent({ id: "21", type: "probe.broken" }),
+      ],
+      failingUpcasters,
+      makeUpcastCtx(testDb.db, TENANT_ID),
+      { errorPolicy: "quarantine" },
+    );
+
+    // Drop one directly to add noise of a different type.
+    await testDb.db.insert(upcasterDeadLetterTable).values({
+      eventId: "99",
+      tenantId: TENANT_ID,
+      aggregateId: "other",
+      aggregateType: "other",
+      eventType: "other.broken",
+      fromVersion: 1,
+      targetVersion: 2,
+      errorMessage: "unrelated",
+      originalPayload: {},
+    });
+
+    const probeOnly = await listDeadLetters(testDb.db, { eventType: "probe.broken" });
+    expect(probeOnly).toHaveLength(2);
+    expect(probeOnly.every((r) => r.eventType === "probe.broken")).toBe(true);
+
+    const all = await listDeadLetters(testDb.db);
+    expect(all.length).toBeGreaterThanOrEqual(3);
+  });
+
+  test("same event quarantined twice inserts two rows (retry-across-deploys visibility)", async () => {
+    const broken = makeEvent({ id: "30", type: "probe.broken" });
+
+    await upcastStoredEvents([broken], failingUpcasters, makeUpcastCtx(testDb.db, TENANT_ID), {
+      errorPolicy: "quarantine",
+    });
+    await upcastStoredEvents([broken], failingUpcasters, makeUpcastCtx(testDb.db, TENANT_ID), {
+      errorPolicy: "quarantine",
+    });
+
+    const rows = await testDb.db
+      .select({ c: sql<number>`count(*)::int` })
+      .from(upcasterDeadLetterTable)
+      .where(eq(upcasterDeadLetterTable.eventId, "30"));
+    expect(rows[0]?.c).toBe(2);
+  });
+});

package/src/event-store/__tests__/upcaster.integration.ts

@@ -0,0 +1,460 @@
+// B1 — r.eventMigration + event_version routing (Marten upcaster).
+//
+// Covers the two load-bearing claims:
+//   1. Stored v(N) payloads are transparently upgraded to v(current) when
+//      read through the upcaster. Projections and any future aggregate
+//      loader see the current shape regardless of how old the event is.
+//   2. Boot-time validation refuses incomplete chains. Declaring version=3
+//      with only a 1→2 migration fails immediately, so a missing upcaster
+//      can never silently hand half-migrated data to consumers.
+
+import { sql } from "drizzle-orm";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { z } from "zod";
+import { integer as pgInteger, table as pgTable, text as pgText } from "../../db/dialect";
+import { createEventStoreExecutor } from "../../db/event-store-executor";
+import { buildDrizzleTable } from "../../db/table-builder";
+import { createTenantDb, type TenantDb } from "../../db/tenant-db";
+import { createEntity, createRegistry, createTextField, defineFeature } from "../../engine";
+import type { StoredEvent } from "../../event-store";
+import { rebuildProjection } from "../../pipeline";
+import { createEntityTable, createTestDb, pushTables, type TestDb, TestUsers } from "../../stack";
+import { append, createEventsTable } from "../index";
+import { upcastStoredEvent } from "../upcaster";
+
+// --- Fixture entity + projection table ---
+
+const orderEntity = createEntity({
+  table: "read_upcast_orders",
+  fields: {
+    customer: createTextField({ required: true }),
+  },
+});
+const orderTable = buildDrizzleTable("upcast-order", orderEntity);
+
+// Projection stores the UPCAST view: the v3 shape expects `totalCents` (int)
+// even though the earliest writes might have stored `totalEuros` (string).
+const orderSummaryTable = pgTable("read_upcast_order_summary", {
+  orderId: pgText("order_id").primaryKey(),
+  tenantId: pgText("tenant_id").notNull(),
+  totalCents: pgInteger("total_cents").notNull(),
+  currency: pgText("currency").notNull(),
+});
+
+// --- Feature: version 3 event with v1→v2 and v2→v3 migrations registered ---
+
+const orderFeature = defineFeature("upcastshop", (r) => {
+  r.entity("upcast-order", orderEntity);
+
+  // v3 shape: { totalCents: int, currency: string }
+  const orderPriced = r.defineEvent(
+    "priced",
+    z.object({ totalCents: z.number().int(), currency: z.string() }),
+    { version: 3 },
+  );
+
+  // v1 → v2: renamed totalEuros → total (kept as string for this step)
+  r.eventMigration("priced", 1, 2, (payload) => {
+    const p = payload as { totalEuros: string };
+    return { total: p.totalEuros, currency: "EUR" };
+  });
+  // v2 → v3: parse "total" string into integer cents
+  r.eventMigration("priced", 2, 3, (payload) => {
+    const p = payload as { total: string; currency: string };
+    const euros = Number.parseFloat(p.total);
+    return { totalCents: Math.round(euros * 100), currency: p.currency };
+  });
+
+  r.projection({
+    name: "order-summary",
+    source: "upcast-order",
+    table: orderSummaryTable,
+    apply: {
+      [orderPriced.name]: async (event, tx) => {
+        const p = event.payload as { totalCents: number; currency: string };
+        await tx
+          .insert(orderSummaryTable)
+          .values({
+            orderId: event.aggregateId,
+            tenantId: event.tenantId,
+            totalCents: p.totalCents,
+            currency: p.currency,
+          })
+          .onConflictDoUpdate({
+            target: orderSummaryTable.orderId,
+            set: { totalCents: p.totalCents, currency: p.currency },
+          });
+      },
+    },
+  });
+});
+
+// --- Test scaffolding ---
+
+let testDb: TestDb;
+let tdb: TenantDb;
+const admin = TestUsers.admin;
+const registry = createRegistry([orderFeature]);
+const qualifiedProjectionName = "upcastshop:projection:order-summary";
+const orderExecutor = createEventStoreExecutor(orderTable, orderEntity, {
+  entityName: "upcast-order",
+});
+
+beforeAll(async () => {
+  testDb = await createTestDb();
+  await createEntityTable(testDb.db, orderEntity, "upcast-order");
+  await createEventsTable(testDb.db);
+  const { createProjectionStateTable } = await import("../../pipeline");
+  await createProjectionStateTable(testDb.db);
+  await pushTables(testDb.db, { upcastOrderSummary: orderSummaryTable });
+  tdb = createTenantDb(testDb.db, admin.tenantId);
+});
+
+afterAll(async () => {
+  await testDb.cleanup();
+});
+
+beforeEach(async () => {
+  await testDb.db.execute(
+    sql`TRUNCATE kumiko_events, read_upcast_orders, read_upcast_order_summary, kumiko_projections RESTART IDENTITY CASCADE`,
+  );
+});
+
+// --- Tests ---
+
+describe("upcaster: in-memory transform chain", () => {
+  test("v1 payload walks v1→v2→v3 before reaching a consumer", async () => {
+    const upcasters = registry.getEventUpcasters();
+    const raw: StoredEvent = {
+      id: "1",
+      aggregateId: "00000000-0000-4000-8000-000000000001",
+      aggregateType: "upcast-order",
+      tenantId: admin.tenantId,
+      version: 1,
+      type: "upcastshop:event:priced",
+      eventVersion: 1,
+      payload: { totalEuros: "19.99" },
+      metadata: { userId: admin.id },
+      createdAt: Temporal.Now.instant(),
+      createdBy: admin.id,
+    };
+
+    const upcast = await upcastStoredEvent(raw, upcasters, {
+      db: testDb.db,
+      tenantId: admin.tenantId,
+    });
+
+    expect(upcast.eventVersion).toBe(3);
+    expect(upcast.payload).toEqual({ totalCents: 1999, currency: "EUR" });
+  });
+
+  test("v2 payload only needs v2→v3 step — chain short-circuits per stored version", async () => {
+    const upcasters = registry.getEventUpcasters();
+    const raw: StoredEvent = {
+      id: "2",
+      aggregateId: "00000000-0000-4000-8000-000000000002",
+      aggregateType: "upcast-order",
+      tenantId: admin.tenantId,
+      version: 1,
+      type: "upcastshop:event:priced",
+      eventVersion: 2,
+      payload: { total: "5.00", currency: "USD" },
+      metadata: { userId: admin.id },
+      createdAt: Temporal.Now.instant(),
+      createdBy: admin.id,
+    };
+
+    const upcast = await upcastStoredEvent(raw, upcasters, {
+      db: testDb.db,
+      tenantId: admin.tenantId,
+    });
+
+    expect(upcast.eventVersion).toBe(3);
+    expect(upcast.payload).toEqual({ totalCents: 500, currency: "USD" });
+  });
+
+  test("already-current events pass through unchanged — fast path", async () => {
+    const upcasters = registry.getEventUpcasters();
+    const raw: StoredEvent = {
+      id: "3",
+      aggregateId: "00000000-0000-4000-8000-000000000003",
+      aggregateType: "upcast-order",
+      tenantId: admin.tenantId,
+      version: 1,
+      type: "upcastshop:event:priced",
+      eventVersion: 3,
+      payload: { totalCents: 7777, currency: "CHF" },
+      metadata: { userId: admin.id },
+      createdAt: Temporal.Now.instant(),
+      createdBy: admin.id,
+    };
+
+    const upcast = await upcastStoredEvent(raw, upcasters, {
+      db: testDb.db,
+      tenantId: admin.tenantId,
+    });
+
+    expect(upcast).toBe(raw); // identity — no rebuild allocated
+  });
+
+  test("unknown event types pass through unchanged", async () => {
+    const upcasters = registry.getEventUpcasters();
+    const raw: StoredEvent = {
+      id: "4",
+      aggregateId: "00000000-0000-4000-8000-000000000004",
+      aggregateType: "upcast-order",
+      tenantId: admin.tenantId,
+      version: 1,
+      type: "some:event:never-declared",
+      eventVersion: 1,
+      payload: { whatever: true },
+      metadata: { userId: admin.id },
+      createdAt: Temporal.Now.instant(),
+      createdBy: admin.id,
+    };
+
+    const upcast = await upcastStoredEvent(raw, upcasters, {
+      db: testDb.db,
+      tenantId: admin.tenantId,
+    });
+
+    expect(upcast).toBe(raw);
+  });
+});
+
+describe("upcaster: projection rebuild walks the chain on replay", () => {
+  test("rebuild produces current-shape projection state from mixed v1/v2/v3 events", async () => {
+    const ord1 = "00000000-0000-4000-8000-00000000aaaa";
+    const ord2 = "00000000-0000-4000-8000-00000000bbbb";
+    const ord3 = "00000000-0000-4000-8000-00000000cccc";
+
+    // Seed the entity rows so the FK-less projection stays readable even if
+    // future tests add FKs; insert directly, the executor is overkill here.
+    await orderExecutor.create({ customer: "c1" }, admin, tdb);
+    await orderExecutor.create({ customer: "c2" }, admin, tdb);
+    await orderExecutor.create({ customer: "c3" }, admin, tdb);
+
+    // Append three "priced" events at three different schema versions. The
+    // projection apply is only written against v3 — without upcasting, the
+    // v1 + v2 events would crash or produce garbage.
+    await append(testDb.db, {
+      aggregateId: ord1,
+      aggregateType: "upcast-order",
+      tenantId: admin.tenantId,
+      expectedVersion: 0,
+      type: "upcastshop:event:priced",
+      eventVersion: 1,
+      payload: { totalEuros: "10.00" },
+      metadata: { userId: admin.id },
+    });
+    await append(testDb.db, {
+      aggregateId: ord2,
+      aggregateType: "upcast-order",
+      tenantId: admin.tenantId,
+      expectedVersion: 0,
+      type: "upcastshop:event:priced",
+      eventVersion: 2,
+      payload: { total: "25.50", currency: "USD" },
+      metadata: { userId: admin.id },
+    });
+    await append(testDb.db, {
+      aggregateId: ord3,
+      aggregateType: "upcast-order",
+      tenantId: admin.tenantId,
+      expectedVersion: 0,
+      type: "upcastshop:event:priced",
+      eventVersion: 3,
+      payload: { totalCents: 9900, currency: "CHF" },
+      metadata: { userId: admin.id },
+    });
+
+    const result = await rebuildProjection(qualifiedProjectionName, {
+      db: testDb.db,
+      registry,
+    });
+    expect(result.eventsProcessed).toBe(3);
+
+    const rows = await testDb.db
+      .select()
+      .from(orderSummaryTable)
+      .orderBy(orderSummaryTable.orderId);
+
+    // Ordered by orderId → ord1 (10€ = 1000¢), ord2 ($25.50 = 2550¢), ord3 (9900¢)
+    expect(rows).toHaveLength(3);
+    const byId = new Map(rows.map((r) => [r.orderId, r]));
+    expect(byId.get(ord1)).toMatchObject({ totalCents: 1000, currency: "EUR" });
+    expect(byId.get(ord2)).toMatchObject({ totalCents: 2550, currency: "USD" });
+    expect(byId.get(ord3)).toMatchObject({ totalCents: 9900, currency: "CHF" });
+  });
+});
+
+describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () => {
+  test("async transform with ctx.db lookup walks chain via projection rebuild", async () => {
+    // Reference data table that the async upcaster looks up — simulates the
+    // typical case "v2 needs to enrich payload with current snapshot of a
+    // reference dataset". We seed a known row and assert the rebuilt
+    // projection has the enriched value.
+    const customerSegments = pgTable("upcast_async_customer_segments", {
+      customerId: pgText("customer_id").primaryKey(),
+      segment: pgText("segment").notNull(),
+    });
+    await pushTables(testDb.db, { upcastAsyncCustomerSegments: customerSegments });
+    await testDb.db
+      .insert(customerSegments)
+      .values({ customerId: "c-async-1", segment: "PREMIUM" });
+
+    const asyncSummary = pgTable("upcast_async_summary", {
+      orderId: pgText("order_id").primaryKey(),
+      customerId: pgText("customer_id").notNull(),
+      segment: pgText("segment").notNull(),
+    });
+    await pushTables(testDb.db, { upcastAsyncSummary: asyncSummary });
+
+    // Feature with async upcaster v1 → v2: enrich payload with segment from DB.
+    const asyncFeature = defineFeature("upcastasync", (r) => {
+      r.entity("upcast-async-order", orderEntity);
+      const placed = r.defineEvent(
+        "placed",
+        z.object({ customerId: z.string(), segment: z.string() }),
+        { version: 2 },
+      );
+
+      r.eventMigration("placed", 1, 2, async (payload, ctx) => {
+        const p = payload as { customerId: string };
+        const [row] = await ctx.db
+          .select()
+          .from(customerSegments)
+          .where(sql`${customerSegments.customerId} = ${p.customerId}`);
+        return { customerId: p.customerId, segment: row?.segment ?? "UNKNOWN" };
+      });
+
+      r.projection({
+        name: "async-summary",
+        source: "upcast-async-order",
+        table: asyncSummary,
+        apply: {
+          [placed.name]: async (event, tx) => {
+            const p = event.payload as { customerId: string; segment: string };
+            await tx.insert(asyncSummary).values({
+              orderId: event.aggregateId,
+              customerId: p.customerId,
+              segment: p.segment,
+            });
+          },
+        },
+      });
+    });
+
+    const asyncRegistry = createRegistry([asyncFeature]);
+
+    // Stream: one v1 event without segment + one v2 event with segment.
+    // The upcaster must lift v1 to v2 via DB lookup on customer_segments.
+    const orderId1 = "00000000-0000-4000-8000-00000000ddd1";
+    const orderId2 = "00000000-0000-4000-8000-00000000ddd2";
+    await append(testDb.db, {
+      aggregateId: orderId1,
+      aggregateType: "upcast-async-order",
+      tenantId: admin.tenantId,
+      expectedVersion: 0,
+      type: "upcastasync:event:placed",
+      eventVersion: 1,
+      payload: { customerId: "c-async-1" },
+      metadata: { userId: admin.id },
+    });
+    await append(testDb.db, {
+      aggregateId: orderId2,
+      aggregateType: "upcast-async-order",
+      tenantId: admin.tenantId,
+      expectedVersion: 0,
+      type: "upcastasync:event:placed",
+      eventVersion: 2,
+      payload: { customerId: "c-async-2", segment: "STANDARD" },
+      metadata: { userId: admin.id },
+    });
+
+    const result = await rebuildProjection("upcastasync:projection:async-summary", {
+      db: testDb.db,
+      registry: asyncRegistry,
+    });
+    expect(result.eventsProcessed).toBe(2);
+
+    const rows = await testDb.db.select().from(asyncSummary).orderBy(asyncSummary.orderId);
+    expect(rows).toHaveLength(2);
+    const byId = new Map(rows.map((r) => [r.orderId, r]));
+    // v1 → v2 via async DB lookup → segment from customer_segments.
+    expect(byId.get(orderId1)?.segment).toBe("PREMIUM");
+    // v2 already current → passes through unchanged.
+    expect(byId.get(orderId2)?.segment).toBe("STANDARD");
+  });
+});
+
+describe("upcaster: boot-time validation", () => {
+  test("defineEvent with version=N and only partial migrations fails at registry build", () => {
+    const incomplete = defineFeature("holes", (r) => {
+      r.entity("hole-order", orderEntity);
+      r.defineEvent("bad", z.object({ v3: z.string() }), { version: 3 });
+      // Only 1→2 registered — the 2→3 gap must be rejected.
+      r.eventMigration("bad", 1, 2, (p) => p);
+    });
+    expect(() => createRegistry([incomplete])).toThrow(/v2.*v3|covers the step v2/);
+  });
+
+  test("migration declared but no defineEvent → rejected", () => {
+    const orphan = defineFeature("orphans", (r) => {
+      r.entity("orph-order", orderEntity);
+      r.eventMigration("ghost", 1, 2, (p) => p);
+    });
+    expect(() => createRegistry([orphan])).toThrow(/no r\.defineEvent/i);
+  });
+
+  test("migration toVersion > defineEvent version → rejected", () => {
+    const future = defineFeature("future", (r) => {
+      r.entity("future-order", orderEntity);
+      r.defineEvent("early", z.object({ x: z.number() }), { version: 1 });
+      r.eventMigration("early", 1, 2, (p) => p);
+    });
+    expect(() => createRegistry([future])).toThrow(/declares only version 1/);
+  });
+
+  test("non-contiguous (1→2 and 3→4 without 2→3) → rejected", () => {
+    const gaps = defineFeature("gaps", (r) => {
+      r.entity("gap-order", orderEntity);
+      r.defineEvent("jumpy", z.object({ v: z.number() }), { version: 4 });
+      r.eventMigration("jumpy", 1, 2, (p) => p);
+      r.eventMigration("jumpy", 3, 4, (p) => p);
+    });
+    expect(() => createRegistry([gaps])).toThrow(/v2.*v3|covers the step v2/);
+  });
+});
+
+describe("upcaster: registrar input validation", () => {
+  test("r.eventMigration rejects multi-step jumps", () => {
+    expect(() =>
+      defineFeature("bigstep", (r) => {
+        r.entity("bigstep-order", orderEntity);
+        r.defineEvent("biz", z.object({ x: z.number() }), { version: 3 });
+        r.eventMigration("biz", 1, 3, (p) => p);
+      }),
+    ).toThrow(/single-step/);
+  });
+
+  test("r.eventMigration rejects duplicate step", () => {
+    expect(() =>
+      defineFeature("dupestep", (r) => {
+        r.entity("dup-order", orderEntity);
+        r.defineEvent("dup", z.object({ x: z.number() }), { version: 2 });
+        r.eventMigration("dup", 1, 2, (p) => p);
+        r.eventMigration("dup", 1, 2, (p) => p);
+      }),
+    ).toThrow(/already registered/);
+  });
+
+  test("r.defineEvent rejects non-positive version", () => {
+    expect(() =>
+      defineFeature("badver", (r) => {
+        r.entity("badver-order", orderEntity);
+        r.defineEvent("neg", z.object({ x: z.number() }), { version: 0 });
+      }),
+    ).toThrow(/positive integer/);
+  });
+});