@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

package/src/pipeline/__tests__/{msp-rebuild.integration.ts → msp-rebuild.integration.test.ts}

@@ -15,12 +15,13 @@
 // carry a different state row (kumiko_event_consumers, not kumiko_projections)
 // and a different apply signature (3rd ctx arg).
 
-import { eq, sql } from "drizzle-orm";
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { sql } from "@cosmicdrift/kumiko-framework/db";
 import { z } from "zod";
 import { integer as pgInteger, table as pgTable, uuid as pgUuid } from "../../db/dialect";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { asRawClient, selectMany, updateMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import {
   eventConsumerStateTable,
@@ -41,13 +42,13 @@ const invoiceEntity = createEntity({
   table: "read_mspreb_invoices",
   fields: { customer: createTextField({ required: true }) },
 });
-const invoiceTable = buildDrizzleTable("msp-reb-invoice", invoiceEntity);
+const invoiceTable = buildEntityTable("msp-reb-invoice", invoiceEntity);
 
 const paymentEntity = createEntity({
   table: "read_mspreb_payments",
   fields: { customer: createTextField({ required: true }) },
 });
-const paymentTable = buildDrizzleTable("msp-reb-payment", paymentEntity);
+const paymentTable = buildEntityTable("msp-reb-payment", paymentEntity);
 
 // Main read-model: running balance per customer.
 const balanceTable = pgTable("read_mspreb_balance", {
@@ -88,33 +89,17 @@ const feature = defineFeature("mspreb", (r) => {
     apply: {
       [invoiceBilled.name]: async (event, tx) => {
         const p = event.payload as { customer: string; cents: number };
-        await tx
-          .insert(balanceTable)
-          .values({
-            customer: p.customer,
-            tenantId: event.tenantId,
-            invoicesCents: p.cents,
-            paymentsCents: 0,
-          })
-          .onConflictDoUpdate({
-            target: balanceTable.customer,
-            set: { invoicesCents: sql`${balanceTable.invoicesCents} + ${p.cents}` },
-          });
+        await asRawClient(tx).unsafe(
+          `INSERT INTO "read_mspreb_balance" (customer, tenant_id, invoices_cents, payments_cents) VALUES ($1::uuid, $2::uuid, $3, 0) ON CONFLICT (customer) DO UPDATE SET invoices_cents = read_mspreb_balance.invoices_cents + $3`,
+          [p.customer, event.tenantId, p.cents],
+        );
       },
       [paymentReceived.name]: async (event, tx) => {
         const p = event.payload as { customer: string; cents: number };
-        await tx
-          .insert(balanceTable)
-          .values({
-            customer: p.customer,
-            tenantId: event.tenantId,
-            invoicesCents: 0,
-            paymentsCents: p.cents,
-          })
-          .onConflictDoUpdate({
-            target: balanceTable.customer,
-            set: { paymentsCents: sql`${balanceTable.paymentsCents} + ${p.cents}` },
-          });
+        await asRawClient(tx).unsafe(
+          `INSERT INTO "read_mspreb_balance" (customer, tenant_id, invoices_cents, payments_cents) VALUES ($1::uuid, $2::uuid, 0, $3) ON CONFLICT (customer) DO UPDATE SET payments_cents = read_mspreb_balance.payments_cents + $3`,
+          [p.customer, event.tenantId, p.cents],
+        );
       },
     },
   });
@@ -248,10 +233,12 @@ describe("rebuildMultiStreamProjection — rebuildable read-model", () => {
     // Disable the saga MSP for this test — it runs on the same event types
     // and would trip its own ctx.appendEvent path during live delivery
     // (which is fine in production, but noise here).
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ status: "disabled", updatedAt: sql`now()` })
-      .where(eq(eventConsumerStateTable.name, SAGA_MSP));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { status: "disabled", updatedAt: sql`now()` },
+      { name: SAGA_MSP },
+    );
 
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: alice, cents: 10_00 }, admin);
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: alice, cents: 5_00 }, admin);
@@ -263,7 +250,7 @@ describe("rebuildMultiStreamProjection — rebuildable read-model", () => {
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: bob, cents: 7_50 }, admin);
     await runFullDispatcher();
 
