@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

package/src/files/__tests__/{storage-tracking.integration.ts → storage-tracking.integration.test.ts}

@@ -8,10 +8,11 @@
 //   3. The table column types survive round-trip (bigint → number via
 //      Drizzle's mode:"number", so arithmetic in assertions Just Works).
 
-import { eq, sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { asRawClient, selectMany } from "../../db/query";
 import type { SessionUser } from "../../engine";
 import { createTestUser, setupTestStack, type TestStack, TestUsers } from "../../stack";
+import { buildMultipartBody, patchFileInstanceofForBunTest } from "../../testing";
 import {
   createInMemoryFileProvider,
   filesStorageTrackingFeature,
@@ -36,6 +37,7 @@ const SMALL = new Uint8Array([0x89, 0x50, 0x4e, 0x47, ...Array(16).fill(0)]); //
 const LARGE = new Uint8Array([0x89, 0x50, 0x4e, 0x47, ...Array(96).fill(0)]); // 100 bytes
 
 beforeAll(async () => {
+  patchFileInstanceofForBunTest();
   provider = createInMemoryFileProvider();
   stack = await setupTestStack({
     features: [filesStorageTrackingFeature],
@@ -54,8 +56,8 @@ beforeEach(async () => {
   // each test starts from zero. kumiko_event_consumers registration is
   // re-asserted below; truncating it forces ensureRegistered to seed the
   // cursor at event.id = 0.
-  await stack.db.execute(
-    sql`TRUNCATE kumiko_events, kumiko_event_consumers, file_refs, read_tenant_storage_usage RESTART IDENTITY CASCADE`,
+  await asRawClient(stack.db).unsafe(
+    `TRUNCATE kumiko_events, kumiko_event_consumers, file_refs, read_tenant_storage_usage RESTART IDENTITY CASCADE`,
   );
   await stack.eventDispatcher?.ensureRegistered();
 });
@@ -64,23 +66,20 @@ async function upload(user: SessionUser, name: string, content: Uint8Array): Pro
   const token = await stack.jwt.sign(user);
   const formData = new FormData();
   formData.append("file", new File([Buffer.from(content)], name, { type: "image/png" }));
+  const { body: multipartBody, contentType } = await buildMultipartBody(formData);
   const res = await stack.app.request("/api/files", {
     method: "POST",
-    headers: { Authorization: `Bearer ${token}` },
-    body: formData,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+    body: multipartBody,
   });
   expect(res.status).toBe(201);
 }
 
 async function usageFor(tenantId: string): Promise<{ totalBytes: number; fileCount: number }> {
-  const [row] = await stack.db
-    .select({
-      totalBytes: tenantStorageUsageTable.totalBytes,
-      fileCount: tenantStorageUsageTable.fileCount,
-    })
-    .from(tenantStorageUsageTable)
-    .where(eq(tenantStorageUsageTable.tenantId, tenantId));
-  return row ?? { totalBytes: 0, fileCount: 0 };
+  const [row] = await selectMany(stack.db, tenantStorageUsageTable, { tenantId });
+  return row
+    ? { totalBytes: Number(row["totalBytes"]) ?? 0, fileCount: Number(row["fileCount"]) ?? 0 }
+    : { totalBytes: 0, fileCount: 0 };
 }
 
 describe("tenant-storage-usage MSP", () => {
@@ -105,10 +104,7 @@ describe("tenant-storage-usage MSP", () => {
 
     // Exactly one row per tenant — the UPSERT must not insert a second
     // row for the second upload.
-    const rows = await stack.db
-      .select()
-      .from(tenantStorageUsageTable)
-      .where(eq(tenantStorageUsageTable.tenantId, admin.tenantId));
+    const rows = await selectMany(stack.db, tenantStorageUsageTable, { tenantId: admin.tenantId });
     expect(rows).toHaveLength(1);
   });
 
@@ -128,11 +124,10 @@ describe("tenant-storage-usage MSP", () => {
     await upload(admin, "a.png", SMALL);
     await stack.eventDispatcher?.runOnce();
 
-    const [first] = await stack.db
-      .select({ at: tenantStorageUsageTable.lastUpdatedAt })
-      .from(tenantStorageUsageTable)
-      .where(eq(tenantStorageUsageTable.tenantId, admin.tenantId));
-    expect(first?.at).toBeInstanceOf(Temporal.Instant);
+    const [first] = await selectMany(stack.db, tenantStorageUsageTable, {
+      tenantId: admin.tenantId,
+    });
+    expect(first?.["lastUpdatedAt"]).toBeInstanceOf(Temporal.Instant);
 
     // Postgres NOW() resolution is microseconds; a second upload a beat
     // later must produce a strictly later timestamp (or at least not an
@@ -142,12 +137,13 @@ describe("tenant-storage-usage MSP", () => {
     await upload(admin, "b.png", LARGE);
     await stack.eventDispatcher?.runOnce();
 
-    const [second] = await stack.db
-      .select({ at: tenantStorageUsageTable.lastUpdatedAt })
-      .from(tenantStorageUsageTable)
-      .where(eq(tenantStorageUsageTable.tenantId, admin.tenantId));
-    expect(second?.at).toBeInstanceOf(Temporal.Instant);
-    if (!first?.at || !second?.at) throw new Error("missing rows");
-    expect(Temporal.Instant.compare(second.at, first.at)).toBeGreaterThanOrEqual(0);
+    const [second] = await selectMany(stack.db, tenantStorageUsageTable, {
+      tenantId: admin.tenantId,
+    });
+    expect(second?.["lastUpdatedAt"]).toBeInstanceOf(Temporal.Instant);
+    if (!first?.["lastUpdatedAt"] || !second?.["lastUpdatedAt"]) throw new Error("missing rows");
+    expect(
+      Temporal.Instant.compare(second["lastUpdatedAt"], first["lastUpdatedAt"]),
+    ).toBeGreaterThanOrEqual(0);
   });
 });

package/src/files/__tests__/write-stream.test.ts

@@ -12,10 +12,10 @@
 // AsyncIterable-source pinst die Streaming-Semantik (Caller streamt
 // chunk-fuer-chunk, Provider niemals alles im Memory).
 
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { createInMemoryFileProvider } from "../in-memory-provider";
 import { createLocalProvider } from "../local-provider";
 

package/src/files/__tests__/zip-stream.test.ts

@@ -11,11 +11,11 @@
 //      kann — kein "passt nur in unserer eigenen reverse-engineerten
 //      Welt".
 
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { spawn } from "node:child_process";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { getTemporal } from "../../time";
 import { createZipStream, type ZipEntry } from "../zip-stream";
 

package/src/files/file-ref-table.ts

@@ -1,5 +1,5 @@
-import { sql } from "drizzle-orm";
-import { instant, integer, table as pgTable, text, uuid } from "../db/dialect";
+// sql now comes from native dialect
+import { instant, integer, table as pgTable, sql, text, uuid } from "../db/dialect";
 
 // `id` is a UUID (not serial): it doubles as the aggregate-id for the
 // `fileRef` event stream — every upload appends exactly one

package/src/files/file-routes.ts

@@ -1,8 +1,8 @@
-import { and, eq } from "drizzle-orm";
+import { deleteMany, selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { Hono } from "hono";
 import { z } from "zod";
 import { getUser } from "../api/auth-middleware";
-import type { DbConnection } from "../db/connection";
+import type { DbConnection, DbTx } from "../db/connection";
 import type { EventDef } from "../engine/types";
 import { isFileField, type Registry, type SessionUser, type TenantId } from "../engine/types";
 import { append as appendEvent } from "../event-store/event-store";
@@ -172,8 +172,9 @@ export function createFileRoutes(options: FileRoutesOptions): Hono {
     // Atomic: insert FileRef + append files:event:uploaded in one tx. Either
     // both land or neither — no dangling FileRef without event, no event
     // referencing a row that doesn't exist.
-    await db.transaction(async (tx) => {
-      await tx.insert(fileRefsTable).values({
+    await db.begin(async (tx: DbTx) => {
+      const { insertOne } = await import("../bun-db/query");
+      await insertOne(tx, fileRefsTable, {
         id: fileRefId,
         tenantId: user.tenantId,
         storageKey,
@@ -271,7 +272,7 @@ export function createFileRoutes(options: FileRoutesOptions): Hono {
     // Upload. Umgekehrt liesse ein storage-success + db-fail eine Row mit
     // permanent-broken Reference zurück — aus Sicht der API "Datei
     // existiert" aber jeder Read 404t aus dem Provider.
-    await db.delete(fileRefsTable).where(eq(fileRefsTable.id, id));
+    await deleteMany(db, fileRefsTable, { id: id });
     await storageProvider.delete(fileRef.storageKey);
     return c.json({ ok: true });
   });
@@ -342,10 +343,7 @@ export function createFileRoutes(options: FileRoutesOptions): Hono {
   });
 
   async function loadFileForTenant(id: string, tenantId: TenantId): Promise<FileRef | null> {
-    const [row] = await db
-      .select()
-      .from(fileRefsTable)
-      .where(and(eq(fileRefsTable.id, id), eq(fileRefsTable.tenantId, tenantId)));
+    const [row] = await selectMany(db, fileRefsTable, { id, tenantId });
     return (row as FileRef | undefined) ?? null; // @cast-boundary db-row
   }
 

package/src/files/storage-tracking.ts

@@ -10,8 +10,8 @@
 // consumer-cursor row. Apps that want it pass filesStorageTrackingFeature
 // into createApp / setupTestStack alongside their domain features.
 
-import { sql } from "drizzle-orm";
-import { bigint, instant, integer, table as pgTable, uuid } from "../db/dialect";
+import { bigint, instant, integer, table as pgTable, sql, uuid } from "../db/dialect";
+import { incrementCounter } from "../db/query";
 import { defineFeature, typedPayload } from "../engine";
 import { fileUploadedEvent } from "./file-routes";
 
@@ -39,21 +39,13 @@ export const filesStorageTrackingFeature = defineFeature("files-storage-tracking
         // The SQL increment guarantees correctness under concurrent dispatcher
         // runs (shouldn't happen with a single consumer, but the invariant is
         // free and cheap — no reason to rely on serial delivery).
-        await tx
-          .insert(tenantStorageUsageTable)
-          .values({
-            tenantId: event.tenantId,
-            totalBytes: payload.size,
-            fileCount: 1,
-          })
-          .onConflictDoUpdate({
-            target: tenantStorageUsageTable.tenantId,
-            set: {
-              totalBytes: sql`${tenantStorageUsageTable.totalBytes} + ${payload.size}`,
-              fileCount: sql`${tenantStorageUsageTable.fileCount} + 1`,
-              lastUpdatedAt: sql`NOW()`,
-            },
-          });
+        await incrementCounter(
+          tx,
+          tenantStorageUsageTable,
+          { tenantId: event.tenantId, totalBytes: payload.size, fileCount: 1 },
+          { totalBytes: payload.size, fileCount: 1 },
+          { set: { lastUpdatedAt: sql`now()` } },
+        );
       },
     },
   });

package/src/i18n/__tests__/i18n.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createEntity, createRegistry, createTextField, defineFeature } from "../../engine";
 import { createI18n } from "../index";
 

package/src/jobs/__tests__/{job-event-trigger.integration.ts → job-event-trigger.integration.test.ts}

@@ -1,10 +1,12 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import type { Hono } from "hono";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { z } from "zod";
 import { buildServer, type JwtHelper } from "../../api";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
 import { createRegistry, defineFeature, type SessionUser } from "../../engine";
-import { createTestDb, createTestRedis, type TestDb, type TestRedis, TestUsers } from "../../stack";
+import { createTestRedis, type TestRedis, TestUsers } from "../../stack";
 import { waitFor } from "../../testing";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { createJobRunner, type JobRunner } from "../job-runner";
 
 // --- Track job executions ---
@@ -64,7 +66,7 @@ const analyticsFeature = defineFeature("analytics", (r) => {
 
 // --- Setup ---
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let testRedis: TestRedis;
 let app: Hono;
 let jwt: JwtHelper;
@@ -74,6 +76,7 @@ const adminUser = TestUsers.admin;
 const JWT_SECRET = "event-trigger-test-secret-minimum-32-chars!!";
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   testRedis = await createTestRedis();
 

package/src/jobs/__tests__/{job-multi-trigger.integration.ts → job-multi-trigger.integration.test.ts}

@@ -6,13 +6,15 @@
 // Validator-Reject). Hier prüfen wir die runtime-dispatch-Pfade durch
 // einen echten BullMQ-Worker.
 
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import type { Hono } from "hono";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { z } from "zod";
 import { buildServer, type JwtHelper } from "../../api";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
 import { createRegistry, defineFeature, type SessionUser } from "../../engine";
-import { createTestDb, createTestRedis, type TestDb, type TestRedis, TestUsers } from "../../stack";
+import { createTestRedis, type TestRedis, TestUsers } from "../../stack";
 import { waitFor } from "../../testing";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { createJobRunner, type JobRunner } from "../job-runner";
 
 const jobExecutions: Array<{ trigger: string; payload: Record<string, unknown> }> = [];
@@ -48,7 +50,7 @@ const orderFeature = defineFeature("multi", (r) => {
   );
 });
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let testRedis: TestRedis;
 let app: Hono;
 let jwt: JwtHelper;
@@ -58,6 +60,7 @@ const adminUser = TestUsers.admin;
 const JWT_SECRET = "multi-trigger-test-secret-minimum-32-chars!!";
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   testRedis = await createTestRedis();
 

package/src/jobs/__tests__/{jobs.integration.ts → jobs.integration.test.ts}

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { requestContext } from "../../api/request-context";
 import { createRegistry, defineFeature } from "../../engine";
 import type { AppContext, Registry } from "../../engine/types";
@@ -192,7 +192,7 @@ describe("scenario 2: scheduled job", () => {
 
   // BullMQ's repeatable scheduler needs a second or two to register its
   // first tick — a generous delay schedule covers the startup window.
-  test("cron job fires via BullMQ scheduler", { timeout: 15_000 }, async () => {
+  test("cron job fires via BullMQ scheduler", async () => {
     clearLog();
     await withRunner(async () => {
       await waitFor(
@@ -278,7 +278,7 @@ describe("concurrency: skip", () => {
 });
 
 describe("concurrency: sequential", () => {
-  test("same-name dispatches run strictly one after the other", { timeout: 15_000 }, async () => {
+  test("same-name dispatches run strictly one after the other", async () => {
     clearLog();
     await withRunner(async (runner) => {
       // Three rapid dispatches. Parallel mode would land all entries
@@ -318,7 +318,7 @@ describe("concurrency: sequential", () => {
     });
   });
 
-  test("lock is released even when the handler throws", { timeout: 10_000 }, async () => {
+  test("lock is released even when the handler throws", async () => {
     clearLog();
     await withRunner(async (runner) => {
       // First dispatch fails. If the finally-path didn't release the lock,
@@ -355,9 +355,7 @@ describe("concurrency: sequential", () => {
     });
   });
 
-  test("lock release is value-matched: foreign tokens survive expiration races", {
-    timeout: 5_000,
-  }, async () => {
+  test("lock release is value-matched: foreign tokens survive expiration races", async () => {
     // Pin the contract that distributed-lock's release script enforces:
     // a release call from a worker whose token has already expired and
     // been claimed by someone else must NOT delete the new owner's lock.

package/src/lifecycle/__tests__/{lifecycle-server.integration.ts → lifecycle-server.integration.test.ts}

@@ -1,7 +1,7 @@
 // Full-stack proof for lifecycle ↔ buildServer wiring.
 // Drives drain() directly — SIGTERM plumbing has its own unit test.
 
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { defineFeature } from "../../engine";
 import { setupTestStack, type TestStack } from "../../stack";
 import { sharedWidgetEntity } from "../../testing";

package/src/lifecycle/__tests__/lifecycle.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import { createLifecycle } from "../lifecycle";
 
 describe("lifecycle — state machine", () => {
@@ -20,7 +20,7 @@ describe("lifecycle — state machine", () => {
 
   test("markReady from 'ready' is a no-op", () => {
     const lc = createLifecycle({ startReady: true });
-    const listener = vi.fn();
+    const listener = mock();
     lc.onStateChange(listener);
     lc.markReady();
     expect(listener).not.toHaveBeenCalled();
@@ -70,7 +70,7 @@ describe("lifecycle — shutdown hooks", () => {
   });
 
   test("one failing hook does not block the others, and the error is logged", async () => {
-    const logger = { error: vi.fn() };
+    const logger = { error: mock() };
     const lc = createLifecycle({ startReady: true, logger });
     const calls: string[] = [];
     lc.registerShutdownHook("healthy-a", async () => {
@@ -171,7 +171,7 @@ describe("lifecycle — onStateChange", () => {
 
   test("unsubscribe stops further callbacks", () => {
     const lc = createLifecycle();
-    const cb = vi.fn();
+    const cb = mock();
     const unsubscribe = lc.onStateChange(cb);
     lc.markReady();
     expect(cb).toHaveBeenCalledTimes(1);
@@ -184,9 +184,9 @@ describe("lifecycle — onStateChange", () => {
   });
 
   test("broken listener does not break others, and the error is logged", () => {
-    const logger = { error: vi.fn() };
+    const logger = { error: mock() };
     const lc = createLifecycle({ logger });
-    const healthy = vi.fn();
+    const healthy = mock();
     lc.onStateChange(() => {
       throw new Error("subscriber exploded");
     });

package/src/lifecycle/__tests__/signal-handlers.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from "vitest";
+import { describe, expect, mock, test } from "bun:test";
 import { createLifecycle } from "../lifecycle";
 import { attachSignalHandlers } from "../signal-handlers";
 import { createTestLifecycle } from "./create-test-lifecycle";
@@ -6,7 +6,7 @@ import { createTestLifecycle } from "./create-test-lifecycle";
 describe("attachSignalHandlers", () => {
   test("SIGTERM triggers drain and calls exit(0)", async () => {
     const lc = createLifecycle({ startReady: true });
-    const exit = vi.fn();
+    const exit = mock();
     const hookCalls: string[] = [];
     lc.registerShutdownHook("spy", async (signal) => {
       hookCalls.push(signal);
@@ -25,7 +25,7 @@ describe("attachSignalHandlers", () => {
 
   test("SIGINT path drains with the right signal label", async () => {
     const lc = createLifecycle({ startReady: true });
-    const exit = vi.fn();
+    const exit = mock();
     const seen: string[] = [];
     lc.registerShutdownHook("spy", async (signal) => {
       seen.push(signal);
@@ -44,7 +44,7 @@ describe("attachSignalHandlers", () => {
 
   test("multiple SIGTERMs still call exit exactly once", async () => {
     const lc = createLifecycle({ startReady: true });
-    const exit = vi.fn();
+    const exit = mock();
     // Slow hook so we can fire additional signals while drain is in-flight.
     lc.registerShutdownHook("slow", async () => {
       await new Promise((r) => setTimeout(r, 30));
@@ -74,7 +74,7 @@ describe("attachSignalHandlers", () => {
         throw new Error("drain itself exploded");
       },
     });
-    const exit = vi.fn();
+    const exit = mock();
     const handle = attachSignalHandlers(brokenLifecycle, { exit, signals: ["SIGTERM"] });
     try {
       process.emit("SIGTERM");
@@ -87,7 +87,7 @@ describe("attachSignalHandlers", () => {
 
   test("detach() removes the process listeners", () => {
     const lc = createLifecycle({ startReady: true });
-    const exit = vi.fn();
+    const exit = mock();
     const before = process.listenerCount("SIGTERM");
     const handle = attachSignalHandlers(lc, { exit, signals: ["SIGTERM"] });
     expect(process.listenerCount("SIGTERM")).toBe(before + 1);

package/src/logging/__tests__/pino-trace-bridge.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "bun:test";
 import { createConsoleProvider } from "../../observability";
 import { mergeTraceFields } from "../pino-logger";
 

package/src/migrations/__tests__/compare-snapshots.test.ts

@@ -3,7 +3,7 @@
 // Projection-Tabelle muss der Detector die richtigen Tabellen-Namen
 // melden, damit migrate apply den richtigen Rebuild triggert.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { compareSnapshots } from "../projection-detection";
 import type { Snapshot, SnapshotTable } from "../schema-drift";
 

package/src/migrations/__tests__/{detect-drift.integration.ts → detect-drift.integration.test.ts}

@@ -4,18 +4,20 @@
 // hier blockiert Container-Starts; jeder False-Negative lässt
 // Schema-Drift unentdeckt durch.
 
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { sql } from "drizzle-orm";
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "vitest";
-import { createTestDb, type TestDb } from "../../stack";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { detectDrift } from "../schema-drift";
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let migrationsDir: string;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
 });
 
@@ -82,8 +84,8 @@ function writeSnapshotSimple(idx: number, tableNames: string[]): void {
 }
 
 async function ensureDrizzleMigrationsTable(): Promise<void> {
-  await testDb.db.execute(sql`CREATE SCHEMA IF NOT EXISTS drizzle`);
-  await testDb.db.execute(sql`
+  await asRawClient(testDb.db).unsafe(`CREATE SCHEMA IF NOT EXISTS drizzle`);
+  await asRawClient(testDb.db).unsafe(`
     CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
       id serial PRIMARY KEY,
       hash text NOT NULL,
@@ -93,12 +95,13 @@ async function ensureDrizzleMigrationsTable(): Promise<void> {
 }
 
 async function dropDrizzleMigrationsTable(): Promise<void> {
-  await testDb.db.execute(sql`DROP TABLE IF EXISTS drizzle.__drizzle_migrations`);
+  await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drizzle.__drizzle_migrations`);
 }
 
 async function insertAppliedMigration(hash: string): Promise<void> {
-  await testDb.db.execute(
-    sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES (${hash}, ${Date.now()})`,
+  await asRawClient(testDb.db).unsafe(
+    `INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES ($1, $2)`,
+    [hash, Date.now()],
   );
 }
 
@@ -106,8 +109,8 @@ describe("detectDrift", () => {
   beforeEach(async () => {
     await dropDrizzleMigrationsTable();
     // Cleanup test tables that might still exist from earlier runs
-    await testDb.db.execute(sql`DROP TABLE IF EXISTS drift_test_users`);
-    await testDb.db.execute(sql`DROP TABLE IF EXISTS drift_test_orders`);
+    await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drift_test_users`);
+    await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS drift_test_orders`);
   });
 
   test("frische DB ohne __drizzle_migrations + 1 Migration im Journal → 1 pending + table missing", async () => {
@@ -124,7 +127,7 @@ describe("detectDrift", () => {
   test("alle Migrations applied + alle Tabellen existieren → ok", async () => {
     writeJournal([{ idx: 0, tag: "0000_init" }]);
     writeSnapshotSimple(0, ["drift_test_users"]);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
     await ensureDrizzleMigrationsTable();
     await insertAppliedMigration("hash-0000");
 
@@ -140,8 +143,8 @@ describe("detectDrift", () => {
       { idx: 1, tag: "0001_add_orders" },
     ]);
     writeSnapshotSimple(1, ["drift_test_users", "drift_test_orders"]);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_orders (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_orders (id uuid PRIMARY KEY)`);
     await ensureDrizzleMigrationsTable();
     await insertAppliedMigration("hash-0000"); // nur eine applied
 
@@ -155,7 +158,7 @@ describe("detectDrift", () => {
   test("alle Migrations applied aber Tabelle fehlt manuell → drift", async () => {
     writeJournal([{ idx: 0, tag: "0000_init" }]);
     writeSnapshotSimple(0, ["drift_test_users", "drift_test_orders"]);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
     // drift_test_orders bewusst NICHT angelegt (simuliert manuellen DROP)
     await ensureDrizzleMigrationsTable();
     await insertAppliedMigration("hash-0000");
@@ -179,7 +182,9 @@ describe("detectDrift", () => {
         },
       ]);
       // DB hat email NULLABLE — drift.
-      await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY, email text)`);
+      await asRawClient(testDb.db).unsafe(
+        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, email text)`,
+      );
       await ensureDrizzleMigrationsTable();
       await insertAppliedMigration("hash-0000");
 
@@ -204,7 +209,7 @@ describe("detectDrift", () => {
         },
       ]);
       // DB hat KEINE email-Spalte.
-      await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+      await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
       await ensureDrizzleMigrationsTable();
       await insertAppliedMigration("hash-0000");
 
@@ -226,8 +231,8 @@ describe("detectDrift", () => {
         },
       ]);
       // DB hat zusätzliche Spalte (z.B. manueller ALTER TABLE in Prod).
-      await testDb.db.execute(
-        sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY, secret_legacy text)`,
+      await asRawClient(testDb.db).unsafe(
+        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, secret_legacy text)`,
       );
       await ensureDrizzleMigrationsTable();
       await insertAppliedMigration("hash-0000");
@@ -251,7 +256,9 @@ describe("detectDrift", () => {
         },
       ]);
       // DB hat age als TEXT statt INTEGER.
-      await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY, age text)`);
+      await asRawClient(testDb.db).unsafe(
+        `CREATE TABLE drift_test_users (id uuid PRIMARY KEY, age text)`,
+      );
       await ensureDrizzleMigrationsTable();
       await insertAppliedMigration("hash-0000");
 
@@ -278,7 +285,7 @@ describe("detectDrift", () => {
           },
         },
       ]);
-      await testDb.db.execute(sql`
+      await asRawClient(testDb.db).unsafe(`
         CREATE TABLE drift_test_users (
           id uuid PRIMARY KEY,
           email text NOT NULL,
@@ -297,10 +304,10 @@ describe("detectDrift", () => {
   test("public.__drizzle_migrations Fallback (Pre-0.20-Drizzle)", async () => {
     writeJournal([{ idx: 0, tag: "0000_init" }]);
     writeSnapshotSimple(0, ["drift_test_users"]);
-    await testDb.db.execute(sql`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
+    await asRawClient(testDb.db).unsafe(`CREATE TABLE drift_test_users (id uuid PRIMARY KEY)`);
     // Legacy: Tabelle in public-Schema statt drizzle-Schema
     await dropDrizzleMigrationsTable();
-    await testDb.db.execute(sql`
+    await asRawClient(testDb.db).unsafe(`
       CREATE TABLE public.__drizzle_migrations (
         id serial PRIMARY KEY,
         hash text NOT NULL,
@@ -308,13 +315,14 @@ describe("detectDrift", () => {
       )
     `);
     try {
-      await testDb.db.execute(
-        sql`INSERT INTO public.__drizzle_migrations (hash, created_at) VALUES ('hash-0000', ${Date.now()})`,
+      await asRawClient(testDb.db).unsafe(
+        `INSERT INTO public.__drizzle_migrations (hash, created_at) VALUES ('hash-0000', $1)`,
+        [Date.now()],
       );
       const report = await detectDrift(testDb.db, migrationsDir);
       expect(report.ok).toBe(true);
     } finally {
-      await testDb.db.execute(sql`DROP TABLE public.__drizzle_migrations`);
+      await asRawClient(testDb.db).unsafe(`DROP TABLE public.__drizzle_migrations`);
     }
   });
 });