@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

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");
+  });
+});

package/src/db/__tests__/table-builder-indexes.test.ts

@@ -3,11 +3,10 @@
 // Vorher mussten Apps für unique-indices über mehrere Spalten daneben eine
 // hand-written pgTable-Definition halten — Single-Source-of-Truth gebrochen,
 // Schema-Drift programmiert. Mit entity.indexes pflegen Author die
-// Constraint deklarativ in der EntityDefinition; buildDrizzleTable rendert
+// Constraint deklarativ in der EntityDefinition; buildEntityTable rendert
 // sie via uniqueIndex/index.
 
-import { getTableConfig } from "drizzle-orm/pg-core";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   createBooleanField,
   createEntity,
@@ -15,9 +14,29 @@ import {
   defineFeature,
   validateBoot,
 } from "../../engine";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 
-describe("buildDrizzleTable — entity.indexes", () => {
+// Native dialect equivalent of drizzle's getTableConfig: reads the
+// EntityTableMeta-shape exposed on every SchemaTable.
+// biome-ignore lint/suspicious/noExplicitAny: DDL index test helper
+function getTableConfig(table: any): {
+  indexes: Array<{ config: { name: string; unique: boolean; columns: Array<{ name: string }> } }>;
+} {
+  const meta = table as unknown as {
+    indexes: ReadonlyArray<{ name: string; columns: readonly string[]; unique?: boolean }>;
+  };
+  return {
+    indexes: meta.indexes.map((idx) => ({
+      config: {
+        name: idx.name,
+        unique: idx.unique === true,
+        columns: idx.columns.map((c) => ({ name: c })),
+      },
+    })),
+  };
+}
+
+describe("buildEntityTable — entity.indexes", () => {
   test("composite unique-index landet als unique=true in Drizzle table-config", () => {
     const entity = createEntity({
       fields: {
@@ -26,7 +45,7 @@ describe("buildDrizzleTable — entity.indexes", () => {
       },
       indexes: [{ unique: true, columns: ["key", "tenantId", "userId"] }],
     });
-    const tbl = buildDrizzleTable("config-value", entity);
+    const tbl = buildEntityTable("config-value", entity);
     const { indexes } = getTableConfig(tbl);
     const composite = indexes.find(
       (i) => i.config.name === "read_config_values_key_tenant_id_user_id_unique",
@@ -48,7 +67,7 @@ describe("buildDrizzleTable — entity.indexes", () => {
       },
       indexes: [{ columns: ["startedAt", "endedAt"] }],
     });
-    const tbl = buildDrizzleTable("session", entity);
+    const tbl = buildEntityTable("session", entity);
     const { indexes } = getTableConfig(tbl);
     const composite = indexes.find(
       (i) => i.config.name === "read_sessions_started_at_ended_at_idx",
@@ -62,7 +81,7 @@ describe("buildDrizzleTable — entity.indexes", () => {
       fields: { slug: createTextField({ required: true }) },
       indexes: [{ unique: true, columns: ["slug"], name: "my_custom_idx" }],
     });
-    const tbl = buildDrizzleTable("page", entity);
+    const tbl = buildEntityTable("page", entity);
     const { indexes } = getTableConfig(tbl);
     const idx = indexes.find((i) => i.config.name === "my_custom_idx");
     expect(idx).toBeDefined();
@@ -75,11 +94,11 @@ describe("buildDrizzleTable — entity.indexes", () => {
         title: createTextField({}),
       },
     });
-    expect(() => buildDrizzleTable("widget", entity)).not.toThrow();
+    expect(() => buildEntityTable("widget", entity)).not.toThrow();
   });
 
   test("Spalten die keine DB-Spalte haben (multi-files) werden via Boot-Validator gecatched", () => {
-    // buildDrizzleTable selbst überspringt fehlende Columns silently —
+    // buildEntityTable selbst überspringt fehlende Columns silently —
     // der Boot-Validator wirft.
     const entity = createEntity({
       fields: {
@@ -88,7 +107,7 @@ describe("buildDrizzleTable — entity.indexes", () => {
       indexes: [{ columns: ["attachments"] }],
     });
     // No throw at build time.
-    expect(() => buildDrizzleTable("widget", entity)).not.toThrow();
+    expect(() => buildEntityTable("widget", entity)).not.toThrow();
     // But validateBoot does.
     const feature = defineFeature("widgetFeature", (r) => {
       r.entity("widget", entity);

package/src/db/__tests__/table-builder-required.test.ts

@@ -7,7 +7,7 @@
 // generierte Variante gedriftet sind. Hier: required muss durchschlagen,
 // für jeden Field-Type.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   createBooleanField,
   createDateField,
@@ -24,25 +24,23 @@ import {
   createTzField,
 } from "../../engine";
 import type { ReferenceFieldDef } from "../../engine/types";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 
 // Reference-fields haben keinen Factory-Helper — direkt-typed inline.
 function refField(args: Omit<ReferenceFieldDef, "type">): ReferenceFieldDef {
   return { type: "reference", ...args };
 }
 
-function colByName(table: ReturnType<typeof buildDrizzleTable>, dbName: string) {
-  // Drizzle's PgTable proxies columns through both JS-prop-name and the
-  // serialized "name" attribute. We need the underlying column.config to
-  // read .notNull, which lives at runtime under the column instance. Simplest
-  // robust path: iterate Object.values, match by name.
-  for (const col of Object.values(table) as Array<{ name?: string; notNull?: boolean }>) {
-    if (col && typeof col === "object" && col.name === dbName) return col;
+function colByName(table: unknown, dbName: string) {
+  const cols = (table as { columns?: ReadonlyArray<{ name: string; notNull?: boolean }> }).columns;
+  if (!cols) throw new Error("Table has no columns metadata");
+  for (const c of cols) {
+    if (c.name === dbName) return { name: c.name, notNull: c.notNull };
   }
   throw new Error(`Column ${dbName} not found in table`);
 }
 
-describe("buildDrizzleTable — required: true → NOT NULL", () => {
+describe("buildEntityTable — required: true → NOT NULL", () => {
   test("text field — required true makes column NOT NULL", () => {
     const entity = createEntity({
       fields: {
@@ -50,7 +48,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         subtitle: createTextField({}),
       },
     });
-    const tbl = buildDrizzleTable("widget", entity);
+    const tbl = buildEntityTable("widget", entity);
     expect(colByName(tbl, "title").notNull).toBe(true);
     expect(colByName(tbl, "subtitle").notNull).toBe(false);
   });
@@ -62,7 +60,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         tag: createSelectField({ options: ["x"] as const }),
       },
     });
-    const tbl = buildDrizzleTable("widget", entity);
+    const tbl = buildEntityTable("widget", entity);
     expect(colByName(tbl, "status").notNull).toBe(true);
     expect(colByName(tbl, "tag").notNull).toBe(false);
   });
@@ -74,7 +72,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         optional: createNumberField({}),
       },
     });
-    const tbl = buildDrizzleTable("widget", entity);
+    const tbl = buildEntityTable("widget", entity);
     expect(colByName(tbl, "count").notNull).toBe(true);
     expect(colByName(tbl, "optional").notNull).toBe(false);
   });
@@ -86,7 +84,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         archived: createBooleanField({}),
       },
     });
-    const tbl = buildDrizzleTable("widget", entity);
+    const tbl = buildEntityTable("widget", entity);
     expect(colByName(tbl, "active").notNull).toBe(true);
     // Default ohne required ergibt notNull (default macht Spalte never-null)
     expect(colByName(tbl, "archived").notNull).toBe(true);
@@ -99,7 +97,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         assignee: refField({ entity: "user" }),
       },
     });
-    const tbl = buildDrizzleTable("task", entity);
+    const tbl = buildEntityTable("task", entity);
     expect(colByName(tbl, "owner").notNull).toBe(true);
     expect(colByName(tbl, "assignee").notNull).toBe(false);
   });
@@ -115,7 +113,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         zoneOpt: createTzField({}),
       },
     });