-    const liveRows = await stack.db.select().from(balanceTable).orderBy(balanceTable.customer);
+    const liveRows = await selectMany(stack.db, balanceTable);
     const aliceLive = liveRows.find((r) => r.customer === alice);
     const bobLive = liveRows.find((r) => r.customer === bob);
     expect(aliceLive).toMatchObject({ invoicesCents: 15_00, paymentsCents: 3_00 });
@@ -279,7 +266,7 @@ describe("rebuildMultiStreamProjection — rebuildable read-model", () => {
     expect(result.eventsProcessed).toBe(4); // 2 invoices + 1 payment + 1 invoice
     expect(result.lastProcessedEventId).toBeGreaterThan(0n);
 
-    const rebuiltRows = await stack.db.select().from(balanceTable).orderBy(balanceTable.customer);
+    const rebuiltRows = await selectMany(stack.db, balanceTable);
     expect(rebuiltRows).toEqual(liveRows);
 
     // Consumer cursor is at head after rebuild — the live dispatcher should
@@ -291,28 +278,29 @@ describe("rebuildMultiStreamProjection — rebuildable read-model", () => {
 
   test("rebuild after table corruption restores the correct state", async () => {
     const carol = "00000000-0000-4000-8000-000000000c03";
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ status: "disabled", updatedAt: sql`now()` })
-      .where(eq(eventConsumerStateTable.name, SAGA_MSP));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { status: "disabled", updatedAt: sql`now()` },
+      { name: SAGA_MSP },
+    );
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: carol, cents: 42_00 }, admin);
     await runFullDispatcher();
 
     // Corrupt the read-model — simulate a buggy apply() landing bad numbers.
-    await stack.db
-      .update(balanceTable)
-      .set({ invoicesCents: -999, paymentsCents: 999 })
-      .where(eq(balanceTable.customer, carol));
+    await updateMany(
+      stack.db,
+      balanceTable,
+      { invoicesCents: -999, paymentsCents: 999 },
+      { customer: carol },
+    );
 
     await rebuildMultiStreamProjection(BALANCE_MSP, {
       db: stack.db,
       registry: stack.registry,
     });
 
-    const [row] = await stack.db
-      .select()
-      .from(balanceTable)
-      .where(eq(balanceTable.customer, carol));
+    const [row] = await selectMany(stack.db, balanceTable, { customer: carol });
     expect(row).toMatchObject({ invoicesCents: 42_00, paymentsCents: 0 });
   });
 });
