@cosmicdrift/kumiko-framework 0.14.0 → 0.15.0

package/src/db/__tests__/{tenant-db.integration.ts → tenant-db.integration.test.ts}

@@ -1,5 +1,5 @@
-import { eq } from "drizzle-orm";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { asRawClient, insertOne, selectMany } from "../../db/query";
 import { createBooleanField, createEntity, createTextField } from "../../engine";
 import {
   createTestDb,
@@ -10,7 +10,7 @@ import {
   unsafePushTables,
 } from "../../stack";
 import { table as pgTable, serial, text, timestamp } from "../dialect";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 import { createTenantDb } from "../tenant-db";
 
 // --- Entity table (has tenantId via buildBaseColumns) ---
@@ -25,7 +25,7 @@ const entity = createEntity({
   softDelete: true,
 });
 
-const table = buildDrizzleTable("tenantDbItem", entity);
+const table = buildEntityTable("tenantDbItem", entity);
 
 // --- System table (no tenantId — like job_runs) ---
 
@@ -58,19 +58,16 @@ describe("scoped mode (default)", () => {
     test("auto-injects tenantId into values", async () => {
       const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-      const rows = await tdb.insert(table).values({ name: "Item 1" }).returning();
-      expect(rows[0]?.["tenantId"]).toBe(testTenantId(1));
-      expect(rows[0]?.["name"]).toBe("Item 1");
+      const row = await tdb.insertOne(table, { name: "Item 1" });
+      expect(row?.["tenantId"]).toBe(testTenantId(1));
+      expect(row?.["name"]).toBe("Item 1");
     });
 
     test("cannot override tenantId via values", async () => {
       const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-      const rows = await tdb
-        .insert(table)
-        .values({ name: "Sneaky", tenantId: testTenantId(999) })
-        .returning();
-      expect(rows[0]?.["tenantId"]).toBe(testTenantId(1));
+      const row = await tdb.insertOne(table, { name: "Sneaky", tenantId: testTenantId(999) });
+      expect(row?.["tenantId"]).toBe(testTenantId(1));
     });
   });
 
@@ -79,11 +76,11 @@ describe("scoped mode (default)", () => {
       const tdb1 = createTenantDb(testDb.db, tenant1.tenantId);
       const tdb2 = createTenantDb(testDb.db, tenant2.tenantId);
 
-      await tdb1.insert(table).values({ name: "T1 Scoped" }).returning();
-      await tdb2.insert(table).values({ name: "T2 Scoped" }).returning();
+      await tdb1.insertOne(table, { name: "T1 Scoped" });
+      await tdb2.insertOne(table, { name: "T2 Scoped" });
 
-      const rows1 = await tdb1.select().from(table);
-      const rows2 = await tdb2.select().from(table);
+      const rows1 = await tdb1.selectMany(table);
+      const rows2 = await tdb2.selectMany(table);
 
       expect(rows1.every((r) => r!["tenantId"] === testTenantId(1))).toBe(true);
       expect(rows2.every((r) => r!["tenantId"] === testTenantId(2))).toBe(true);
@@ -92,10 +89,10 @@ describe("scoped mode (default)", () => {
     test("additional where conditions combine with tenant filter", async () => {
       const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-      await tdb.insert(table).values({ name: "findme", status: "active" }).returning();
-      await tdb.insert(table).values({ name: "notme", status: "draft" }).returning();
+      await tdb.insertOne(table, { name: "findme", status: "active" });
+      await tdb.insertOne(table, { name: "notme", status: "draft" });
 
-      const rows = await tdb.select().from(table).where(eq(table["status"], "active"));
+      const rows = await tdb.selectMany(table, { status: "active" });
 
       expect(rows.length).toBeGreaterThanOrEqual(1);
       expect(
@@ -106,12 +103,12 @@ describe("scoped mode (default)", () => {
     test("select with columns", async () => {
       const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-      await tdb.insert(table).values({ name: "ColSelect" }).returning();
+      await tdb.insertOne(table, { name: "ColSelect" });
 
-      const rows = await tdb
-        .select({ id: table["id"], name: table["name"] })
-        .from(table)
-        .where(eq(table["name"], "ColSelect"));
+      const rows = await asRawClient(tdb).unsafe<Record<string, unknown>>(
+        `SELECT id, name FROM "tenant_db_items" WHERE name = $1 LIMIT 10`,
+        ["ColSelect"],
+      );
 
       expect(rows.length).toBeGreaterThanOrEqual(1);
       const row = rows[0]!;
@@ -124,13 +121,10 @@ describe("scoped mode (default)", () => {
       const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
       for (let i = 0; i < 5; i++) {
-        await tdb
-          .insert(table)
-          .values({ name: `Limit${i}` })
-          .returning();
+        await tdb.insertOne(table, { name: `Limit${i}` });
       }
 
-      const rows = await tdb.select().from(table).limit(2);
+      const rows = await tdb.selectMany(table, {}, { limit: 2 });
       expect(rows).toHaveLength(2);
     });
   });
@@ -140,22 +134,14 @@ describe("scoped mode (default)", () => {
       const tdb1 = createTenantDb(testDb.db, tenant1.tenantId);
       const tdb2 = createTenantDb(testDb.db, tenant2.tenantId);
 
-      const [row] = await tdb1.insert(table).values({ name: "T1 Update" }).returning();
+      const row = await tdb1.insertOne(table, { name: "T1 Update" });
       const id = row!["id"] as string;
 
-      const result = await tdb2
-        .update(table)
-        .set({ name: "Hacked" })
-        .where(eq(table["id"], id))
-        .returning();
+      const result = await tdb2.updateMany(table, { name: "Hacked" }, { id: id });
 
       expect(result).toHaveLength(0);
 
-      const [updated] = await tdb1
-        .update(table)
-        .set({ name: "Updated" })
-        .where(eq(table["id"], id))
-        .returning();
+      const [updated] = await tdb1.updateMany(table, { name: "Updated" }, { id: id });
 
       expect(updated!["name"]).toBe("Updated");
     });
@@ -163,12 +149,12 @@ describe("scoped mode (default)", () => {
     test("update without returning", async () => {
       const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-      const [row] = await tdb.insert(table).values({ name: "NoReturn" }).returning();
+      const row = await tdb.insertOne(table, { name: "NoReturn" });
       const id = row!["id"] as string;
 
-      await tdb.update(table).set({ name: "NoReturnUpdated" }).where(eq(table["id"], id));
+      await tdb.updateMany(table, { name: "NoReturnUpdated" }, { id: id });
 
-      const [updated] = await tdb.select().from(table).where(eq(table["id"], id));
+      const [updated] = await tdb.selectMany(table, { id: id });
       expect(updated!["name"]).toBe("NoReturnUpdated");
     });
   });
@@ -178,12 +164,12 @@ describe("scoped mode (default)", () => {
       const tdb1 = createTenantDb(testDb.db, tenant1.tenantId);
       const tdb2 = createTenantDb(testDb.db, tenant2.tenantId);
 
-      const [row] = await tdb1.insert(table).values({ name: "T1 Delete" }).returning();
+      const row = await tdb1.insertOne(table, { name: "T1 Delete" });
       const id = row!["id"] as string;
 
-      await tdb2.delete(table).where(eq(table["id"], id));
+      await tdb2.deleteMany(table, { id: id });
 
-      const rows = await tdb1.select().from(table).where(eq(table["id"], id));
+      const rows = await tdb1.selectMany(table, { id: id });
       expect(rows).toHaveLength(1);
     });
   });
@@ -193,21 +179,17 @@ describe("scoped mode (default)", () => {
       const tdb1 = createTenantDb(testDb.db, tenant1.tenantId);
       const tdb2 = createTenantDb(testDb.db, tenant2.tenantId);
 
-      const [created] = await tdb1.insert(table).values({ name: "Secret" }).returning();
+      const created = await tdb1.insertOne(table, { name: "Secret" });
       const id = created!["id"] as string;
 
-      const seen = await tdb2.select().from(table).where(eq(table["id"], id));
+      const seen = await tdb2.selectMany(table, { id: id });
       expect(seen).toHaveLength(0);
 
-      const updated = await tdb2
-        .update(table)
-        .set({ name: "Hacked" })
-        .where(eq(table["id"], id))
-        .returning();
+      const updated = await tdb2.updateMany(table, { name: "Hacked" }, { id: id });
       expect(updated).toHaveLength(0);
 
-      await tdb2.delete(table).where(eq(table["id"], id));
-      const stillThere = await tdb1.select().from(table).where(eq(table["id"], id));
+      await tdb2.deleteMany(table, { id: id });
+      const stillThere = await tdb1.selectMany(table, { id: id });
       expect(stillThere).toHaveLength(1);
     });
   });
@@ -215,7 +197,7 @@ describe("scoped mode (default)", () => {
   describe("reference data (tenantId = 0)", () => {
     test("scoped select includes rows with tenantId = 0", async () => {
       // Seed reference data with tenantId = 0 (like seedReferenceData does)
-      await testDb.db.insert(table).values({
+      await insertOne(testDb.db, table, {
         name: "GlobalRef",
         status: "ref",
         tenantId: "00000000-0000-4000-8000-000000000000",
@@ -227,15 +209,15 @@ describe("scoped mode (default)", () => {
       const tdb2 = createTenantDb(testDb.db, tenant2.tenantId);
 
       // Both tenants can see the global reference row
-      const rows1 = await tdb1.select().from(table).where(eq(table["name"], "GlobalRef"));
+      const rows1 = await tdb1.selectMany(table, { name: "GlobalRef" });
       expect(rows1).toHaveLength(1);
 
-      const rows2 = await tdb2.select().from(table).where(eq(table["name"], "GlobalRef"));
+      const rows2 = await tdb2.selectMany(table, { name: "GlobalRef" });
       expect(rows2).toHaveLength(1);
     });
 
     test("scoped update does NOT affect tenantId = 0 rows", async () => {
-      await testDb.db.insert(table).values({
+      await insertOne(testDb.db, table, {
         name: "RefNoUpdate",
         status: "ref",
         tenantId: "00000000-0000-4000-8000-000000000000",
@@ -245,25 +227,18 @@ describe("scoped mode (default)", () => {
 
       const tdb1 = createTenantDb(testDb.db, tenant1.tenantId);
 
-      const result = await tdb1
-        .update(table)
-        .set({ name: "Hacked" })
-        .where(eq(table["name"], "RefNoUpdate"))
-        .returning();
+      const result = await tdb1.updateMany(table, { name: "Hacked" }, { name: "RefNoUpdate" });
 
       // Writes from a tenant scope must never touch reference rows (tenantId = 0).
       // Reading them is fine, modifying them is a cross-tenant integrity bug.
       expect(result).toHaveLength(0);
 
-      const [untouched] = await testDb.db
-        .select()
-        .from(table)
-        .where(eq(table["name"], "RefNoUpdate"));
+      const [untouched] = await selectMany(testDb.db, table, { name: "RefNoUpdate" });
       expect(untouched!["name"]).toBe("RefNoUpdate");
     });
 
     test("scoped delete does NOT affect tenantId = 0 rows", async () => {
-      await testDb.db.insert(table).values({
+      await insertOne(testDb.db, table, {
         name: "RefNoDelete",
         status: "ref",
         tenantId: "00000000-0000-4000-8000-000000000000",
@@ -272,12 +247,9 @@ describe("scoped mode (default)", () => {
       });
 
       const tdb1 = createTenantDb(testDb.db, tenant1.tenantId);
-      await tdb1.delete(table).where(eq(table["name"], "RefNoDelete"));
+      await tdb1.deleteMany(table, { name: "RefNoDelete" });
 
-      const [stillThere] = await testDb.db
-        .select()
-        .from(table)
-        .where(eq(table["name"], "RefNoDelete"));
+      const [stillThere] = await selectMany(testDb.db, table, { name: "RefNoDelete" });
       expect(stillThere).toBeDefined();
     });
   });
@@ -292,11 +264,11 @@ describe("system mode (r.systemScope())", () => {
     const scoped1 = createTenantDb(testDb.db, tenant1.tenantId);
     const scoped2 = createTenantDb(testDb.db, tenant2.tenantId);
 
-    await scoped1.insert(table).values({ name: "System-T1" }).returning();
-    await scoped2.insert(table).values({ name: "System-T2" }).returning();
+    await scoped1.insertOne(table, { name: "System-T1" });
+    await scoped2.insertOne(table, { name: "System-T2" });
 
     const systemDb = createTenantDb(testDb.db, tenant1.tenantId, "system");
-    const rows = await systemDb.select().from(table);
+    const rows = await systemDb.selectMany(table);
 
     const tenantIds = new Set(rows.map((r) => r!["tenantId"]));
     // Must see rows from at least 2 different tenants
@@ -307,14 +279,14 @@ describe("system mode (r.systemScope())", () => {
     const systemDb = createTenantDb(testDb.db, tenant1.tenantId, "system");
 
     // Without explicit tenantId — uses the default (tenant1)
-    const [defaultRow] = await systemDb.insert(table).values({ name: "SystemDefault" }).returning();
+    const defaultRow = await systemDb.insertOne(table, { name: "SystemDefault" });
     expect(defaultRow!["tenantId"]).toBe(testTenantId(1));
 
     // With explicit tenantId — handler's value wins
-    const [overrideRow] = await systemDb
-      .insert(table)
-      .values({ name: "SystemOverride", tenantId: testTenantId(99) })
-      .returning();
+    const overrideRow = await systemDb.insertOne(table, {
+      name: "SystemOverride",
+      tenantId: testTenantId(99),
+    });
     expect(overrideRow!["tenantId"]).toBe(testTenantId(99));
   });
 
@@ -326,55 +298,47 @@ describe("system mode (r.systemScope())", () => {
 
     // In scoped mode, tenantId: 77 would be overridden to 1
     const scopedDb = createTenantDb(testDb.db, tenant1.tenantId);
-    const [scopedRow] = await scopedDb
-      .insert(table)
-      .values({ name: "ScopedForce", tenantId: testTenantId(77) })
-      .returning();
+    const scopedRow = await scopedDb.insertOne(table, {
+      name: "ScopedForce",
+      tenantId: testTenantId(77),
+    });
     expect(scopedRow!["tenantId"]).toBe(testTenantId(1)); // forced
 
     // In unscoped mode, explicit tenantId wins
-    const [unscopedRow] = await systemDb
-      .insert(table)
-      .values({ name: "SystemExplicit", tenantId: testTenantId(77) })
-      .returning();
+    const unscopedRow = await systemDb.insertOne(table, {
+      name: "SystemExplicit",
+      tenantId: testTenantId(77),
+    });
     expect(unscopedRow!["tenantId"]).toBe(testTenantId(77)); // handler wins
   });
 
   test("update affects rows from any tenant", async () => {
     const scoped2 = createTenantDb(testDb.db, tenant2.tenantId);
-    const [row] = await scoped2.insert(table).values({ name: "T2-System-Upd" }).returning();
+    const row = await scoped2.insertOne(table, { name: "T2-System-Upd" });
     const id = row!["id"] as string;
 
     // Scoped tenant 1 cannot update tenant 2's row
     const scoped1 = createTenantDb(testDb.db, tenant1.tenantId);
-    const scopedResult = await scoped1
-      .update(table)
-      .set({ name: "ScopedFail" })
-      .where(eq(table["id"], id))
-      .returning();
+    const scopedResult = await scoped1.updateMany(table, { name: "ScopedFail" }, { id: id });
     expect(scopedResult).toHaveLength(0);
 
     // Unscoped CAN update tenant 2's row
     const systemDb = createTenantDb(testDb.db, tenant1.tenantId, "system");
-    const [updated] = await systemDb
-      .update(table)
-      .set({ name: "SystemWin" })
-      .where(eq(table["id"], id))
-      .returning();
-    expect(updated!["name"]).toBe("SystemWin");
+    const updated = await systemDb.updateMany(table, { name: "SystemWin" }, { id: id });
+    expect(updated[0]!["name"]).toBe("SystemWin");
   });
 
   test("delete affects rows from any tenant", async () => {
     const scoped2 = createTenantDb(testDb.db, tenant2.tenantId);
-    const [row] = await scoped2.insert(table).values({ name: "T2-System-Del" }).returning();
+    const row = await scoped2.insertOne(table, { name: "T2-System-Del" });
     const id = row!["id"] as string;
 
     // Unscoped can delete tenant 2's row from tenant 1 context
     const systemDb = createTenantDb(testDb.db, tenant1.tenantId, "system");
-    await systemDb.delete(table).where(eq(table["id"], id));
+    await systemDb.deleteMany(table, { id: id });
 
     // Verify it's gone
-    const remaining = await scoped2.select().from(table).where(eq(table["id"], id));
+    const remaining = await scoped2.selectMany(table, { id: id });
     expect(remaining).toHaveLength(0);
   });
 });
@@ -386,18 +350,18 @@ describe("system mode (r.systemScope())", () => {
 describe("tables without tenantId column", () => {
   test("select returns all rows (no tenant filter)", async () => {
     // Insert two rows via raw db
-    await testDb.db.insert(systemTable).values({ label: "System-A" });
-    await testDb.db.insert(systemTable).values({ label: "System-B" });
+    await insertOne(testDb.db, systemTable, { label: "System-A" });
+    await insertOne(testDb.db, systemTable, { label: "System-B" });
 
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
-    const rows = await tdb.select().from(systemTable);
+    const rows = await tdb.selectMany(systemTable);
     expect(rows.length).toBeGreaterThanOrEqual(2);
   });
 
   test("insert does not inject tenantId", async () => {
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-    const [row] = await tdb.insert(systemTable).values({ label: "NoTenantInjection" }).returning();
+    const row = await tdb.insertOne(systemTable, { label: "NoTenantInjection" });
     const data = row!;
     expect(data["label"]).toBe("NoTenantInjection");
     // No tenantId column at all — should not be in the result
@@ -407,33 +371,33 @@ describe("tables without tenantId column", () => {
   test("select with where works without tenant filter", async () => {
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-    await tdb.insert(systemTable).values({ label: "FindThis" }).returning();
+    await tdb.insertOne(systemTable, { label: "FindThis" });
 
-    const rows = await tdb.select().from(systemTable).where(eq(systemTable["label"], "FindThis"));
+    const rows = await tdb.selectMany(systemTable, { label: "FindThis" });
     expect(rows).toHaveLength(1);
   });
 
   test("update works without tenant filter", async () => {
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-    const [row] = await tdb.insert(systemTable).values({ label: "BeforeUpd" }).returning();
+    const row = await tdb.insertOne(systemTable, { label: "BeforeUpd" });
     const id = row!["id"] as number;
 
-    await tdb.update(systemTable).set({ label: "AfterUpd" }).where(eq(systemTable["id"], id));
+    await tdb.updateMany(systemTable, { label: "AfterUpd" }, { id: id });
 
-    const [updated] = await tdb.select().from(systemTable).where(eq(systemTable["id"], id));
+    const [updated] = await tdb.selectMany(systemTable, { id: id });
     expect(updated!["label"]).toBe("AfterUpd");
   });
 
   test("delete works without tenant filter", async () => {
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
 
-    const [row] = await tdb.insert(systemTable).values({ label: "ToDelete" }).returning();
+    const row = await tdb.insertOne(systemTable, { label: "ToDelete" });
     const id = row!["id"] as number;
 
-    await tdb.delete(systemTable).where(eq(systemTable["id"], id));
+    await tdb.deleteMany(systemTable, { id: id });
 
-    const remaining = await tdb.select().from(systemTable).where(eq(systemTable["id"], id));
+    const remaining = await tdb.selectMany(systemTable, { id: id });
     expect(remaining).toHaveLength(0);
   });
 });
@@ -460,41 +424,41 @@ describe("tenantId property", () => {
 describe("mass-update guard", () => {
   test(".set().returning() without .where() rejects with a clear error", async () => {
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
-    await tdb.insert(table).values({ name: "MassUpdateVictim1" }).returning();
-    await tdb.insert(table).values({ name: "MassUpdateVictim2" }).returning();
+    await tdb.insertOne(table, { name: "MassUpdateVictim1" });
+    await tdb.insertOne(table, { name: "MassUpdateVictim2" });
 
-    await expect(tdb.update(table).set({ name: "Wiped" }).returning()).rejects.toThrow(
-      /without \.where\(\) would mass-update/,
+    // biome-ignore lint/suspicious/noExplicitAny: test cast
+    await expect((tdb as any).updateMany(table, { name: "Wiped" })).rejects.toThrow(
+      /without where would mass-update/,
     );
 
     // Rows must be untouched — the rejection happened before any SQL ran.
-    const untouched = await tdb.select().from(table);
+    const untouched = await tdb.selectMany(table);
     const touched = untouched.filter((r) => r["name"] === "Wiped");
     expect(touched).toHaveLength(0);
   });
 
   test(".set() awaited without .where() rejects too", async () => {
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
-    await tdb.insert(table).values({ name: "AwaitGuardVictim" }).returning();
+    await tdb.insertOne(table, { name: "AwaitGuardVictim" });
 
-    const promise = tdb.update(table).set({ name: "WipedByAwait" }) as unknown as Promise<void>;
-    await expect(promise).rejects.toThrow(/awaited without \.where\(\) would mass-update/);
+    // biome-ignore lint/suspicious/noExplicitAny: test cast
+    const promise = (tdb as any).updateMany(table, {
+      name: "WipedByAwait",
+    }) as unknown as Promise<void>;
+    await expect(promise).rejects.toThrow(/without where would mass-update/);
 
-    const untouched = await tdb.select().from(table);
+    const untouched = await tdb.selectMany(table);
     const touched = untouched.filter((r) => r["name"] === "WipedByAwait");
     expect(touched).toHaveLength(0);
   });
 
   test(".set().where(...).returning() still works (guard only triggers on missing where)", async () => {
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
-    const [row] = await tdb.insert(table).values({ name: "HappyPath" }).returning();
+    const row = await tdb.insertOne(table, { name: "HappyPath" });
     const id = row!["id"] as string;
 
-    const updated = await tdb
-      .update(table)
-      .set({ name: "HappyPathUpdated" })
-      .where(eq(table["id"], id))
-      .returning();
+    const updated = await tdb.updateMany(table, { name: "HappyPathUpdated" }, { id: id });
     expect(updated[0]!["name"]).toBe("HappyPathUpdated");
   });
 });
@@ -514,7 +478,7 @@ describe("pre-flight signal cancellation", () => {
 
     let thrown: unknown;
     try {
-      await tdb.select().from(table);
+      await tdb.selectMany(table);
     } catch (e) {
       thrown = e;
     }
@@ -535,7 +499,7 @@ describe("pre-flight signal cancellation", () => {
 
     let insertThrown: unknown;
     try {
-      await tdb.insert(table).values({ name: "x" }).returning();
+      await tdb.insertOne(table, { name: "x" });
     } catch (e) {
       insertThrown = e;
     }
@@ -543,10 +507,7 @@ describe("pre-flight signal cancellation", () => {
 
     let updateThrown: unknown;
     try {
-      await tdb
-        .update(table)
-        .set({ name: "y" })
-        .where(eq(table["id"], "00000000-0000-0000-0000-000000000001"));
+      await tdb.updateMany(table, { name: "y" }, { id: "00000000-0000-0000-0000-000000000001" });
     } catch (e) {
       updateThrown = e;
     }
@@ -554,7 +515,7 @@ describe("pre-flight signal cancellation", () => {
 
     let deleteThrown: unknown;
     try {
-      await tdb.delete(table).where(eq(table["id"], "00000000-0000-0000-0000-000000000001"));
+      await tdb.deleteMany(table, { id: "00000000-0000-0000-0000-000000000001" });
     } catch (e) {
       deleteThrown = e;
     }
@@ -576,14 +537,14 @@ describe("pre-flight signal cancellation", () => {
       controller.signal,
     );
 
-    const [first] = await tdb.insert(table).values({ name: "preflight-first" }).returning();
+    const first = await tdb.insertOne(table, { name: "preflight-first" });
     expect(first).toBeDefined();
 
     controller.abort();
 
     let secondThrown: unknown;
     try {
-      await tdb.insert(table).values({ name: "preflight-second" }).returning();
+      await tdb.insertOne(table, { name: "preflight-second" });
     } catch (e) {
       secondThrown = e;
     }
@@ -592,7 +553,7 @@ describe("pre-flight signal cancellation", () => {
     // Proves the first row was actually committed and the second never
     // made it — the abort prevented future work, didn't roll back done
     // work.
-    const rows = await testDb.db.select().from(table);
+    const rows = await selectMany(testDb.db, table);
     const names = rows.map((r) => r["name"] as string);
     expect(names).toContain("preflight-first");
     expect(names).not.toContain("preflight-second");
@@ -600,7 +561,8 @@ describe("pre-flight signal cancellation", () => {
 
   test("no signal passed: queries run normally (signal is opt-in)", async () => {
     const tdb = createTenantDb(testDb.db, tenant1.tenantId);
-    const result = await tdb.insert(table).values({ name: "no-signal" }).returning();
-    expect(result).toHaveLength(1);
+    const result = await tdb.insertOne(table, { name: "no-signal" });
+    expect(result).toBeDefined();
+    expect(result?.["name"]).toBe("no-signal");
   });
 });

package/src/db/__tests__/{unique-violation-mapping.integration.ts → unique-violation-mapping.integration.test.ts}

@@ -13,13 +13,15 @@
 // also nicht. Erst die projection-INSERT verletzt den Index. Ohne F8:
 // 500. Mit F8: writeFailure(UniqueViolationError) → 409.
 
-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 { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient, selectMany } from "../../db/query";
 import { createEntity, createTextField } from "../../engine";
 import { createEventsTable } from "../../event-store";
-import { createTestDb, type TestDb, TestUsers, unsafeCreateEntityTable } from "../../stack";
+import { TestUsers, unsafeCreateEntityTable } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { createEventStoreExecutor } from "../event-store-executor";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 import { createTenantDb, type TenantDb } from "../tenant-db";
 
 const userEntity = createEntity({
@@ -39,14 +41,15 @@ const userEntity = createEntity({
     { columns: ["tenantId", "email"], unique: true, name: "read_unique_users_tenant_email_uniq" },
   ],
 });
-const table = buildDrizzleTable("unique-user", userEntity);
+const table = buildEntityTable("unique-user", userEntity);
 const exec = createEventStoreExecutor(table, userEntity, { entityName: "unique-user" });
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let tdb: TenantDb;
 const admin = TestUsers.admin;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await unsafeCreateEntityTable(testDb.db, userEntity, "unique-user");
   await createEventsTable(testDb.db);
@@ -58,7 +61,9 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`TRUNCATE kumiko_events, read_unique_users RESTART IDENTITY CASCADE`);
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_unique_users RESTART IDENTITY CASCADE`,
+  );
 });
 
 // =============================================================================
@@ -98,7 +103,7 @@ describe("F8 — entity-level unique-violation auf create", () => {
       tdb,
     );
     expect(second.isSuccess).toBe(false);
-    const rows = await testDb.db.select().from(table);
+    const rows = await selectMany(testDb.db, table);
     expect(rows).toHaveLength(1);
     expect((rows[0] as { displayName: string }).displayName).toBe("Bob 1");
   });