@cosmicdrift/kumiko-framework 0.14.0 → 0.15.0

package/src/db/__tests__/{event-store-executor.integration.ts → event-store-executor.integration.test.ts}

@@ -1,5 +1,5 @@
-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 { asRawClient } from "../../db/query";
 import { createBooleanField, createEntity, createTextField } from "../../engine";
 import { createEventsTable } from "../../event-store";
 import {
@@ -10,7 +10,7 @@ import {
   unsafeCreateEntityTable,
 } from "../../stack";
 import { createEventStoreExecutor } from "../event-store-executor";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 import { createTenantDb, type TenantDb } from "../tenant-db";
 
 const entity = createEntity({
@@ -22,7 +22,7 @@ const entity = createEntity({
   },
   softDelete: true,
 });
-const table = buildDrizzleTable("esExecUser", entity);
+const table = buildEntityTable("esExecUser", entity);
 
 let testDb: TestDb;
 let tdb: TenantDb;
@@ -40,7 +40,9 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`TRUNCATE kumiko_events, read_es_exec_users RESTART IDENTITY CASCADE`);
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_es_exec_users RESTART IDENTITY CASCADE`,
+  );
 });
 
 describe("event-store-executor", () => {
@@ -117,7 +119,7 @@ const sensitiveEntity = createEntity({
   },
   softDelete: true,
 });
-const sensitiveTable = buildDrizzleTable("esExecSensitive", sensitiveEntity);
+const sensitiveTable = buildEntityTable("esExecSensitive", sensitiveEntity);
 
 describe("event-store-executor — sensitive fields", () => {
   const crud = createEventStoreExecutor(sensitiveTable, sensitiveEntity, {
@@ -129,8 +131,8 @@ describe("event-store-executor — sensitive fields", () => {
   });
 
   beforeEach(async () => {
-    await testDb.db.execute(
-      sql`TRUNCATE kumiko_events, read_es_exec_sensitive RESTART IDENTITY CASCADE`,
+    await asRawClient(testDb.db).unsafe(
+      `TRUNCATE kumiko_events, read_es_exec_sensitive RESTART IDENTITY CASCADE`,
     );
   });
 
@@ -138,12 +140,17 @@ describe("event-store-executor — sensitive fields", () => {
     type: string;
     payload: TPayload;
   }> {
-    const rows = await testDb.db.execute<{ type: string; payload: TPayload }>(
-      sql`SELECT type, payload FROM kumiko_events ORDER BY id DESC LIMIT 1`,
-    );
+    const rows = (await asRawClient(testDb.db).unsafe(
+      `SELECT type, payload FROM kumiko_events ORDER BY id DESC LIMIT 1`,
+    )) as Array<{ type: string; payload: unknown }>;
     const row = rows[0];
     if (!row) throw new Error("no events in store");
-    return row;
+    return {
+      type: row["type"],
+      payload: (typeof row["payload"] === "string"
+        ? JSON.parse(row["payload"])
+        : row["payload"]) as TPayload,
+    };
   }
 
   test("create event payload excludes sensitive fields but entity row keeps them", async () => {

package/src/db/__tests__/{implicit-projection-equivalence.integration.ts → implicit-projection-equivalence.integration.test.ts}

@@ -15,16 +15,17 @@
 //   5. Snapshot erneut nehmen
 //   6. deep-equal: identische Rows in identischer Reihenfolge
 
-import { asc, 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 { createBooleanField, createEntity, createTextField, defineFeature } from "../../engine";
 import { createRegistry } from "../../engine/registry";
 import { createEventsTable } from "../../event-store";
 import { rebuildProjection } from "../../pipeline";
 import { createProjectionStateTable } from "../../pipeline/projection-state";
-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({
@@ -41,13 +42,14 @@ const userFeature = defineFeature("implicittest", (r) => {
   r.entity("user", userEntity);
 });
 
-const userTable = buildDrizzleTable("user", userEntity);
+const userTable = buildEntityTable("user", userEntity);
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let tdb: TenantDb;
 const adminUser = TestUsers.admin;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await unsafeCreateEntityTable(testDb.db, userEntity, "user");
   await createEventsTable(testDb.db);
@@ -60,13 +62,18 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(
-    sql`TRUNCATE kumiko_events, read_implicit_users, kumiko_projections RESTART IDENTITY CASCADE`,
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_implicit_users, kumiko_projections RESTART IDENTITY CASCADE`,
   );
 });
 
 async function snapshotTable(): Promise<readonly Record<string, unknown>[]> {
-  const rows = await testDb.db.select().from(userTable).orderBy(asc(userTable["id"]));
+  const rows = await selectMany(
+    testDb.db,
+    userTable,
+    {},
+    { orderBy: { col: "id", direction: "asc" } },
+  );
   return rows as readonly Record<string, unknown>[];
 }
 
