@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

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-keys.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, test } from "bun:test";
+import { RedisKeys } from "../redis-keys";
+
+describe("RedisKeys", () => {
+  test("uses unique kumiko-prefixed namespaces", () => {
+    const values = Object.values(RedisKeys);
+    expect(new Set(values).size).toBe(values.length);
+    for (const key of values) {
+      expect(key.startsWith("kumiko:")).toBe(true);
+    }
+  });
+});

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();
 });
 

package/src/pipeline/cascade-handler.ts

@@ -1,5 +1,5 @@
-import { eq } from "drizzle-orm";
 import type { TableColumns } from "../db/dialect";
+import { deleteMany, fetchOne, updateMany } from "../db/query";
 import { OnDeleteStrategies, SystemHookNames, SystemHookPriorities } from "../engine/constants";
 import type { PreDeleteHookFn, Registry } from "../engine/types";
 import { ConflictError, FrameworkReasons } from "../errors";
@@ -44,12 +44,8 @@ export function createCascadeDeleteHook(
           if (!targetTable) continue;
 
           if (strategy === OnDeleteStrategies.restrict) {
-            const rows = await db
-              .select({ id: targetTable["id"] })
-              .from(targetTable)
-              .where(eq(targetTable[relation.foreignKey], payload.id))
-              .limit(1);
-            if (rows.length > 0) {
+            const row = await fetchOne(db, targetTable, { [relation.foreignKey]: payload.id });
+            if (row) {
               throw new ConflictError({
                 message: `${relation.target} has records referencing ${entityName}#${payload.id}`,
                 i18nKey: "errors.deleteRestricted",
@@ -64,14 +60,16 @@ export function createCascadeDeleteHook(
           }
 
           if (strategy === OnDeleteStrategies.cascade) {
-            await db.delete(targetTable).where(eq(targetTable[relation.foreignKey], payload.id));
+            await deleteMany(db, targetTable, { [relation.foreignKey]: payload.id });
           }
 
           if (strategy === OnDeleteStrategies.setNull) {
-            await db
-              .update(targetTable)
-              .set({ [relation.foreignKey]: null })
-              .where(eq(targetTable[relation.foreignKey], payload.id));
+            await updateMany(
+              db,
+              targetTable,
+              { [relation.foreignKey]: null },
+              { [relation.foreignKey]: payload.id },
+            );
           }
         }
 
@@ -79,17 +77,11 @@ export function createCascadeDeleteHook(
           const throughTable = tables.get(relation.through.table);
           if (!throughTable) continue;
           // sourceKey points at the owner side (the entity being deleted).
-          // targetKey would point at the other side — filtering by it here
-          // would miss every through-row for this entity.
           const sourceKey = relation.through.sourceKey;
 
           if (strategy === OnDeleteStrategies.restrict) {
-            const rows = await db
-              .select({ id: throughTable["id"] })
-              .from(throughTable)
-              .where(eq(throughTable[sourceKey], payload.id))
-              .limit(1);
-            if (rows.length > 0) {
+            const row = await fetchOne(db, throughTable, { [sourceKey]: payload.id });
+            if (row) {
               throw new ConflictError({
                 message: `${relation.through.table} has records referencing ${entityName}#${payload.id}`,
                 i18nKey: "errors.deleteRestricted",
@@ -104,7 +96,7 @@ export function createCascadeDeleteHook(
           }
 
           if (strategy === OnDeleteStrategies.cascade) {
-            await db.delete(throughTable).where(eq(throughTable[sourceKey], payload.id));
+            await deleteMany(db, throughTable, { [sourceKey]: payload.id });
           }
         }
       }

package/src/pipeline/dispatcher-utils.ts

@@ -6,7 +6,13 @@ import type {
   SessionUser,
   WriteResult,
 } from "../engine/types";
-import { InternalError, isKumikoError, type KumikoError, type WriteErrorInfo } from "../errors";
+import {
+  type FieldIssue,
+  InternalError,
+  isKumikoError,
+  type KumikoError,
+  type WriteErrorInfo,
+} from "../errors";
 
 export type FailedWriteResult = Extract<WriteResult, { isSuccess: false }>;
 
@@ -146,12 +152,7 @@ export function prefixValidationPath(info: WriteErrorInfo, prefix: string): Writ
   if (info.code !== "validation_error") return info;
   const details = info.details as // @cast-boundary error-details
     | {
-        fields?: readonly {
-          path: string;
-          code: string;
-          i18nKey: string;
-          params?: Readonly<Record<string, unknown>>;
-        }[];
+        fields?: readonly FieldIssue[];
       }
     | undefined;
   const fields = details?.fields;