@@ -339,18 +327,22 @@ describe("rebuildMultiStreamProjection — guard rails", () => {
   test("saga MSP using ctx.appendEvent fails rebuild at the first appendEvent call", async () => {
     const dave = "00000000-0000-4000-8000-000000000d04";
     // Disable the saga in live passes so we control when the apply runs.
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ status: "disabled", updatedAt: sql`now()` })
-      .where(eq(eventConsumerStateTable.name, SAGA_MSP));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { status: "disabled", updatedAt: sql`now()` },
+      { name: SAGA_MSP },
+    );
     await stack.http.writeOk("mspreb:write:invoice:bill", { customer: dave, cents: 1_00 }, admin);
     // Put the consumer back to idle so rebuild doesn't treat it as "just
     // disabled on purpose" — rebuild is opinionated about WHEN it refuses,
     // not about the consumer's live-status.
-    await stack.db
-      .update(eventConsumerStateTable)
-      .set({ status: "idle", updatedAt: sql`now()` })
-      .where(eq(eventConsumerStateTable.name, SAGA_MSP));
+    await updateMany(
+      stack.db,
+      eventConsumerStateTable,
+      { status: "idle", updatedAt: sql`now()` },
+      { name: SAGA_MSP },
+    );
 
     await expect(
       rebuildMultiStreamProjection(SAGA_MSP, {

package/src/pipeline/__tests__/{multi-stream-projection.integration.ts → multi-stream-projection.integration.test.ts}

@@ -6,12 +6,12 @@
 // event-dispatcher — at-least-once delivery, strictly ordered by events.id
 // per MSP consumer, dead-letters on repeated handler failures.
 
-import { eq, sql } from "drizzle-orm";
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { integer as pgInteger, table as pgTable, uuid as pgUuid } from "../../db/dialect";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { asRawClient, selectMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import {
   createTestUser,
@@ -28,13 +28,13 @@ const shipmentEntity = createEntity({
   table: "read_msp_shipments",
   fields: { customer: createTextField({ required: true }) },
 });
-const shipmentTable = buildDrizzleTable("msp-shipment", shipmentEntity);
+const shipmentTable = buildEntityTable("msp-shipment", shipmentEntity);
 
 const refundEntity = createEntity({
   table: "read_msp_refunds",
   fields: { customer: createTextField({ required: true }) },
 });
-const refundTable = buildDrizzleTable("msp-refund", refundEntity);
+const refundTable = buildEntityTable("msp-refund", refundEntity);
 
 // Cross-cutting MSP: one row per customer, sums shipments − refunds. Key
 // differences from a single-stream projection:
@@ -68,41 +68,19 @@ const mspFeature = defineFeature("msptest", (r) => {
     apply: {
       [shipmentBilled.name]: async (event, tx) => {
         const p = event.payload as { customer: string; cents: number };
-        await tx
-          .insert(customerBalanceTable)
-          .values({
-            customer: p.customer,
-            tenantId: event.tenantId,
-            shipments: 1,
-            refunds: 0,
-            netCents: p.cents,
-          })
-          .onConflictDoUpdate({
-            target: customerBalanceTable.customer,
-            set: {
-              shipments: sql`${customerBalanceTable.shipments} + 1`,
-              netCents: sql`${customerBalanceTable.netCents} + ${p.cents}`,
-            },
-          });
+        await asRawClient(tx).unsafe(
+          `INSERT INTO "read_msp_customer_balance" (customer, tenant_id, shipments, refunds, net_cents) VALUES ($1::uuid, $2::uuid, 1, 0, $3) ON CONFLICT (customer) DO UPDATE SET shipments = read_msp_customer_balance.shipments + 1, net_cents = read_msp_customer_balance.net_cents + $3`,
+          [p.customer, event.tenantId, p.cents],
+        );
       },
       [refundIssued.name]: async (event, tx) => {
         const p = event.payload as { customer: string; cents: number };
-        await tx
-          .insert(customerBalanceTable)
-          .values({
-            customer: p.customer,
-            tenantId: event.tenantId,
-            shipments: 0,
-            refunds: 1,
-            netCents: -p.cents,
-          })
-          .onConflictDoUpdate({
-            target: customerBalanceTable.customer,
-            set: {
-              refunds: sql`${customerBalanceTable.refunds} + 1`,
-              netCents: sql`${customerBalanceTable.netCents} - ${p.cents}`,
-            },
-          });
+        // -$3 ohne cast wird vom planner als "unary minus on unknown type"
+        // mehrdeutig — wir casten $3 explizit auf integer.
+        await asRawClient(tx).unsafe(
+          `INSERT INTO "read_msp_customer_balance" (customer, tenant_id, shipments, refunds, net_cents) VALUES ($1::uuid, $2::uuid, 0, 1, -$3::integer) ON CONFLICT (customer) DO UPDATE SET refunds = read_msp_customer_balance.refunds + 1, net_cents = read_msp_customer_balance.net_cents - $3::integer`,
+          [p.customer, event.tenantId, p.cents],
+        );
       },
     },
   });
@@ -207,10 +185,7 @@ describe("r.multiStreamProjection — Marten MultiStreamProjection equivalent",
     // Drain the dispatcher — MSPs run async.
     await stack.eventDispatcher?.runOnce();
 
-    const rows = await stack.db
-      .select()
-      .from(customerBalanceTable)
-      .orderBy(customerBalanceTable.customer);
+    const rows = await selectMany(stack.db, customerBalanceTable);
     const byCustomer = new Map(rows.map((r) => [r.customer, r]));
 
     expect(byCustomer.get(customerA)).toMatchObject({
@@ -239,10 +214,7 @@ describe("r.multiStreamProjection — Marten MultiStreamProjection equivalent",
     expect(pass2?.byConsumer[mspName]?.processed ?? 0).toBe(0);
 
     // Row state is stable across the no-op pass.
-    const [row] = await stack.db
-      .select()
-      .from(customerBalanceTable)
-      .where(eq(customerBalanceTable.customer, cust));
+    const [row] = await selectMany(stack.db, customerBalanceTable, { customer: cust });
     expect(row?.shipments).toBe(1);
     expect(row?.netCents).toBe(42);
   });
@@ -273,10 +245,7 @@ describe("r.multiStreamProjection — Marten MultiStreamProjection equivalent",
     );
     await stack.eventDispatcher?.runOnce();
 
-    const rows = await stack.db
-      .select()
-      .from(customerBalanceTable)
-      .orderBy(customerBalanceTable.customer);
+    const rows = await selectMany(stack.db, customerBalanceTable);
     const alpha = rows.find((r) => r.customer === customerAlpha);
     const beta = rows.find((r) => r.customer === customerBeta);
 
@@ -298,10 +267,7 @@ describe("r.multiStreamProjection — Marten MultiStreamProjection equivalent",
 
     // Only the shipment-billed event was folded in; the auto "created"
     // event was silently skipped.
-    const [row] = await stack.db
-      .select()
-      .from(customerBalanceTable)
-      .where(eq(customerBalanceTable.customer, cust));
+    const [row] = await selectMany(stack.db, customerBalanceTable, { customer: cust });
     expect(row?.shipments).toBe(1);
   });
 });

package/src/pipeline/__tests__/{perf-rebuild.integration.ts → perf-rebuild.integration.test.ts}

@@ -13,27 +13,25 @@
 // jitter does not. If this ever flakes in CI, drop to 3000 — the goal is
 // "catastrophic regression detector", not "perf SLO".
 
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
-import {
-  integer as drizzleInteger,
-  table as drizzlePgTable,
-  uuid as drizzleUuid,
-} from "../../db/dialect";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { integer, table as pgTable, uuid as pgUuid } from "../../db/dialect";
+import { asRawClient } from "../../db/query";
 import { createEntity, createRegistry, createTextField, defineFeature } from "../../engine";
 import type { ProjectionDefinition } from "../../engine/types";
 import { createEventsTable } from "../../event-store";
 import { createProjectionStateTable, rebuildProjection } from "../../pipeline";
-import { createTestDb, type TestDb, TestUsers, unsafePushTables } from "../../stack";
+import { TestUsers, unsafePushTables } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { generateId as uuid } from "../../utils";
 
 // Counter projection: every task.created bumps a counter, every
 // task.updated is a no-op. Enough to exercise the apply path —
 // rebuild cost is dominated by event iteration + apply dispatch,
 // not the projection state shape.
-const taskCountTable = drizzlePgTable("read_perf_rebuild_task_count", {
-  tenantId: drizzleUuid("tenant_id").primaryKey(),
-  count: drizzleInteger("count").notNull().default(0),
+const taskCountTable = pgTable("read_perf_rebuild_task_count", {
+  tenantId: pgUuid("tenant_id").primaryKey(),
+  count: integer("count").notNull().default(0),
 });
 
 const taskCountProjection: ProjectionDefinition = {
@@ -42,13 +40,10 @@ const taskCountProjection: ProjectionDefinition = {
   table: taskCountTable,
   apply: {
     "task.created": async (event, tx) => {
-      await tx
-        .insert(taskCountTable)
-        .values({ tenantId: event.tenantId, count: 1 })
-        .onConflictDoUpdate({
-          target: taskCountTable.tenantId,
-          set: { count: sql`${taskCountTable.count} + 1` },
-        });
+      await asRawClient(tx).unsafe(
+        `INSERT INTO "read_perf_rebuild_task_count" (tenant_id, count) VALUES ($1, 1) ON CONFLICT (tenant_id) DO UPDATE SET count = read_perf_rebuild_task_count.count + 1`,
+        [event.tenantId],
+      );
     },
     "task.updated": async (_event, _tx) => {
       // No-op apply — measuring event-iteration overhead, not per-event
@@ -69,11 +64,12 @@ const feature = defineFeature("perfrebuild", (r) => {
 });
 
 const admin = TestUsers.admin;
-let testDb: TestDb;
+let testDb: BunTestDb;
 const registry = createRegistry([feature]);
 const qualifiedProjectionName = "perfrebuild:projection:task-count";
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await createEventsTable(testDb.db);
   await createProjectionStateTable(testDb.db);
@@ -85,8 +81,8 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(
-    sql`TRUNCATE kumiko_events, read_perf_rebuild_task_count, kumiko_projections RESTART IDENTITY CASCADE`,
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_perf_rebuild_task_count, kumiko_projections RESTART IDENTITY CASCADE`,
   );
 });
 
@@ -96,25 +92,31 @@ beforeEach(async () => {
 async function seedEvents(count: number, depth: number): Promise<void> {
   const userId = uuid();
   // v1 creates
-  await testDb.db.execute(sql`
+  await asRawClient(testDb.db).unsafe(
+    `
     INSERT INTO kumiko_events (aggregate_id, aggregate_type, tenant_id, version, type, payload, metadata, created_by)
-    SELECT gen_random_uuid(), 'task', ${admin.tenantId}::uuid, 1, 'task.created',
+    SELECT gen_random_uuid(), 'task', $1::uuid, 1, 'task.created',
            jsonb_build_object('title', 'Task ' || gs.n),
-           jsonb_build_object('userId', ${userId}::text),
-           ${userId}::text
-      FROM generate_series(1, ${count}) AS gs(n);
-  `);
+           jsonb_build_object('userId', $2::text),
+           $3::text
+      FROM generate_series(1, $4) AS gs(n);
+  `,
+    [admin.tenantId, userId, userId, count],
+  );
   // v2..depth updates
   for (let v = 2; v <= depth; v++) {
-    await testDb.db.execute(sql`
+    await asRawClient(testDb.db).unsafe(
+      `
       INSERT INTO kumiko_events (aggregate_id, aggregate_type, tenant_id, version, type, payload, metadata, created_by)
-      SELECT e.aggregate_id, 'task', ${admin.tenantId}::uuid, ${v}, 'task.updated',
-             jsonb_build_object('title', 'Task v' || ${v}),
-             jsonb_build_object('userId', ${userId}::text),
-             ${userId}::text
+      SELECT e.aggregate_id, 'task', $1::uuid, $2, 'task.updated',
+             jsonb_build_object('title', 'Task v' || $3),
+             jsonb_build_object('userId', $4::text),
+             $5::text
         FROM kumiko_events e
-       WHERE e.aggregate_type = 'task' AND e.version = ${v - 1};
-    `);
+       WHERE e.aggregate_type = 'task' AND e.version = $6;
+    `,
+      [admin.tenantId, v, v, userId, userId, v - 1],
+    );
   }
 }
 

package/src/pipeline/__tests__/{post-query-hook.integration.ts → post-query-hook.integration.test.ts}

@@ -9,7 +9,7 @@
 // Memory `feedback_no_fake_dispatcher`: real HTTP-Calls via setupTestStack,
 // nicht createTestDispatcher.
 
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import type { PostQueryHookFn } from "../../engine/types";

package/src/pipeline/__tests__/{projection-rebuild.integration.ts → projection-rebuild.integration.test.ts}

@@ -10,15 +10,11 @@
 //   - status lifecycle (idle → rebuilding → idle on success, → failed on throw)
 //   - never-rebuilt projection has sensible default state
 
-import { eq, sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
-import {
-  integer as drizzleInteger,
-  table as drizzlePgTable,
-  uuid as drizzleUuid,
-} from "../../db/dialect";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { integer, table as pgTable, uuid } 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,
@@ -54,23 +50,19 @@ const itemEntity = createEntity({
   },
   softDelete: true,
 });
-const itemTable = buildDrizzleTable("rebuild-item", itemEntity);
+const itemTable = buildEntityTable("rebuild-item", itemEntity);
 
-const itemsPerGroupTable = drizzlePgTable("read_rebuild_items_per_group", {
-  groupId: drizzleUuid("group_id").primaryKey(),
-  tenantId: drizzleUuid("tenant_id").notNull(),
-  itemCount: drizzleInteger("item_count").notNull().default(0),
+const itemsPerGroupTable = pgTable("read_rebuild_items_per_group", {
+  groupId: uuid("group_id").primaryKey(),
+  tenantId: uuid("tenant_id").notNull(),
+  itemCount: integer("item_count").notNull().default(0),
 });
 
 async function bump(tx: unknown, groupId: string, tenantId: string, delta: number): Promise<void> {
-  // biome-ignore lint/suspicious/noExplicitAny: tx is DbRunner
-  await (tx as any)
-    .insert(itemsPerGroupTable)
-    .values({ groupId, tenantId, itemCount: delta })
-    .onConflictDoUpdate({
-      target: itemsPerGroupTable.groupId,
-      set: { itemCount: sql`${itemsPerGroupTable.itemCount} + ${delta}` },
-    });
+  await asRawClient(tx).unsafe(
+    `INSERT INTO "read_rebuild_items_per_group" (group_id, tenant_id, item_count) VALUES ($1::uuid, $2::uuid, $3) ON CONFLICT (group_id) DO UPDATE SET item_count = read_rebuild_items_per_group.item_count + $3`,
+    [groupId, tenantId, delta],
+  );
 }
 
 type ItemCreated = { groupId: string };
@@ -121,8 +113,8 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(
-    sql`TRUNCATE kumiko_events, read_rebuild_items, read_rebuild_items_per_group, kumiko_projections RESTART IDENTITY CASCADE`,
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_rebuild_items, read_rebuild_items_per_group, kumiko_projections RESTART IDENTITY CASCADE`,
   );
 });
 
@@ -138,10 +130,7 @@ async function appendCreatedEvent(groupId: string, name: string): Promise<void>
 }
 
 async function getCount(groupId: string): Promise<number | undefined> {
-  const [row] = await testDb.db
-    .select()
-    .from(itemsPerGroupTable)
-    .where(eq(itemsPerGroupTable.groupId, groupId));
+  const [row] = await selectMany(testDb.db, itemsPerGroupTable, { groupId: groupId });
   return row?.itemCount;
 }
 
@@ -174,9 +163,11 @@ describe("rebuildProjection — happy path", () => {
     await appendCreatedEvent(group, "b");
 
     // Seed the projection table with a stale/wrong value.
-    await testDb.db
-      .insert(itemsPerGroupTable)
-      .values({ groupId: group, tenantId: admin.tenantId, itemCount: 999 });
+    await insertOne(testDb.db, itemsPerGroupTable, {
+      groupId: group,
+      tenantId: admin.tenantId,
+      itemCount: 999,
+    });
 
     const result = await rebuildProjection(qualifiedProjectionName, {
       db: testDb.db,

package/src/pipeline/__tests__/{query-projection.integration.ts → query-projection.integration.test.ts}

@@ -3,7 +3,7 @@
 // drizzle-tables directly. Auto-filters by tenant_id when the projection
 // table carries that column.
 
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { z } from "zod";
 import {
   integer as pgInteger,
@@ -12,7 +12,8 @@ import {
   uuid as pgUuid,
 } from "../../db/dialect";
 import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { insertOne } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField, defineFeature } from "../../engine";
 import {
   resetEventStore,
@@ -26,7 +27,7 @@ const widgetEntity = createEntity({
   table: "read_qp_widgets",
   fields: { name: createTextField({ required: true }) },
 });
-const widgetTable = buildDrizzleTable("qp-widget", widgetEntity);
+const widgetTable = buildEntityTable("qp-widget", widgetEntity);
 
 // Tenant-scoped projection — auto-filter by tenant_id.
 const tenantScopedTable = pgTable("read_qp_widget_count_tenant", {
@@ -52,7 +53,7 @@ const qpFeature = defineFeature("qp", (r) => {
     apply: {
       "qp-widget.created": async (event, tx) => {
         const p = event.payload as { name?: string };
-        await tx.insert(tenantScopedTable).values({
+        await insertOne(tx, tenantScopedTable, {
           widgetId: event.aggregateId,
           tenantId: event.tenantId,
           label: p.name ?? "?",
@@ -68,7 +69,7 @@ const qpFeature = defineFeature("qp", (r) => {
     apply: {
       "qp-widget.created": async (event, tx) => {
         const p = event.payload as { name?: string };
-        await tx.insert(systemScopedTable).values({
+        await insertOne(tx, systemScopedTable, {
           widgetId: event.aggregateId,
           label: p.name ?? "?",
         });

package/src/pipeline/__tests__/{redis-pipeline.integration.ts → redis-pipeline.integration.test.ts}

@@ -1,5 +1,6 @@
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { createTestRedis, type TestRedis } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { createEntityCache } from "../entity-cache";
 import { createEventDedup } from "../event-dedup";
 import { createIdempotencyGuard } from "../idempotency";
@@ -7,6 +8,7 @@ import { createIdempotencyGuard } from "../idempotency";
 let testRedis: TestRedis;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testRedis = await createTestRedis();
 });