-    const tbl = buildDrizzleTable("event", entity);
+    const tbl = buildEntityTable("event", entity);
     expect(colByName(tbl, "born_on").notNull).toBe(true);
     expect(colByName(tbl, "born_on_opt").notNull).toBe(false);
     expect(colByName(tbl, "observed_at").notNull).toBe(true);
@@ -131,7 +129,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         dropoff: createLocatedTimestampField({}),
       },
     });
-    const tbl = buildDrizzleTable("transport", entity);
+    const tbl = buildEntityTable("transport", entity);
     expect(colByName(tbl, "pickup_utc").notNull).toBe(true);
     expect(colByName(tbl, "pickup_tz").notNull).toBe(true);
     expect(colByName(tbl, "dropoff_utc").notNull).toBe(false);
@@ -156,7 +154,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         }),
       },
     });
-    const tbl = buildDrizzleTable("acl", entity);
+    const tbl = buildEntityTable("acl", entity);
     expect(colByName(tbl, "roles_default").notNull).toBe(true);
     expect(colByName(tbl, "roles_optional").notNull).toBe(true);
     expect(colByName(tbl, "roles_required").notNull).toBe(true);
@@ -170,7 +168,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         metaOptional: createEmbeddedField({ note: { type: "text" } }, { required: false }),
       },
     });
-    const tbl = buildDrizzleTable("widget", entity);
+    const tbl = buildEntityTable("widget", entity);
     expect(colByName(tbl, "meta").notNull).toBe(true);
     expect(colByName(tbl, "meta_optional").notNull).toBe(true);
   });
@@ -183,7 +181,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         tagsOptional: refField({ entity: "tag", multiple: true, required: false }),
       },
     });
-    const tbl = buildDrizzleTable("post", entity);
+    const tbl = buildEntityTable("post", entity);
     expect(colByName(tbl, "tags").notNull).toBe(true);
     expect(colByName(tbl, "tags_optional").notNull).toBe(true);
   });
@@ -195,7 +193,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         discount: createMoneyField({}),
       },
     });
-    const tbl = buildDrizzleTable("listing", entity);
+    const tbl = buildEntityTable("listing", entity);
     expect(colByName(tbl, "price").notNull).toBe(true);
     expect(colByName(tbl, "price_currency").notNull).toBe(true);
     expect(colByName(tbl, "discount").notNull).toBe(false);
@@ -209,7 +207,7 @@ describe("buildDrizzleTable — required: true → NOT NULL", () => {
         cover: createImageField({}),
       },
     });
-    const tbl = buildDrizzleTable("profile", entity);
+    const tbl = buildEntityTable("profile", entity);
     expect(colByName(tbl, "avatar").notNull).toBe(true);
     expect(colByName(tbl, "cover").notNull).toBe(false);
   });