@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

package/src/event-store/__tests__/{upcaster-dead-letter.integration.ts → upcaster-dead-letter.integration.test.ts}

@@ -6,9 +6,10 @@
 //   - 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 { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient, insertOne, selectMany } from "../../db/query";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import type { StoredEvent } from "../event-store";
 import { createEventsTable, eventsTable } from "../events-schema";
 import { type EventUpcasters, makeUpcastCtx, upcastStoredEvents } from "../upcaster";
@@ -18,7 +19,7 @@ import {
   upcasterDeadLetterTable,
 } from "../upcaster-dead-letter";
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 
 const TENANT_ID = "00000000-0000-4000-8000-0000000000aa";
 
@@ -78,6 +79,7 @@ const passthroughUpcasters: EventUpcasters = new Map([
 ]);
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await createEventsTable(testDb.db);
   await createUpcasterDeadLetterTable(testDb.db);
@@ -88,8 +90,8 @@ afterAll(async () => {
 });
 
 afterEach(async () => {
-  await testDb.db.delete(upcasterDeadLetterTable);
-  await testDb.db.delete(eventsTable);
+  await asRawClient(testDb.db).unsafe(`DELETE FROM "${upcasterDeadLetterTable.tableName}"`);
+  await asRawClient(testDb.db).unsafe(`DELETE FROM "${eventsTable.tableName}"`);
 });
 
 describe("upcaster error-policy: throw (default)", () => {
@@ -165,7 +167,7 @@ describe("upcaster error-policy: quarantine", () => {
     );
 
     // Drop one directly to add noise of a different type.
-    await testDb.db.insert(upcasterDeadLetterTable).values({
+    await insertOne(testDb.db, upcasterDeadLetterTable, {
       eventId: "99",
       tenantId: TENANT_ID,
       aggregateId: "other",
@@ -195,10 +197,7 @@ describe("upcaster error-policy: quarantine", () => {
       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);
+    const rows = await selectMany(testDb.db, upcasterDeadLetterTable, { eventId: "30" });
+    expect(rows).toHaveLength(2);
   });
 });

package/src/event-store/__tests__/{upcaster.integration.ts → upcaster.integration.test.ts}

@@ -8,12 +8,12 @@
 //      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 { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 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 { asRawClient, insertOne, selectMany } from "../../db/query";
+import { buildEntityTable } 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";
@@ -36,7 +36,7 @@ const orderEntity = createEntity({
     customer: createTextField({ required: true }),
   },
 });
-const orderTable = buildDrizzleTable("upcast-order", orderEntity);
+const orderTable = buildEntityTable("upcast-order", orderEntity);
 
 // Projection stores the UPCAST view: the v3 shape expects `totalCents` (int)
 // even though the earliest writes might have stored `totalEuros` (string).
@@ -78,18 +78,10 @@ const orderFeature = defineFeature("upcastshop", (r) => {
     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 },
-          });
+        await asRawClient(tx).unsafe(
+          `INSERT INTO "read_upcast_order_summary" (order_id, tenant_id, total_cents, currency) VALUES ($1, $2, $3, $4) ON CONFLICT (order_id) DO UPDATE SET total_cents = $3, currency = $4`,
+          [event.aggregateId, event.tenantId, p.totalCents, p.currency],
+        );
       },
     },
   });
