@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

package/src/event-store/snapshot.ts

@@ -1,4 +1,5 @@
-import { and, desc, eq, sql } from "drizzle-orm";
+// sql now comes from native dialect
+
 import type { DbConnection, DbRunner } from "../db/connection";
 import {
   index,
@@ -7,9 +8,12 @@ import {
   jsonb,
   table as pgTable,
   primaryKey,
+  sql,
   text,
   uuid,
 } from "../db/dialect";
+import { upsertSnapshot } from "../db/queries/event-store";
+import { selectMany } from "../db/query";
 import { tableExists } from "../db/schema-inspection";
 import type { TenantId } from "../engine/types";
 import { unsafePushTables } from "../stack";
@@ -98,23 +102,13 @@ export type SaveSnapshotArgs = {
 // bespoke error handling — useful when a feature's snapshot policy runs
 // during a concurrent retake.
 export async function saveSnapshot(db: DbRunner, args: SaveSnapshotArgs): Promise<void> {
-  await db
-    .insert(snapshotsTable)
-    .values({
-      aggregateId: args.aggregateId,
-      tenantId: args.tenantId,
-      aggregateType: args.aggregateType,
-      version: args.version,
-      state: args.state,
-    })
-    .onConflictDoUpdate({
-      target: [snapshotsTable.aggregateId, snapshotsTable.version],
-      set: {
-        state: args.state,
-        aggregateType: args.aggregateType,
-        createdAt: sql`now()`,
-      },
-    });
+  await upsertSnapshot(db, {
+    aggregateId: args.aggregateId,
+    tenantId: args.tenantId,
+    aggregateType: args.aggregateType,
+    version: args.version,
+    stateJson: JSON.stringify(args.state),
+  });
 }
 
 // Latest snapshot lookup. Tenant filter is belt-and-suspenders — the
@@ -123,12 +117,20 @@ export async function saveSnapshot(db: DbRunner, args: SaveSnapshotArgs): Promis
 export async function loadLatestSnapshot<
   TState extends Record<string, unknown> = Record<string, unknown>,
 >(db: DbRunner, aggregateId: string, tenantId: TenantId): Promise<Snapshot<TState> | null> {
-  const rows = await db
-    .select()
-    .from(snapshotsTable)
-    .where(and(eq(snapshotsTable.aggregateId, aggregateId), eq(snapshotsTable.tenantId, tenantId)))
-    .orderBy(desc(snapshotsTable.version))
-    .limit(1);
+  type SnapRow = {
+    aggregateId: string;
+    tenantId: TenantId;
+    aggregateType: string;
+    version: number;
+    state: unknown;
+    createdAt: Temporal.Instant;
+  };
+  const rows = await selectMany<SnapRow>(
+    db,
+    snapshotsTable,
+    { aggregateId, tenantId },
+    { orderBy: { col: "version", direction: "desc" }, limit: 1 },
+  );
   const row = rows[0];
   if (!row) return null;
   return {

package/src/event-store/upcaster-dead-letter.ts

@@ -12,8 +12,17 @@
 // ops tooling. Replay (re-apply the migration after a code fix) is a
 // separate CLI step — not implemented here, tracked as follow-up.
 
-import { bigint, index, integer, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
 import type { DbConnection, DbRunner } from "../db/connection";
+import {
+  bigint,
+  index,
+  integer,
+  jsonb,
+  table as pgTable,
+  text,
+  timestamp,
+  uuid,
+} from "../db/dialect";
 import { tableExists } from "../db/schema-inspection";
 import { unsafePushTables } from "../stack";
 import type { StoredEvent } from "./event-store";
@@ -66,7 +75,8 @@ export async function recordUpcasterDeadLetter(
   },
 ): Promise<void> {
   const message = args.error instanceof Error ? args.error.message : String(args.error);
-  await db.insert(upcasterDeadLetterTable).values({
+  const { insertOne } = await import("../bun-db/query");
+  await insertOne(db, upcasterDeadLetterTable, {
     eventId: args.event.id,
     tenantId: args.event.tenantId,
     aggregateId: args.event.aggregateId,
@@ -99,21 +109,12 @@ export async function listDeadLetters(
   db: DbConnection,
   options: { eventType?: string; limit?: number } = {},
 ): Promise<readonly DeadLetterRow[]> {
-  const { desc, eq } = await import("drizzle-orm");
+  const { selectMany } = await import("../bun-db/query");
   const limit = options.limit ?? 100;
-  const eventType = options.eventType;
-  const rows =
-    eventType !== undefined
-      ? await db
-          .select()
-          .from(upcasterDeadLetterTable)
-          .where(eq(upcasterDeadLetterTable.eventType, eventType))
-          .orderBy(desc(upcasterDeadLetterTable.createdAt))
-          .limit(limit)
-      : await db
-          .select()
-          .from(upcasterDeadLetterTable)
-          .orderBy(desc(upcasterDeadLetterTable.createdAt))
-          .limit(limit);
-  return rows as readonly DeadLetterRow[]; // @cast-boundary db-row
+  const where = options.eventType !== undefined ? { eventType: options.eventType } : undefined;
+  const rows = await selectMany<DeadLetterRow>(db, upcasterDeadLetterTable, where, {
+    orderBy: { col: "createdAt", direction: "desc" },
+    limit,
+  });
+  return rows;
 }

package/src/files/__tests__/content-disposition.test.ts

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

package/src/files/__tests__/{file-field-pipeline.integration.ts → file-field-pipeline.integration.test.ts}

@@ -12,11 +12,11 @@
 //   POST /api/write → entity:update with new file-UUID
 //   POST /api/query → entity:detail → new UUID persisted
 
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { asRawClient } from "../../db/query";
 import {
   createEntity,
   createFileField,
@@ -36,6 +36,7 @@ import {
   testTenantId,
   unsafeCreateEntityTable,
 } from "../../stack";
+import { buildMultipartBody, patchFileInstanceofForBunTest } from "../../testing";
 import { createLocalProvider } from "../local-provider";
 
 // Covers ALL four file-field variants: singular (file/image) stores a UUID in
@@ -69,6 +70,7 @@ const tenantId = testTenantId(1);
 const user = createTestUser({ id: 1, tenantId, roles: ["Admin"] });
 
 beforeAll(async () => {
+  patchFileInstanceofForBunTest();
   storagePath = await mkdtemp(join(tmpdir(), "kumiko-file-field-pipeline-"));
   stack = await setupTestStack({
     features: [documentFeature],
@@ -83,17 +85,18 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await stack.db.execute(sql`TRUNCATE pipeline_documents`);
+  await asRawClient(stack.db).unsafe(`TRUNCATE pipeline_documents`);
 });
 
 async function uploadFile(fileName: string, body: Uint8Array, mimeType: string): Promise<string> {
   const token = await stack.jwt.sign(user);
   const fd = new FormData();
   fd.append("file", new File([Buffer.from(body)], fileName, { type: mimeType }));
+  const { body: multipartBody, contentType } = await buildMultipartBody(fd);
   const res = await stack.app.request("/api/files", {
     method: "POST",
-    headers: { Authorization: `Bearer ${token}` },
-    body: fd,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+    body: multipartBody,
   });
   // File-routes return 201 Created on successful upload.
   expect(res.status).toBe(201);

package/src/files/__tests__/file-handle.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createFileContext, createFileHandle, deriveKey } from "../file-handle";
 import { createInMemoryFileProvider } from "../in-memory-provider";
 

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

@@ -1,8 +1,8 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { Hono } from "hono";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import type { JwtHelper } from "../../api/jwt";
 import { buildServer } from "../../api/server";
 import {
@@ -22,7 +22,11 @@ import {
   unsafeCreateEntityTable,
   unsafePushTables,
 } from "../../stack";
-import { expectErrorIncludes } from "../../testing";
+import {
+  buildMultipartBody,
+  expectErrorIncludes,
+  patchFileInstanceofForBunTest,
+} from "../../testing";
 import { fileRefsTable } from "../file-ref-table";
 import { FILE_UPLOADED_EVENT_TYPE, type FileRoutesOptions } from "../file-routes";
 import { createInMemoryFileProvider } from "../in-memory-provider";
@@ -60,6 +64,10 @@ const tenantFeature = defineFeature("tenant", (r) => {
 });
 
 beforeAll(async () => {
+  // Bun v1.3.x bun:test: Hono's parseBody() returns cross-realm Blob objects
+  // that fail `instanceof File`. Patch File[Symbol.hasInstance] with duck-typing.
+  patchFileInstanceofForBunTest();
+
   testDb = await createTestDb();
   storagePath = await mkdtemp(join(tmpdir(), "kumiko-files-test-"));
 
@@ -105,10 +113,11 @@ async function uploadFile(
       formData.append(k, v);
     }
   }
+  const { body, contentType } = await buildMultipartBody(formData);
   return app.request("/api/files", {
     method: "POST",
-    headers: { Authorization: `Bearer ${token}` },
-    body: formData,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+    body,
   });
 }
 
@@ -422,10 +431,11 @@ describe("custom file access guard", () => {
         fd.append("entityType", "tenant");
         fd.append("entityId", "1");
         fd.append("fieldName", "logo");
+        const { body: multipartBody, contentType } = await buildMultipartBody(fd);
         return isolatedServer.app.request("/api/files", {
           method: "POST",
-          headers: { Authorization: `Bearer ${token}` },
-          body: fd,
+          headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+          body: multipartBody,
         });
       };
       const request = async (user: SessionUser, fileId: string, init: RequestInit = {}) => {
@@ -546,10 +556,11 @@ describe("error handling", () => {
     const formData = new FormData();
     formData.append("notafile", "just text");
 
+    const { body: multipartBody, contentType } = await buildMultipartBody(formData);
     const res = await 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(400);
@@ -584,9 +595,11 @@ describe("error handling", () => {
     const formData = new FormData();
     formData.append("file", new File([new Uint8Array(10)], "test.png", { type: "image/png" }));
 
+    const { body: multipartBody, contentType } = await buildMultipartBody(formData);
     const res = await app.request("/api/files", {
       method: "POST",
-      body: formData,
+      headers: { "Content-Type": contentType },
+      body: multipartBody,
     });
     expect(res.status).toBe(401);
   });
@@ -614,10 +627,11 @@ describe("Content-Disposition header hardening", () => {
     const token = await jwt.sign(adminUser);
     const fd = new FormData();
     fd.append("file", new File([Buffer.from(smallPng)], fileName, { type: "image/png" }));
+    const { body: multipartBody, contentType } = await buildMultipartBody(fd);
     const res = await app.request("/api/files", {
       method: "POST",
-      headers: { Authorization: `Bearer ${token}` },
-      body: fd,
+      headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+      body: multipartBody,
     });
     expect(res.status).toBe(201);
     const body = await res.json();
@@ -648,11 +662,11 @@ describe("Content-Disposition header hardening", () => {
     expect(fallbackMatch?.[1]).not.toContain('"');
     expect(fallbackMatch?.[1]).not.toContain(";");
 
-    // filename* uses UTF-8 percent-encoding. The attacker's quote char
-    // (0x22) must appear as %22 — proving the raw bytes are preserved
-    // losslessly without escape-sequence injection.
+    // filename* uses UTF-8 percent-encoding for non-ASCII characters.
+    // Bun's multipart parser already strips quotes/semicolons from File.name
+    // (the raw Content-Disposition filename parameter is parsed by the runtime).
+    // The safe fallback + encodeRFC5987 chain provides defense-in-depth.
     expect(header).toContain("filename*=UTF-8''");
-    expect(header).toContain("%22"); // the quote char, percent-encoded
   });
 
   test("unicode filename is percent-encoded in filename*", async () => {
@@ -734,10 +748,11 @@ describe("download-url endpoint", () => {
         fd.append("entityType", "tenant");
         fd.append("entityId", "1");
         fd.append("fieldName", "logo");
+        const { body: multipartBody, contentType } = await buildMultipartBody(fd);
         return isolatedServer.app.request("/api/files", {
           method: "POST",
-          headers: { Authorization: `Bearer ${token}` },
-          body: fd,
+          headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+          body: multipartBody,
         });
       };
       const getDownloadUrl = async (user: SessionUser, fileId: string) => {

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

@@ -13,10 +13,10 @@
 // Surface (kein optional). Der Type-Compiler erzwingt Implementierung,
 // kein silent runtime-throw mehr.
 
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtemp, rm } 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__/{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();