@@ -224,7 +231,7 @@ describe("implicit-projection / Live==Rebuild equivalence", () => {
 // sensitive-Spalte oder verschlüsseltem Event-Payload), bricht der Test
 // und zwingt zu Aufmerksamkeit.
 
-import { sql as drizzleSql, eq } from "drizzle-orm";
+import { asRawClient, selectMany } from "../../db/query";
 
 const sensitiveTable = "read_implicit_sensitive_users";
 
@@ -240,7 +247,7 @@ const sensitiveFeature = defineFeature("implicitsensitive", (r) => {
   r.entity("sensitive-user", sensitiveEntity);
 });
 
-const sensitiveDrizzleTable = buildDrizzleTable("sensitive-user", sensitiveEntity);
+const sensitiveEntityTable = buildEntityTable("sensitive-user", sensitiveEntity);
 
 describe("implicit-projection / dokumentierte Sensitive-Drift", () => {
   beforeAll(async () => {
@@ -248,15 +255,13 @@ describe("implicit-projection / dokumentierte Sensitive-Drift", () => {
   });
 
   beforeEach(async () => {
-    await testDb.db.execute(
-      drizzleSql.raw(
-        `TRUNCATE ${sensitiveTable}, kumiko_events, kumiko_projections RESTART IDENTITY CASCADE`,
-      ),
+    await asRawClient(testDb.db).unsafe(
+      `TRUNCATE ${sensitiveTable}, kumiko_events, kumiko_projections RESTART IDENTITY CASCADE`,
     );
   });
 
   test("Live schreibt sensitive-Felder, Rebuild lässt sie NULL (Welle-3-Roadmap)", async () => {
-    const crud = createEventStoreExecutor(sensitiveDrizzleTable, sensitiveEntity, {
+    const crud = createEventStoreExecutor(sensitiveEntityTable, sensitiveEntity, {
       entityName: "sensitive-user",
     });
 
@@ -269,20 +274,22 @@ describe("implicit-projection / dokumentierte Sensitive-Drift", () => {
     );
     if (!created.isSuccess) throw new Error("setup failed");
 
-    const [liveRow] = await testDb.db
-      .select()
-      .from(sensitiveDrizzleTable)
-      .where(eq(sensitiveDrizzleTable["id"], created.data.id as string));
+    const [liveRow] = await selectMany(testDb.db, sensitiveEntityTable, {
+      id: created.data.id as string,
+    });
     expect(liveRow?.["apiKey"]).toBe("secret-token-abc");
     expect(liveRow?.["email"]).toBe("x@test.de");
 
     // 2. Verifiziere dass das Event-Log das Feld NICHT enthält (stripped).
-    const events = await testDb.db.execute<{ payload: Record<string, unknown> }>(
-      drizzleSql`SELECT payload FROM kumiko_events WHERE aggregate_id = ${created.data.id}::uuid`,
+    const { eventsTable } = await import("../../event-store");
+    const [event] = await selectMany(
+      testDb.db,
+      eventsTable,
+      { aggregateId: created.data.id },
+      { orderBy: { col: "version", direction: "asc" } },
     );
-    expect(events[0]?.payload).toBeDefined();
-    expect(events[0]?.payload?.["apiKey"]).toBeUndefined();
-    expect(events[0]?.payload?.["email"]).toBe("x@test.de");
+    expect(event?.payload?.["apiKey"]).toBeUndefined();
+    expect(event?.payload?.["email"]).toBe("x@test.de");
 
     // 3. Rebuild über die ImplicitProjection. Read-Tabelle wird aus
     //    event.payload neu materialisiert — apiKey ist nicht im Log,
@@ -293,10 +300,9 @@ describe("implicit-projection / dokumentierte Sensitive-Drift", () => {
       registry,
     });
 
-    const [rebuiltRow] = await testDb.db
-      .select()
-      .from(sensitiveDrizzleTable)
-      .where(eq(sensitiveDrizzleTable["id"], created.data.id as string));
+    const [rebuiltRow] = await selectMany(testDb.db, sensitiveEntityTable, {
+      id: created.data.id as string,
+    });
     expect(rebuiltRow?.["email"]).toBe("x@test.de");
     // DAS ist die Drift: sensitive Feld ist nach Rebuild weg.
     expect(rebuiltRow?.["apiKey"]).toBeNull();

package/src/db/__tests__/located-timestamp.test.ts

@@ -1,7 +1,7 @@
 // Pure Unit-Tests für die flatten/rehydrate Helpers — Auto-Convert für
 // locatedTimestamp-Felder. Keine DB, kein Stack, nur Daten-Transform.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createEntity, createLocatedTimestampField, createTextField } from "../../engine";
 import type { EntityDefinition } from "../../engine/types";
 import { flattenLocatedTimestamp, rehydrateLocatedTimestamp } from "../located-timestamp";

package/src/db/__tests__/money.test.ts

@@ -1,6 +1,6 @@
 // Pure Unit-Tests für money flatten/rehydrate Helpers.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createEntity, createMoneyField, createTextField } from "../../engine";
 import type { EntityDefinition } from "../../engine/types";
 import { flattenMoney, rehydrateMoney } from "../money";

package/src/db/__tests__/{multi-row-insert.integration.ts → multi-row-insert.integration.test.ts}

@@ -7,8 +7,9 @@
 // have a real footgun, or whether the showcase bug had a different root
 // cause.
 
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
-import { buildDrizzleTable } from "../../db/table-builder";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { insertOne, selectMany } from "../../db/query";
+import { buildEntityTable } from "../../db/table-builder";
 import { createEntity, createTextField } from "../../engine";
 import { setupTestStack, type TestStack, unsafeCreateEntityTable } from "../../stack";
 
@@ -19,7 +20,7 @@ const linkEntity = createEntity({
     rightId: createTextField({ required: true }),
   },
 });
-const linkTable = buildDrizzleTable("link", linkEntity);
+const linkTable = buildEntityTable("link", linkEntity);
 
 let stack: TestStack;
 
@@ -41,7 +42,7 @@ describe("instant() customType is forgiving with ISO strings", () => {
     table: "mri_ts",
     fields: { name: createTextField({ required: true }) },
   });
-  const tsTable = buildDrizzleTable("ts-row", tsEntity);
+  const tsTable = buildEntityTable("ts-row", tsEntity);
 
   test("INSERT accepts an ISO string for an instant column (forgiving path)", async () => {
     await unsafeCreateEntityTable(stack.db, tsEntity, "ts-row");
@@ -50,12 +51,12 @@ describe("instant() customType is forgiving with ISO strings", () => {
     // would call .toString() on a string and produce a malformed driver
     // value that PG rejects.
     const isoString = "2026-01-15T12:00:00Z";
-    await stack.db.insert(tsTable).values({
+    await insertOne(stack.db, tsTable, {
       name: "x",
       tenantId: "00000000-0000-4000-8000-000000000001",
       insertedAt: isoString as unknown as Temporal.Instant,
     });
-    const rows = await stack.db.select().from(tsTable);
+    const rows = await selectMany(stack.db, tsTable);
     expect(rows).toHaveLength(1);
     expect(rows[0]?.["insertedAt"]).toBeInstanceOf(Temporal.Instant);
   });
@@ -63,11 +64,17 @@ describe("instant() customType is forgiving with ISO strings", () => {
 
 describe("multi-row INSERT", () => {
   test("two rows with no id supplied → both rows persist (PG gen_random_uuid per row)", async () => {
-    await stack.db.insert(linkTable).values([
-      { leftId: "L1", rightId: "R1", tenantId: "00000000-0000-4000-8000-000000000001" },
-      { leftId: "L2", rightId: "R2", tenantId: "00000000-0000-4000-8000-000000000001" },
-    ]);
-    const rows = await stack.db.select().from(linkTable);
+    await insertOne(stack.db, linkTable, {
+      leftId: "L1",
+      rightId: "R1",
+      tenantId: "00000000-0000-4000-8000-000000000001",
+    });
+    await insertOne(stack.db, linkTable, {
+      leftId: "L2",
+      rightId: "R2",
+      tenantId: "00000000-0000-4000-8000-000000000001",
+    });
+    const rows = await selectMany(stack.db, linkTable);
     expect(rows).toHaveLength(2);
     // Each row got its own id from the PG default.
     const ids = new Set(rows.map((r) => r["id"] as string));

package/src/db/__tests__/parse-auto-verb.test.ts

@@ -7,7 +7,7 @@
 // Wenn parseAutoVerb für ein Domain-Event versehentlich einen Verb
 // returnt, würde die ImplicitProjection den falschen Handler firen.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import type { StoredEvent } from "../../event-store";
 import { parseAutoVerb } from "../apply-entity-event";
 

package/src/db/__tests__/{required-not-null-migration-safety.integration.ts → required-not-null-migration-safety.integration.test.ts}

@@ -16,13 +16,15 @@
 // solchen Migration eine Sanity-Query auf NULL-Counts in den betroffenen
 // Spalten laufen, oder DB drop'pen wenn der State Demo-State ist.
 
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
-import { createTestDb, type TestDb } from "../../stack";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
 });
 
@@ -31,53 +33,53 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`DROP TABLE IF EXISTS migration_safety_test`);
+  await asRawClient(testDb.db).unsafe(`DROP TABLE IF EXISTS migration_safety_test`);
 });
 
 describe("ALTER TABLE SET NOT NULL — Daten-Sicherheits-Verhalten", () => {
   test("SET NOT NULL kracht wenn die Spalte NULL-Zeilen enthält", async () => {
-    await testDb.db.execute(sql`
+    await asRawClient(testDb.db).unsafe(`
       CREATE TABLE migration_safety_test (
         id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
         key text
       )
     `);
     // NULL-Zeile einschleusen — simuliert prod state vor dem Drift-Fix.
-    await testDb.db.execute(sql`INSERT INTO migration_safety_test (key) VALUES (NULL)`);
+    await asRawClient(testDb.db).unsafe(`INSERT INTO migration_safety_test (key) VALUES (NULL)`);
 
     let caught: unknown;
     try {
-      await testDb.db.execute(sql`ALTER TABLE migration_safety_test ALTER COLUMN key SET NOT NULL`);
+      await asRawClient(testDb.db).unsafe(
+        `ALTER TABLE migration_safety_test ALTER COLUMN key SET NOT NULL`,
+      );
     } catch (err) {
       caught = err;
     }
     expect(caught).toBeDefined();
-    // Drizzle wrapped den PG-Error in einer DrizzleQueryError. Der echte
-    // not_null_violation steckt in `.cause` als postgres-js Error mit
-    // `.code === "23502"` und einem deutschsprachigen oder englischen
-    // `.message`. Wir prüfen pragmatisch beide Pfade.
-    const cause = (caught as { cause?: unknown }).cause;
-    const causeCode = (cause as { code?: string } | undefined)?.code;
-    expect(causeCode).toBe("23502");
+    // Postgres-js throws PostgresError directly (no drizzle wrapper anymore).
+    const code = (caught as { code?: string } | undefined)?.code;
+    expect(code).toBe("23502");
   });
 
   test("SET NOT NULL läuft sauber durch wenn alle Zeilen Werte haben", async () => {
-    await testDb.db.execute(sql`
+    await asRawClient(testDb.db).unsafe(`
       CREATE TABLE migration_safety_test (
         id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
         key text
       )
     `);
-    await testDb.db.execute(sql`INSERT INTO migration_safety_test (key) VALUES ('foo')`);
-    await testDb.db.execute(sql`INSERT INTO migration_safety_test (key) VALUES ('bar')`);
+    await asRawClient(testDb.db).unsafe(`INSERT INTO migration_safety_test (key) VALUES ('foo')`);
+    await asRawClient(testDb.db).unsafe(`INSERT INTO migration_safety_test (key) VALUES ('bar')`);
 
     // Sollte ohne Throw durchlaufen.
-    await testDb.db.execute(sql`ALTER TABLE migration_safety_test ALTER COLUMN key SET NOT NULL`);
+    await asRawClient(testDb.db).unsafe(
+      `ALTER TABLE migration_safety_test ALTER COLUMN key SET NOT NULL`,
+    );
 
     // Verifizieren: zukünftige NULL-Inserts werden jetzt blockiert.
     let caught: unknown;
     try {
-      await testDb.db.execute(sql`INSERT INTO migration_safety_test (key) VALUES (NULL)`);
+      await asRawClient(testDb.db).unsafe(`INSERT INTO migration_safety_test (key) VALUES (NULL)`);
     } catch (err) {
       caught = err;
     }
@@ -88,17 +90,19 @@ describe("ALTER TABLE SET NOT NULL — Daten-Sicherheits-Verhalten", () => {
     // Frisch erstellt, keine Zeilen — der Fall in dem `migrate apply` nach
     // einem DB-drop läuft. Dieser Pfad muss IMMER grün sein, sonst wäre
     // jeder Greenfield-Deploy kaputt.
-    await testDb.db.execute(sql`
+    await asRawClient(testDb.db).unsafe(`
       CREATE TABLE migration_safety_test (
         id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
         key text
       )
     `);
-    await testDb.db.execute(sql`ALTER TABLE migration_safety_test ALTER COLUMN key SET NOT NULL`);
+    await asRawClient(testDb.db).unsafe(
+      `ALTER TABLE migration_safety_test ALTER COLUMN key SET NOT NULL`,
+    );
 
     // Beweis: information_schema zeigt die Spalte jetzt als NOT NULL.
-    const rows = await testDb.db.execute<{ is_nullable: string }>(
-      sql`SELECT is_nullable FROM information_schema.columns WHERE table_name = 'migration_safety_test' AND column_name = 'key'`,
+    const rows = await asRawClient(testDb.db).unsafe<{ is_nullable: string }>(
+      `SELECT is_nullable FROM information_schema.columns WHERE table_name = 'migration_safety_test' AND column_name = 'key'`,
     );
     expect(rows[0]?.is_nullable).toBe("NO");
   });

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

@@ -1,5 +1,6 @@
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient, insertOne, selectMany } from "../../db/query";
 import {
   createBooleanField,
   createDateField,
@@ -9,8 +10,9 @@ import {
   defineFeature,
 } from "../../engine";
 import type { FeatureDefinition } from "../../engine/types";
-import { createTestDb, type TestDb, unsafePushTables } from "../../stack";
-import { buildDrizzleTable } from "../table-builder";
+import { unsafePushTables } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
+import { buildEntityTable } from "../table-builder";
 
 /**
  * Integration tests for the schema migration workflow.
@@ -18,14 +20,15 @@ import { buildDrizzleTable } from "../table-builder";
  *
  * Each test simulates:
  *   1. Developer defines/changes entities
- *   2. buildDrizzleTable creates Drizzle table objects
+ *   2. buildEntityTable creates Drizzle table objects
  *   3. Schema is applied to a real database via unsafePushTables (drizzle-kit push)
  *   4. We verify the DB state matches expectations
  */
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
 });
 
@@ -38,7 +41,7 @@ async function applySchema(features: readonly FeatureDefinition[]): Promise<void
   const tables: Record<string, unknown> = {};
   for (const feature of features) {
     for (const [entityName, entity] of Object.entries(feature.entities)) {
-      tables[entityName] = buildDrizzleTable(entityName, entity);
+      tables[entityName] = buildEntityTable(entityName, entity);
     }
   }
   await unsafePushTables(testDb.db, tables);
@@ -48,12 +51,13 @@ async function applySchema(features: readonly FeatureDefinition[]): Promise<void
 async function getTableColumns(
   tableName: string,
 ): Promise<Map<string, { dataType: string; isNullable: boolean }>> {
-  const rows = await testDb.db.execute<{
+  const rows = await asRawClient(testDb.db).unsafe<{
     column_name: string;
     data_type: string;
     is_nullable: string;
   }>(
-    sql`SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_name = ${tableName} ORDER BY ordinal_position`,
+    `SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_name = $1 ORDER BY ordinal_position`,
+    [tableName],
   );
 
   const result = new Map<string, { dataType: string; isNullable: boolean }>();
@@ -121,10 +125,8 @@ describe("schema migration workflows", () => {
     });
     await applySchema([feature]);
 
-    const indexRows = await testDb.db.execute<{ indexname: string; indexdef: string }>(
-      sql.raw(
-        `SELECT indexname, indexdef FROM pg_indexes WHERE tablename = 'wf1b_articles' AND indexname = 'wf1b_articles_tenant_id_idx'`,
-      ),
+    const indexRows = await asRawClient(testDb.db).unsafe<{ indexname: string; indexdef: string }>(
+      `SELECT indexname, indexdef FROM pg_indexes WHERE tablename = 'wf1b_articles' AND indexname = 'wf1b_articles_tenant_id_idx'`,
     );
     expect(indexRows.length).toBe(1);
     expect(indexRows[0]?.indexdef).toContain("tenant_id");
@@ -136,7 +138,7 @@ describe("schema migration workflows", () => {
       table: "wf2_users",
       fields: { email: createTextField() },
     });
-    await unsafePushTables(testDb.db, { user: buildDrizzleTable("user", initialEntity) });
+    await unsafePushTables(testDb.db, { user: buildEntityTable("user", initialEntity) });
 
     // Developer adds a new field
     const updatedEntity = createEntity({
@@ -150,8 +152,8 @@ describe("schema migration workflows", () => {
     // Push updated schema — drizzle-kit generates ALTER TABLE ADD COLUMN
     await unsafePushTables(
       testDb.db,
-      { user: buildDrizzleTable("user", updatedEntity) },
-      { user: buildDrizzleTable("user", initialEntity) },
+      { user: buildEntityTable("user", updatedEntity) },
+      { user: buildEntityTable("user", initialEntity) },
     );
 
     const columns = await getTableColumns("wf2_users");
@@ -166,24 +168,25 @@ describe("schema migration workflows", () => {
       table: "wf3_projects",
       fields: { name: createTextField() },
     });
-    const initialTable = buildDrizzleTable("project", initialEntity);
+    const initialTable = buildEntityTable("project", initialEntity);
     await unsafePushTables(testDb.db, { project: initialTable });
 
     // Insert a row first (to prove ADD COLUMN with default doesn't break existing rows)
-    await testDb.db
-      .insert(initialTable)
-      .values({ tenantId: "00000000-0000-4000-8000-000000000001", name: "Test Project" });
+    await insertOne(testDb.db, initialTable, {
+      tenantId: "00000000-0000-4000-8000-000000000001",
+      name: "Test Project",
+    });
 
     // Developer adds boolean field with default
     const updatedEntity = createEntity({
       table: "wf3_projects",
       fields: { name: createTextField(), isArchived: createBooleanField({ default: false }) },
     });
-    const updatedTable = buildDrizzleTable("project", updatedEntity);
+    const updatedTable = buildEntityTable("project", updatedEntity);
     await unsafePushTables(testDb.db, { project: updatedTable }, { project: initialTable });
 
     // Existing row should have the default value
-    const rows = await testDb.db.select().from(updatedTable);
+    const rows = await selectMany(testDb.db, updatedTable);
 
     expect(rows[0]).toMatchObject({ name: "Test Project", isArchived: false });
   });
@@ -199,12 +202,13 @@ describe("schema migration workflows", () => {
       table: "wf3b_users",
       fields: { email: createTextField({ required: true }) },
     });
-    const initialTable = buildDrizzleTable("user", initialEntity);
+    const initialTable = buildEntityTable("user", initialEntity);
     await unsafePushTables(testDb.db, { user: initialTable });
 
-    await testDb.db
-      .insert(initialTable)
-      .values({ tenantId: "00000000-0000-4000-8000-000000000001", email: "x@y.z" });
+    await insertOne(testDb.db, initialTable, {
+      tenantId: "00000000-0000-4000-8000-000000000001",
+      email: "x@y.z",
+    });
 
     const updatedEntity = createEntity({
       table: "wf3b_users",
@@ -213,10 +217,10 @@ describe("schema migration workflows", () => {
         roles: createTextField({ required: true, default: "[]" }),
       },
     });
-    const updatedTable = buildDrizzleTable("user", updatedEntity);
+    const updatedTable = buildEntityTable("user", updatedEntity);
     await unsafePushTables(testDb.db, { user: updatedTable }, { user: initialTable });
 
-    const rows = await testDb.db.select().from(updatedTable);
+    const rows = await selectMany(testDb.db, updatedTable);
     expect(rows[0]).toMatchObject({ email: "x@y.z", roles: "[]" });
   });
 

package/src/db/__tests__/sql-inventory.test.ts

@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { formatReport, isRawSqlAllowed, joinPath, scanRepo } from "../sql-inventory";
+
+const cleanups: string[] = [];
+
+afterEach(async () => {
+  for (const dir of cleanups) {
+    await Bun.spawn(["rm", "-rf", dir]).exited;
+  }
+  cleanups.length = 0;
+});
+
+async function tempRepo(files: Record<string, string>): Promise<string> {
+  const root = joinPath(import.meta.dir, `.tmp-sql-inv-${crypto.randomUUID()}`);
+  cleanups.push(root);
+  await Promise.all(
+    Object.entries(files).map(([rel, content]) => Bun.write(joinPath(root, rel), content)),
+  );
+  return root;
+}
+
+describe("sql-inventory", () => {
+  test("isRawSqlAllowed permits db/queries and bun-db/query", () => {
+    expect(isRawSqlAllowed("/repo/packages/framework/src/db/queries/event-store.ts")).toBe(true);
+    expect(isRawSqlAllowed("/repo/packages/framework/src/bun-db/query.ts")).toBe(true);
+    expect(
+      isRawSqlAllowed("/repo/packages/bundled-features/src/sessions/db/queries/cleanup.ts"),
+    ).toBe(true);
+    expect(isRawSqlAllowed("/repo/samples/apps/marketing-demo/src/db/queries/seed-counts.ts")).toBe(
+      true,
+    );
+    expect(isRawSqlAllowed("/repo/bin/commands/schema.ts")).toBe(true);
+    expect(isRawSqlAllowed("/repo/scripts/codemod-drizzle-chain-to-bun-db.ts")).toBe(true);
+    expect(
+      isRawSqlAllowed("/repo/packages/bundled-features/src/sessions/handlers/cleanup.job.ts"),
+    ).toBe(false);
+  });
+
+  test("scanRepo classifies production vs test hits", async () => {
+    const root = await tempRepo({
+      "packages/framework/src/db/queries/demo.ts": `export async function x(db: unknown) {
+  return asRawClient(db).unsafe("SELECT 1");
+}`,
+      "packages/framework/src/handlers/bad.ts": `export async function y(db: unknown) {
+  return asRawClient(db).unsafe("DELETE FROM read_users");
+}`,
+      "packages/framework/src/__tests__/ok.integration.ts": `await asRawClient(db).unsafe("DELETE FROM read_users");`,
+    });
+
+    const report = await scanRepo(root);
+    expect(report.summary.byBucket.allowed).toBeGreaterThanOrEqual(1);
+    expect(report.summary.byBucket.tests).toBeGreaterThanOrEqual(1);
+    expect(report.summary.byBucket.disallowed).toBeGreaterThanOrEqual(1);
+    expect(formatReport(report)).toContain("sql inventory");
+  });
+});