@@ -121,8 +113,8 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(
-    sql`TRUNCATE kumiko_events, read_upcast_orders, read_upcast_order_summary, kumiko_projections RESTART IDENTITY CASCADE`,
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_upcast_orders, read_upcast_order_summary, kumiko_projections RESTART IDENTITY CASCADE`,
   );
 });
 
@@ -280,10 +272,7 @@ describe("upcaster: projection rebuild walks the chain on replay", () => {
     });
     expect(result.eventsProcessed).toBe(3);
 
-    const rows = await testDb.db
-      .select()
-      .from(orderSummaryTable)
-      .orderBy(orderSummaryTable.orderId);
+    const rows = await selectMany(testDb.db, orderSummaryTable);
 
     // Ordered by orderId → ord1 (10€ = 1000¢), ord2 ($25.50 = 2550¢), ord3 (9900¢)
     expect(rows).toHaveLength(3);
@@ -305,9 +294,7 @@ describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () =>
       segment: pgText("segment").notNull(),
     });
     await unsafePushTables(testDb.db, { upcastAsyncCustomerSegments: customerSegments });
-    await testDb.db
-      .insert(customerSegments)
-      .values({ customerId: "c-async-1", segment: "PREMIUM" });
+    await insertOne(testDb.db, customerSegments, { customerId: "c-async-1", segment: "PREMIUM" });
 
     const asyncSummary = pgTable("upcast_async_summary", {
       orderId: pgText("order_id").primaryKey(),
@@ -327,11 +314,11 @@ describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () =>
 
       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" };
+        const [row] = await selectMany(ctx.db, customerSegments, { customerId: p.customerId });
+        return {
+          customerId: p.customerId,
+          segment: (row as { segment?: string } | undefined)?.segment ?? "UNKNOWN",
+        };
       });
 
       r.projection({
@@ -341,7 +328,7 @@ describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () =>
         apply: {
           [placed.name]: async (event, tx) => {
             const p = event.payload as { customerId: string; segment: string };
-            await tx.insert(asyncSummary).values({
+            await insertOne(tx, asyncSummary, {
               orderId: event.aggregateId,
               customerId: p.customerId,
               segment: p.segment,
@@ -384,7 +371,7 @@ describe("upcaster: async (Marten AsyncOnlyEventUpcaster — DB-Lookups)", () =>
     });
     expect(result.eventsProcessed).toBe(2);
 
-    const rows = await testDb.db.select().from(asyncSummary).orderBy(asyncSummary.orderId);
+    const rows = await selectMany(testDb.db, asyncSummary);
     expect(rows).toHaveLength(2);
     const byId = new Map(rows.map((r) => [r.orderId, r]));
     // v1 → v2 via async DB lookup → segment from customer_segments.

package/src/event-store/admin-api.ts

@@ -7,13 +7,18 @@
 // Allowlist: samples/*/migration/, scripts/migrations/, die Definition
 // selbst, das Guard-Script selbst.
 
-import { sql } from "drizzle-orm";
 import type { DbRunner } from "../db";
 import { isUniqueViolation } from "../db/pg-error";
+import {
+  eventPredecessorExists,
+  findExistingEventVersion,
+  insertRawEventBatch,
+  insertRawFirstEvent,
+  insertRawSubsequentEvent,
+} from "../db/queries/event-store-admin";
 import type { TenantId } from "../engine/types";
 import { VersionConflictError } from "./errors";
 import type { EventMetadata } from "./event-store";
-import { eventsTable } from "./events-schema";
 
 export type RawEventToAppend = {
   readonly aggregateId: string;
@@ -55,30 +60,28 @@ export async function appendRaw(runner: DbRunner, event: RawEventToAppend): Prom
   }
 }
 
+function rawEventParams(event: RawEventToAppend, newVersion: number, eventVersion: number) {
+  return {
+    aggregateId: event.aggregateId,
+    aggregateType: event.aggregateType,
+    tenantId: event.tenantId,
+    newVersion,
+    type: event.type,
+    eventVersion,
+    payloadJson: JSON.stringify(event.payload),
+    metadataJson: JSON.stringify(event.metadata),
+    createdAt: event.createdAt.toString(),
+    createdBy: event.createdBy,
+  };
+}
+
 async function insertRawFirst(
   runner: DbRunner,
   event: RawEventToAppend,
   newVersion: number,
   eventVersion: number,
 ): Promise<void> {
-  await runner.execute(sql`
-    INSERT INTO ${eventsTable} (
-      aggregate_id, aggregate_type, tenant_id, version,
-      type, event_version, payload, metadata, created_at, created_by
-    )
-    VALUES (
-      ${event.aggregateId}::uuid,
-      ${event.aggregateType},
-      ${event.tenantId}::uuid,
-      ${newVersion},
-      ${event.type},
-      ${eventVersion},
-      ${JSON.stringify(event.payload)}::jsonb,
-      ${JSON.stringify(event.metadata)}::jsonb,
-      ${event.createdAt.toString()}::timestamptz,
-      ${event.createdBy}
-    )
-  `);
+  await insertRawFirstEvent(runner, rawEventParams(event, newVersion, eventVersion));
 }
 
 async function insertRawSubsequent(
@@ -87,30 +90,11 @@ async function insertRawSubsequent(
   newVersion: number,
   eventVersion: number,
 ): Promise<void> {
-  const rows = await runner.execute<{ id: string }>(sql`
-    INSERT INTO ${eventsTable} (
-      aggregate_id, aggregate_type, tenant_id, version,
-      type, event_version, payload, metadata, created_at, created_by
-    )
-    SELECT ${event.aggregateId}::uuid,
-           ${event.aggregateType},
-           ${event.tenantId}::uuid,
-           ${newVersion},
-           ${event.type},
-           ${eventVersion},
-           ${JSON.stringify(event.payload)}::jsonb,
-           ${JSON.stringify(event.metadata)}::jsonb,
-           ${event.createdAt.toString()}::timestamptz,
-           ${event.createdBy}
-    WHERE EXISTS (
-      SELECT 1 FROM ${eventsTable}
-      WHERE aggregate_id = ${event.aggregateId}::uuid
-        AND version = ${event.expectedVersion}
-        AND tenant_id = ${event.tenantId}::uuid
-    )
-    RETURNING id
-  `);
-  if (rows.length === 0) {
+  const inserted = await insertRawSubsequentEvent(runner, {
+    ...rawEventParams(event, newVersion, eventVersion),
+    expectedVersion: event.expectedVersion,
+  });
+  if (!inserted) {
     throw new VersionConflictError(event.aggregateId, event.expectedVersion);
   }
 }
@@ -133,31 +117,28 @@ export async function appendRawBatch(
   await verifyPredecessors(runner, events);
   await verifyNoDuplicates(runner, events);
 
-  const rows = events.map((e) => {
+  const params: unknown[] = [];
+  const valuesClauses = events.map((e) => {
     const newVersion = e.expectedVersion + 1;
     const eventVersion = e.eventVersion ?? 1;
-    return sql`(
-      ${e.aggregateId}::uuid,
-      ${e.aggregateType},
-      ${e.tenantId}::uuid,
-      ${newVersion},
-      ${e.type},
-      ${eventVersion},
-      ${JSON.stringify(e.payload)}::jsonb,
-      ${JSON.stringify(e.metadata)}::jsonb,
-      ${e.createdAt.toString()}::timestamptz,
-      ${e.createdBy}
-    )`;
+    const baseIdx = params.length;
+    params.push(
+      e.aggregateId,
+      e.aggregateType,
+      e.tenantId,
+      newVersion,
+      e.type,
+      eventVersion,
+      JSON.stringify(e.payload),
+      JSON.stringify(e.metadata),
+      e.createdAt.toString(),
+      e.createdBy,
+    );
+    return `($${baseIdx + 1}::uuid, $${baseIdx + 2}, $${baseIdx + 3}::uuid, $${baseIdx + 4}, $${baseIdx + 5}, $${baseIdx + 6}, $${baseIdx + 7}::jsonb, $${baseIdx + 8}::jsonb, $${baseIdx + 9}::timestamptz, $${baseIdx + 10})`;
   });
 
   try {
-    await runner.execute(sql`
-      INSERT INTO ${eventsTable} (
-        aggregate_id, aggregate_type, tenant_id, version,
-        type, event_version, payload, metadata, created_at, created_by
-      )
-      VALUES ${sql.join(rows, sql`, `)}
-    `);
+    await insertRawEventBatch(runner, valuesClauses.join(", "), params);
   } catch (e) {
     if (isUniqueViolation(e)) {
       // Pre-flight ran but lost a race against a concurrent writer. Rare for
@@ -221,15 +202,8 @@ async function verifyPredecessors(
 
   for (const g of groups.values()) {
     if (g.minExpected === 0) continue;
-    const rows = await runner.execute<{ present: boolean }>(sql`
-      SELECT EXISTS(
-        SELECT 1 FROM ${eventsTable}
-        WHERE aggregate_id = ${g.aggregateId}::uuid
-          AND tenant_id = ${g.tenantId}::uuid
-          AND version = ${g.minExpected}
-      ) AS present
-    `);
-    if (!rows[0]?.present) {
+    const present = await eventPredecessorExists(runner, g.aggregateId, g.tenantId, g.minExpected);
+    if (!present) {
       throw new VersionConflictError(g.aggregateId, g.minExpected);
     }
   }
@@ -242,16 +216,14 @@ async function verifyNoDuplicates(
   runner: DbRunner,
   events: readonly RawEventToAppend[],
 ): Promise<void> {
-  const triples = events.map(
-    (e) => sql`(${e.tenantId}::uuid, ${e.aggregateId}::uuid, ${e.expectedVersion + 1})`,
-  );
-  const rows = await runner.execute<{ aggregate_id: string; version: number }>(sql`
-    SELECT aggregate_id, version FROM ${eventsTable}
-    WHERE (tenant_id, aggregate_id, version) IN (${sql.join(triples, sql`, `)})
-    LIMIT 1
-  `);
-  const conflict = rows[0];
+  const params: unknown[] = [];
+  const tripleClauses = events.map((e) => {
+    const baseIdx = params.length;
+    params.push(e.tenantId, e.aggregateId, e.expectedVersion + 1);
+    return `($${baseIdx + 1}::uuid, $${baseIdx + 2}::uuid, $${baseIdx + 3})`;
+  });
+  const conflict = await findExistingEventVersion(runner, tripleClauses.join(", "), params);
   if (conflict) {
-    throw new VersionConflictError(conflict.aggregate_id, conflict.version - 1);
+    throw new VersionConflictError(conflict.aggregateId, conflict.version - 1);
   }
 }

package/src/event-store/archive.ts

@@ -1,6 +1,9 @@
-import { and, eq, sql } from "drizzle-orm";
+// sql now comes from native dialect
+
 import type { DbConnection, DbRunner } from "../db/connection";
-import { instant, table as pgTable, text, uniqueIndex, uuid } from "../db/dialect";
+import { instant, table as pgTable, sql, text, uniqueIndex, uuid } from "../db/dialect";
+import { upsertArchivedStream } from "../db/queries/event-store";
+import { deleteMany, fetchOne } from "../db/query";
 import { tableExists } from "../db/schema-inspection";
 import type { TenantId } from "../engine/types";
 import { unsafePushTables } from "../stack";
@@ -46,24 +49,13 @@ export type ArchiveStreamArgs = {
 // aggregate) updates archivedAt/archivedBy to the latest call instead of
 // failing. That matches Marten's "archive is a state, not an event" model.
 export async function archiveStream(db: DbRunner, args: ArchiveStreamArgs): Promise<void> {
-  await db
-    .insert(archivedStreamsTable)
-    .values({
-      tenantId: args.tenantId,
-      aggregateId: args.aggregateId,
-      aggregateType: args.aggregateType,
-      archivedBy: args.archivedBy,
-      reason: args.reason ?? null,
-    })
-    .onConflictDoUpdate({
-      target: [archivedStreamsTable.tenantId, archivedStreamsTable.aggregateId],
-      set: {
-        archivedAt: sql`now()`,
-        archivedBy: args.archivedBy,
-        aggregateType: args.aggregateType,
-        reason: args.reason ?? null,
-      },
-    });
+  await upsertArchivedStream(db, {
+    tenantId: args.tenantId,
+    aggregateId: args.aggregateId,
+    aggregateType: args.aggregateType,
+    archivedBy: args.archivedBy,
+    reason: args.reason ?? null,
+  });
 }
 
 // Cheap existence probe — issued in the hot read path, so keep the query to
@@ -73,17 +65,8 @@ export async function isStreamArchived(
   tenantId: TenantId,
   aggregateId: string,
 ): Promise<boolean> {
-  const rows = await db
-    .select({ one: sql`1` })
-    .from(archivedStreamsTable)
-    .where(
-      and(
-        eq(archivedStreamsTable.tenantId, tenantId),
-        eq(archivedStreamsTable.aggregateId, aggregateId),
-      ),
-    )
-    .limit(1);
-  return rows.length > 0;
+  const row = await fetchOne(db, archivedStreamsTable, { tenantId, aggregateId });
+  return row !== undefined;
 }
 
 // Undo an archive — restores the stream to writable state. Ops tool. The
@@ -95,12 +78,5 @@ export async function restoreStream(
   tenantId: TenantId,
   aggregateId: string,
 ): Promise<void> {
-  await db
-    .delete(archivedStreamsTable)
-    .where(
-      and(
-        eq(archivedStreamsTable.tenantId, tenantId),
-        eq(archivedStreamsTable.aggregateId, aggregateId),
-      ),
-    );
+  await deleteMany(db, archivedStreamsTable, { tenantId, aggregateId });
 }