@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

package/src/engine/__tests__/projection-helpers.test.ts

@@ -1,15 +1,19 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import type { StoredEvent } from "../../event-store/event-store";
 import { setFields } from "../projection-helpers";
 import type { ProjectionTable } from "../types/projection";
 
-// Minimal fake table: only the `id` column is needed for setFields, and
-// setFields only hands it to `eq()` — no actual SQL runs in the unit test.
-// The cast mirrors ProjectionTable's deliberate erasure: the framework
-// doesn't know user table shapes at compile time, so real Drizzle tables
-// go through the same `any`-ish generic parameter.
+// Minimal fake table: only the `id` column is needed for setFields, plus
+// the kumiko:schema:Name + kumiko:schema:Columns symbols that bun-db introspects for
+// table-name + column-mapping. We don't run real SQL — unsafe() is mocked.
 const fakeIdCol = { name: "id" };
-const fakeTable = { id: fakeIdCol, __name: "fake_table" } as unknown as ProjectionTable;
+const fakeTable = Object.assign(
+  { id: fakeIdCol },
+  {
+    [Symbol.for("kumiko:schema:Name")]: "fake_table",
+    [Symbol.for("kumiko:schema:Columns")]: { id: fakeIdCol },
+  },
+) as unknown as ProjectionTable;
 
 function makeFakeEvent(overrides: Partial<StoredEvent> = {}): StoredEvent {
   return {
@@ -29,30 +33,34 @@ function makeFakeEvent(overrides: Partial<StoredEvent> = {}): StoredEvent {
   };
 }
 
-// Drizzle's tx.update(...).set(...).where(...) chain — capture each step.
+// bun-db path: setFields calls updateMany(tx, table, set, where) which lands
+// on asRawClient(tx).unsafe(sqlText, params). Capture the SQL + params.
 function makeFakeTx() {
-  const where = vi.fn().mockResolvedValue(undefined);
-  const set = vi.fn(() => ({ where }));
-  const update = vi.fn(() => ({ set }));
-  return { fakeTx: { update } as never, update, set, where };
+  const unsafe = mock(async (_sqlText: string, _params: unknown[]) => [] as unknown[]);
+  const fakeTx = { unsafe, begin: mock() } as never;
+  return { fakeTx, unsafe };
 }
 
 describe("setFields", () => {
   test("returns an apply fn that UPDATEs the passed fields WHERE id = aggregateId", async () => {
     const apply = setFields(fakeTable, { status: "sent" });
-    const { fakeTx, update, set } = makeFakeTx();
+    const { fakeTx, unsafe } = makeFakeTx();
     await apply(makeFakeEvent(), fakeTx);
-    expect(update).toHaveBeenCalledWith(fakeTable);
-    expect(set).toHaveBeenCalledWith({ status: "sent" });
+    expect(unsafe).toHaveBeenCalledTimes(1);
+    const [sqlText, params] = unsafe.mock.calls[0]!;
+    expect(sqlText).toMatch(/UPDATE "fake_table" SET "status" = \$1.*WHERE "id" = \$2/);
+    expect(params).toEqual(["sent", "agg-42"]);
   });
 
   test("fields as a function receives the event and returns the field values", async () => {
     const apply = setFields(fakeTable, (event) => ({
       status: (event.payload as { newStatus: string }).newStatus,
     }));
-    const { fakeTx, set } = makeFakeTx();
+    const { fakeTx, unsafe } = makeFakeTx();
     await apply(makeFakeEvent({ payload: { newStatus: "cancelled" } }), fakeTx);
-    expect(set).toHaveBeenCalledWith({ status: "cancelled" });
+    expect(unsafe).toHaveBeenCalledTimes(1);
+    const [, params] = unsafe.mock.calls[0]!;
+    expect(params).toEqual(["cancelled", "agg-42"]);
   });
 
   test("throws at construction time when the table has no 'id' column", () => {

package/src/engine/__tests__/projection.test.ts

@@ -1,5 +1,5 @@
-import { integer, pgTable, uuid } from "drizzle-orm/pg-core";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
+import { integer, type SchemaTable, table, uuid } from "../../db/dialect";
 import type { ProjectionDefinition } from "../../engine/types";
 import { defineFeature } from "../define-feature";
 import { createEntity, createTextField } from "../factories";
@@ -9,10 +9,10 @@ import { createRegistry } from "../registry";
 // the projection itself (apply, TX semantics) is covered by the MietNomade
 // integration suite; this file focuses on the registrar/registry contracts
 // that fire BEFORE any write happens.
-const testTable = pgTable("test_projection", {
+const testTable = table("test_projection", {
   id: uuid("id").primaryKey(),
   count: integer("count").notNull().default(0),
-});
+}) as unknown as SchemaTable;
 
 function exampleEntity(name = "unit") {
   return createEntity({

package/src/engine/__tests__/qualified-name.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   isKebabSegment,
   isValidQn,

package/src/engine/__tests__/raw-table.test.ts

@@ -2,16 +2,17 @@
 // aggregation. Full DB roundtrip (setupTestStack pushes the table → INSERT
 // / SELECT) lives in src/__tests__/raw-table.integration.ts.
 
-import { pgTable, text } from "drizzle-orm/pg-core";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
+import type { SchemaTable } from "../../db/dialect";
+import { table, text } from "../../db/dialect";
 import { defineFeature } from "../define-feature";
 import { createRegistry } from "../registry";
 import type { ProjectionDefinition } from "../types";
 
-const probeTable = pgTable("rt_probe_table", {
+const probeTable = table("rt_probe_table", {
   id: text("id").primaryKey(),
 });
-const probeTableTwo = pgTable("rt_probe_table_two", {
+const probeTableTwo = table("rt_probe_table_two", {
   id: text("id").primaryKey(),
 });
 
@@ -107,9 +108,9 @@ describe("createRegistry — rawTable aggregation", () => {
     // when one role writes (primary cache) and a second role reads
     // (alias view). Push-time dedupe keeps the boot to a single CREATE;
     // the registry keeps both entries so callers can resolve either name.
-    const sharedT = pgTable("rt_shared_dedupe", {
+    const sharedT = table("rt_shared_dedupe", {
       id: text("id").primaryKey(),
-    });
+    }) as unknown as SchemaTable;
     const feat = defineFeature("dedupe", (r) => {
       r.rawTable("primary", sharedT, { reason: "main writer" });
       r.rawTable("alias", sharedT, { reason: "alias for read consumers" });
@@ -126,9 +127,9 @@ describe("createRegistry — rawTable aggregation", () => {
     // r.projection() is almost always an authoring bug — two owners on
     // the same physical table, one event-sourced, one bypass. Boot
     // throws so the failure points at the misconfiguration site.
-    const sharedT = pgTable("rt_collision_phys", {
+    const sharedT = table("rt_collision_phys", {
       id: text("id").primaryKey(),
-    });
+    }) as unknown as SchemaTable;
     const projection: ProjectionDefinition = {
       name: "shared-summary",
       source: "shared",

package/src/engine/__tests__/resolve-config-or-param.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import { createTenantConfig, createUserConfig } from "../config-helpers";
 import { type ClampInfo, resolveConfigOrParam } from "../resolve-config-or-param";
 import type {
@@ -25,7 +25,7 @@ function makeCtx(entries: Record<string, { def: KeyEntry; fallback: unknown }>)
     getConfigKey: (key: string) => entries[key]?.def,
   } as unknown as Registry;
 
-  const configFn = vi.fn(async <T extends ConfigKeyType>(handle: ConfigKeyHandle<T>) => {
+  const configFn = mock(async <T extends ConfigKeyType>(handle: ConfigKeyHandle<T>) => {
     return entries[handle.name]?.fallback as ConfigValue<T> | undefined;
   });
 
@@ -273,14 +273,14 @@ describe("resolveConfigOrParam — onClamp audit hook", () => {
 
   test("onClamp does NOT fire when value is within bounds", async () => {
     const { ctx } = makeCtx({ k: { def: boundedDef, fallback: 10 } });
-    const onClamp = vi.fn();
+    const onClamp = mock();
     await resolveConfigOrParam(ctx, handleFor("k", "number"), 50, { onClamp });
     expect(onClamp).not.toHaveBeenCalled();
   });
 
   test("onClamp does NOT fire on exact boundary values", async () => {
     const { ctx } = makeCtx({ k: { def: boundedDef, fallback: 10 } });
-    const onClamp = vi.fn();
+    const onClamp = mock();
     await resolveConfigOrParam(ctx, handleFor("k", "number"), 1, { onClamp });
     await resolveConfigOrParam(ctx, handleFor("k", "number"), 100, { onClamp });
     expect(onClamp).not.toHaveBeenCalled();
@@ -288,7 +288,7 @@ describe("resolveConfigOrParam — onClamp audit hook", () => {
 
   test("onClamp does NOT fire when value is coerced to NaN (no clamp happens, config fallback used)", async () => {
     const { ctx } = makeCtx({ k: { def: boundedDef, fallback: 10 } });
-    const onClamp = vi.fn();
+    const onClamp = mock();
     await resolveConfigOrParam(ctx, handleFor("k", "number"), "abc", { onClamp });
     expect(onClamp).not.toHaveBeenCalled();
   });

package/src/engine/__tests__/run-in.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { runsInLane } from "../run-in";
 
 describe("runsInLane", () => {

package/src/engine/__tests__/schema-builder.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   createBooleanField,
   createDateField,

package/src/engine/__tests__/screen.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { validateBoot } from "../boot-validator";
 import { defineFeature } from "../define-feature";
 import { createEntity, createTextField } from "../factories";

package/src/engine/__tests__/search-payload-extension.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createEntity, createRegistry, defineFeature } from "../index";
 import type { SearchPayloadContributorFn } from "../types";
 
@@ -21,7 +21,7 @@ describe("searchPayloadExtension registration", () => {
       r.searchPayloadExtension(thing, noop);
     });
 
-    const entry = feature.searchPayloadExtensions["thing"];
+    const entry = feature.searchPayloadExtensions!["thing"];
     expect(entry).toHaveLength(1);
   });
 
@@ -35,7 +35,7 @@ describe("searchPayloadExtension registration", () => {
       r.searchPayloadExtension(thing, c2);
     });
 
-    expect(feature.searchPayloadExtensions["thing"]).toHaveLength(2);
+    expect(feature.searchPayloadExtensions!["thing"]).toHaveLength(2);
   });
 });
 

package/src/engine/__tests__/state-machine.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { UnprocessableError } from "../../errors";
 import { defineTransitions, guardTransition } from "../state-machine";
 

package/src/engine/__tests__/steps-aggregate-append-event.test.ts

@@ -1,9 +1,9 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import { getStep } from "../define-step";
 import { buildAggregateAppendEventStep } from "../steps/aggregate-append-event";
 import type { PipelineCtx } from "../types/step";
 
-const mockUnsafeAppendEvent = vi.fn();
+const mockUnsafeAppendEvent = mock();
 
 const mockCtx = {
   unsafeAppendEvent: mockUnsafeAppendEvent,
@@ -39,7 +39,7 @@ describe("buildAggregateAppendEventStep", () => {
 
 describe("aggregate.appendEvent run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("calls ctx.unsafeAppendEvent with resolved aggregateId and payload", async () => {
@@ -56,7 +56,7 @@ describe("aggregate.appendEvent run", () => {
       mockCtx,
     );
 
-    expect(mockUnsafeAppendEvent).toHaveBeenCalledOnce();
+    expect(mockUnsafeAppendEvent).toHaveBeenCalledTimes(1);
     const call = mockUnsafeAppendEvent.mock.calls[0]![0];
     expect(call).toMatchObject({
       aggregateId: "abc-123",
@@ -68,9 +68,9 @@ describe("aggregate.appendEvent run", () => {
 
   it("resolves function resolvers before calling unsafeAppendEvent", async () => {
     const stepDef = getStep("aggregate.appendEvent");
-    const idFn = vi.fn(() => "dynamic-id");
-    const payloadFn = vi.fn(() => ({ note: "dynamic" }));
-    const headersFn = vi.fn(() => ({ key: "val" }));
+    const idFn = mock(() => "dynamic-id");
+    const payloadFn = mock(() => ({ note: "dynamic" }));
+    const headersFn = mock(() => ({ key: "val" }));
 
     await stepDef!.run(
       {

package/src/engine/__tests__/steps-aggregate-create.test.ts

@@ -1,10 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import type { EventStoreExecutor } from "../../db/event-store-executor";
 import { getStep } from "../define-step";
 import { buildAggregateCreateStep } from "../steps/aggregate-create";
 import type { PipelineCtx } from "../types/step";
 
-const mockCreate = vi.fn();
+const mockCreate = mock();
 const mockExecutor = { create: mockCreate } as unknown as EventStoreExecutor & {
   create: typeof mockCreate;
 };
@@ -39,7 +39,7 @@ describe("buildAggregateCreateStep", () => {
 
 describe("aggregate.create run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("resolves data and calls executor.create with user and db", async () => {
@@ -64,7 +64,7 @@ describe("aggregate.create run", () => {
 
   it("resolves a function data resolver before calling executor.create", async () => {
     const stepDef = getStep("aggregate.create");
-    const dataFn = vi.fn((ctx: PipelineCtx) => ({
+    const dataFn = mock((ctx: PipelineCtx) => ({
       label: (ctx.event.payload as { label: string }).label,
     }));
     mockExecutor.create.mockResolvedValue({

package/src/engine/__tests__/steps-aggregate-update.test.ts

@@ -1,10 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import type { EventStoreExecutor } from "../../db/event-store-executor";
 import { getStep } from "../define-step";
 import { buildAggregateUpdateStep } from "../steps/aggregate-update";
 import type { PipelineCtx } from "../types/step";
 
-const mockUpdate = vi.fn();
+const mockUpdate = mock();
 const mockExecutor = { update: mockUpdate } as unknown as EventStoreExecutor & {
   update: typeof mockUpdate;
 };
@@ -61,7 +61,7 @@ describe("buildAggregateUpdateStep", () => {
 
 describe("aggregate.update run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("resolves id, changes, version and calls executor.update", async () => {

package/src/engine/__tests__/steps-call-feature.test.ts

@@ -1,10 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import { getStep } from "../define-step";
 import { buildCallFeatureStep } from "../steps/call-feature";
 import type { PipelineCtx } from "../types/step";
 
-const mockWrite = vi.fn();
-const mockWriteAs = vi.fn();
+const mockWrite = mock();
+const mockWriteAs = mock();
 
 const mockCtx = {
   write: mockWrite,
@@ -37,7 +37,7 @@ describe("buildCallFeatureStep", () => {
 
 describe("callFeature run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("calls ctx.write with the resolved payload and handler name", async () => {
@@ -64,7 +64,7 @@ describe("callFeature run", () => {
 
   it("resolves a function payload resolver before calling ctx.write", async () => {
     const stepDef = getStep("callFeature");
-    const payloadFn = vi.fn((ctx: PipelineCtx) => ({
+    const payloadFn = mock((ctx: PipelineCtx) => ({
       title: (ctx.event.payload as { title: string }).title,
     }));
     mockWrite.mockResolvedValue({

package/src/engine/__tests__/steps-mail-send.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 import { getStep } from "../define-step";
 import {
   STEP_DISPATCH_AGGREGATE_TYPE,
@@ -7,7 +7,7 @@ import {
 import { buildMailSendStep } from "../steps/mail-send";
 import type { PipelineCtx } from "../types/step";
 
-const mockUnsafeAppendEvent = vi.fn();
+const mockUnsafeAppendEvent = mock();
 
 const mockCtx = {
   unsafeAppendEvent: mockUnsafeAppendEvent,
@@ -61,7 +61,7 @@ describe("buildMailSendStep", () => {
 
 describe("mail.send run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
   });
 
   it("appends a step.dispatch-requested system event with the mail spec", async () => {
@@ -78,7 +78,7 @@ describe("mail.send run", () => {
       mockCtx,
     );
 
-    expect(mockUnsafeAppendEvent).toHaveBeenCalledOnce();
+    expect(mockUnsafeAppendEvent).toHaveBeenCalledTimes(1);
     const eventArg = mockUnsafeAppendEvent.mock.calls[0]![0];
 
     expect(eventArg.aggregateType).toBe(STEP_DISPATCH_AGGREGATE_TYPE);
@@ -93,9 +93,9 @@ describe("mail.send run", () => {
 
   it("resolves function-based resolvers", async () => {
     const stepDef = getStep("mail.send");
-    const toFn = vi.fn(() => "resolved@example.com");
-    const subjectFn = vi.fn(() => "Resolved Subject");
-    const bodyFn = vi.fn(() => "Resolved Body");
+    const toFn = mock(() => "resolved@example.com");
+    const subjectFn = mock(() => "Resolved Subject");
+    const bodyFn = mock(() => "Resolved Body");
 
     await stepDef!.run({ to: toFn, subject: subjectFn, body: bodyFn, mode: "deferred" }, mockCtx);
 

package/src/engine/__tests__/steps-read.test.ts

@@ -1,36 +1,27 @@
-import type { SQL } from "drizzle-orm";
-import { pgTable, text, uuid } from "drizzle-orm/pg-core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, mock } from "bun:test";
+import { table, text, uuid } from "../../db/dialect";
 import { getStep } from "../define-step";
 import { buildReadFindManyStep } from "../steps/read-find-many";
 import { buildReadFindOneStep } from "../steps/read-find-one";
 import type { PipelineCtx } from "../types/step";
 
-const testTable = pgTable("test_read", {
+const testTable = table("test_read", {
   id: uuid("id").primaryKey().defaultRandom(),
   tenantId: uuid("tenant_id").notNull(),
   label: text("label"),
 });
 
-class MockQuery {
-  rows: Record<string, unknown>[] = [];
-  where = vi.fn(() => this);
-  limit = vi.fn(() => this);
-  // biome-ignore lint/suspicious/noThenProperty: mock query builder is intentionally thenable so await resolves rows
-  then: Promise<Record<string, unknown>[]>["then"];
-
-  constructor(rows?: Record<string, unknown>[]) {
-    if (rows) this.rows = rows;
-    const promise = Promise.resolve(this.rows);
-    // biome-ignore lint/suspicious/noThenProperty: see above
-    this.then = promise.then.bind(promise);
-  }
-}
-
-const mockDb = { select: vi.fn(() => ({ from: vi.fn(() => new MockQuery([])) })) };
+// bun-db path: read-find-many/one call selectMany(ctx.db.raw, table, where, opts)
+// which goes through asRawClient(ctx.db.raw).unsafe(sqlText, params).
+// Mock the .unsafe() return value to feed back rows.
+const unsafeMock = mock(
+  async (_sqlText: string, _params: unknown[]): Promise<Record<string, unknown>[]> => [],
+);
+const rawDb = { unsafe: unsafeMock, begin: mock() };
+const ctxDb = { raw: rawDb };
 
 const mockCtx = {
-  db: mockDb,
+  db: ctxDb,
   event: { type: "test", payload: {} },
   steps: {},
   scope: {},
@@ -40,7 +31,7 @@ describe("buildReadFindOneStep", () => {
   it("returns a StepInstance with kind read.findOne", () => {
     const step = buildReadFindOneStep("myLookup", {
       table: testTable,
-      where: undefined as unknown as SQL,
+      where: { id: "x" },
     });
     expect(step.kind).toBe("read.findOne");
     expect((step.args as { name: string }).name).toBe("myLookup");
@@ -49,7 +40,7 @@ describe("buildReadFindOneStep", () => {
   it("stores the result key from the name arg", () => {
     const step = buildReadFindOneStep("lookupResult", {
       table: testTable,
-      where: undefined as unknown as SQL,
+      where: { id: "x" },
     });
     const def = getStep("read.findOne");
     expect(def?.resultKey?.(step.args as { name: string })).toBe("lookupResult");
@@ -58,16 +49,16 @@ describe("buildReadFindOneStep", () => {
 
 describe("read.findOne run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
+    unsafeMock.mockResolvedValue([]);
   });
 
   it("returns null when no row is found", async () => {
     const stepDef = getStep("read.findOne");
-    const query = new MockQuery([]);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    unsafeMock.mockResolvedValueOnce([]);
 
     const result = await stepDef!.run(
-      { name: "lookup", table: testTable, where: undefined as unknown as SQL },
+      { name: "lookup", table: testTable, where: { id: "x" } },
       mockCtx,
     );
 
@@ -77,11 +68,10 @@ describe("read.findOne run", () => {
   it("returns the first row when found", async () => {
     const stepDef = getStep("read.findOne");
     const row = { id: "abc", tenantId: "t1", label: "hello" };
-    const query = new MockQuery([row]);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    unsafeMock.mockResolvedValueOnce([row]);
 
     const result = await stepDef!.run(
-      { name: "lookup", table: testTable, where: undefined as unknown as SQL },
+      { name: "lookup", table: testTable, where: { id: "abc" } },
       mockCtx,
     );
 
@@ -90,14 +80,17 @@ describe("read.findOne run", () => {
 
   it("resolves a function where-clause before querying", async () => {
     const stepDef = getStep("read.findOne");
-    const whereFn = vi.fn(() => "dynamic where" as unknown as SQL);
-    const query = new MockQuery([]);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    const whereFn = mock(() => ({ tenantId: "dyn-tenant" }));
+    unsafeMock.mockResolvedValueOnce([]);
 
     await stepDef!.run({ name: "lookup", table: testTable, where: whereFn }, mockCtx);
 
     expect(whereFn).toHaveBeenCalledWith(mockCtx);
-    expect(query.where).toHaveBeenCalledWith("dynamic where");
+    expect(unsafeMock).toHaveBeenCalledTimes(1);
+    const [sqlText, params] = unsafeMock.mock.calls[0]!;
+    expect(sqlText).toMatch(/SELECT \* FROM "test_read"/);
+    expect(sqlText).toMatch(/"tenant_id" = \$1/);
+    expect(params).toEqual(["dyn-tenant"]);
   });
 });
 
@@ -116,13 +109,13 @@ describe("buildReadFindManyStep", () => {
 
 describe("read.findMany run", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mock.clearAllMocks();
+    unsafeMock.mockResolvedValue([]);
   });
 
   it("returns an empty array when no rows exist", async () => {
     const stepDef = getStep("read.findMany");
-    const query = new MockQuery([]);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    unsafeMock.mockResolvedValueOnce([]);
 
     const result = await stepDef!.run({ name: "list", table: testTable }, mockCtx);
 
@@ -132,11 +125,12 @@ describe("read.findMany run", () => {
   it("applies the limit when specified", async () => {
     const stepDef = getStep("read.findMany");
     const rows = [{ id: "a" }, { id: "b" }];
-    const query = new MockQuery(rows);
-    mockDb.select.mockReturnValue({ from: vi.fn().mockReturnValue(query) });
+    unsafeMock.mockResolvedValueOnce(rows);
 
     await stepDef!.run({ name: "list", table: testTable, limit: 2 }, mockCtx);
 
-    expect(query.limit).toHaveBeenCalledWith(2);
+    expect(unsafeMock).toHaveBeenCalledTimes(1);
+    const [sqlText] = unsafeMock.mock.calls[0]!;
+    expect(sqlText).toMatch(/LIMIT 2/);
   });
 });

package/src/engine/__tests__/steps-resolver-utils.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, mock } from "bun:test";
 import { resolveOptional, resolveRequired } from "../steps/_resolver-utils";
 import type { PipelineCtx } from "../types/step";
 
@@ -13,15 +13,15 @@ describe("resolveRequired", () => {
   });
 
   it("calls a function resolver with the ctx and returns its result", () => {
-    const fn = vi.fn((_ctx: PipelineCtx) => "from-fn");
+    const fn = mock((_ctx: PipelineCtx) => "from-fn");
     expect(resolveRequired(fn, dummyCtx)).toBe("from-fn");
-    expect(fn).toHaveBeenCalledOnce();
+    expect(fn).toHaveBeenCalledTimes(1);
     expect(fn).toHaveBeenCalledWith(dummyCtx);
   });
 
   it("passes the full ctx to the resolver function", () => {
     const ctx = { event: { type: "test" }, steps: { x: 1 }, scope: {} } as unknown as PipelineCtx;
-    const fn = vi.fn((c: PipelineCtx) => c.event.type);
+    const fn = mock((c: PipelineCtx) => c.event.type);
     expect(resolveRequired(fn, ctx)).toBe("test");
   });
 });
@@ -39,9 +39,9 @@ describe("resolveOptional", () => {
   });
 
   it("calls a function resolver when defined", () => {
-    const fn = vi.fn(() => "resolved");
+    const fn = mock(() => "resolved");
     expect(resolveOptional(fn, dummyCtx)).toBe("resolved");
-    expect(fn).toHaveBeenCalledOnce();
+    expect(fn).toHaveBeenCalledTimes(1);
   });
 
   it("returns undefined for undefined function resolver", () => {