@cosmicdrift/kumiko-framework 0.14.0 → 0.15.0

package/src/pipeline/projection-rebuild.ts

@@ -1,5 +1,12 @@
-import { asc, eq, getTableName, inArray, sql } from "drizzle-orm";
-import type { DbConnection } from "../db/connection";
+import type { DbConnection, DbTx } from "../db/connection";
+import {
+  finalizeProjectionRebuild,
+  markProjectionRebuildFailed,
+  markProjectionRebuilding,
+  selectEventsForProjectionRebuild,
+} from "../db/queries/projection-rebuild";
+import { truncateTable } from "../db/queries/table-ops";
+import { coerceRow, extractTableInfo, selectMany } from "../db/query";
 import type { Registry, TenantId } from "../engine/types";
 import {
   eventsTable,
@@ -86,53 +93,43 @@ export async function rebuildProjection(
   let lastProcessedEventId = 0n;
 
   try {
-    await db.transaction(async (tx) => {
-      // Lock the state row. Use upsert so a never-rebuilt projection also
-      // gets a row. FOR UPDATE would need the row to exist — upsert-first
-      // keeps it idempotent.
-      await tx
-        .insert(projectionStateTable)
-        .values({ name: projectionName, status: "rebuilding" })
-        .onConflictDoUpdate({
-          target: projectionStateTable.name,
-          set: {
-            status: "rebuilding",
-            lastError: null,
-            updatedAt: sql`now()`,
-          },
-        });
+    await db.begin(async (tx: DbTx) => {
+      await markProjectionRebuilding(tx, projectionName);
 
-      // Wipe the projection table. drizzle-orm's public API doesn't expose
-      // TRUNCATE, so we issue raw SQL — but `getTableName()` is the public
-      // accessor for the table's registered name, avoiding Symbol.for()
-      // internal lookups. The identifier is still quoted defensively.
       const tableName = getTableName(projection.table);
-      await tx.execute(sql.raw(`TRUNCATE TABLE ${quoteIdent(tableName)}`));
+      await truncateTable(tx, tableName);
 
       // Stream events in chronological order for every source. The event
-      // type filter (inArray(type, validTypes)) prunes events the projection
-      // doesn't care about early — important when a single source has more
-      // event types than the projection subscribes to.
+      // type filter prunes events the projection doesn't care about early.
       const subscribed = Object.keys(projection.apply);
       if (subscribed.length === 0) {
         // nothing to replay, just mark idle — projection exists but doesn't
         // subscribe to any event types on its sources yet.
       } else {
-        const events = (await tx
-          .select()
-          .from(eventsTable)
-          .where(
-            sql`${inArray(eventsTable.aggregateType, sources)} AND ${inArray(
-              eventsTable.type,
-              subscribed,
-            )}`,
-          )
-          .orderBy(asc(eventsTable.id))) as ReadonlyArray<typeof eventsTable.$inferSelect>; // @cast-boundary db-row
+        type EventRow = {
+          id: bigint;
+          aggregateId: string;
+          aggregateType: string;
+          tenantId: string;
+          version: number;
+          type: string;
+          eventVersion: number;
+          payload: Record<string, unknown>;
+          metadata: import("../event-store/event-store").EventMetadata;
+          createdAt: Temporal.Instant;
+          createdBy: string;
+        };
+        const sourcesList = [...sources];
+        const subscribedList = [...subscribed];
+        const rawEvents = await selectEventsForProjectionRebuild(tx, sourcesList, subscribedList);
+        const events = rawEvents.map((r) => {
+          const info = extractTableInfo(eventsTable);
+          return coerceRow(r, info) as EventRow;
+        });
 
         // Upcasters run at read time: older stored payloads get walked
         // through the registered r.eventMigration chain until their shape
-        // matches the current event version. An apply() written against the
-        // v3 shape stays oblivious to v1 payloads still on disk.
+        // matches the current event version.
         const upcasters = registry.getEventUpcasters();
         for (const row of events) {
           deps.signal?.throwIfAborted();
@@ -163,30 +160,13 @@ export async function rebuildProjection(
         }
       }
 
-      // Finalize state row.
-      await tx
-        .update(projectionStateTable)
-        .set({
-          lastProcessedEventId,
-          status: "idle",
-          lastRebuildAt: sql`now()`,
-          lastError: null,
-          updatedAt: sql`now()`,
-        })
-        .where(eq(projectionStateTable.name, projectionName));
+      await finalizeProjectionRebuild(tx, projectionName, lastProcessedEventId);
     });
   } catch (e) {
     // Outer catch: TX has been rolled back by Postgres already. Record the
-    // failure in a SEPARATE write so ops can see what happened — the
-    // rolled-back status change is gone, so we write failed+error now.
+    // failure in a SEPARATE write so ops can see what happened.
     const message = e instanceof Error ? e.message : String(e);
-    await db
-      .insert(projectionStateTable)
-      .values({ name: projectionName, status: "failed", lastError: message })
-      .onConflictDoUpdate({
-        target: projectionStateTable.name,
-        set: { status: "failed", lastError: message, updatedAt: sql`now()` },
-      });
+    await markProjectionRebuildFailed(db, projectionName, message);
     // Failure metric: duration until throw, 0 events "delivered" (the replayed
     // rows were rolled back — counting them would overstate live delivery).
     // success=false label distinguishes these in Prom dashboards.
@@ -219,11 +199,16 @@ export async function rebuildProjection(
   return result;
 }
 
-// Identifier quoting for raw TRUNCATE. Drizzle doesn't expose a safe helper
-// for table-name interpolation in raw SQL; double-quote + escape double-quote
-// matches Postgres identifier rules.
-function quoteIdent(name: string): string {
-  return `"${name.replace(/"/g, '""')}"`;
+const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
+function getTableName(table: unknown): string {
+  if (typeof table !== "object" || table === null) {
+    throw new Error("projection-rebuild: projection.table is not a pgTable object");
+  }
+  const name = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
+  if (typeof name !== "string") {
+    throw new Error("projection-rebuild: projection.table missing drizzle name symbol");
+  }
+  return name;
 }
 
 // Read-only status for one projection. Returns null if the projection was
@@ -239,10 +224,15 @@ export async function getProjectionState(
   readonly lastError: string | null;
   readonly updatedAt: Temporal.Instant;
 } | null> {
-  const [row] = await db
-    .select()
-    .from(projectionStateTable)
-    .where(eq(projectionStateTable.name, projectionName));
+  type Row = {
+    readonly name: string;
+    readonly status: string;
+    readonly lastProcessedEventId: bigint;
+    readonly lastRebuildAt: Temporal.Instant | null;
+    readonly lastError: string | null;
+    readonly updatedAt: Temporal.Instant;
+  };
+  const [row] = await selectMany<Row>(db, projectionStateTable, { name: projectionName });
   if (!row) return null;
   return {
     name: row.name,
@@ -277,8 +267,16 @@ export async function listProjectionsWithState(
     readonly lastError: string | null;
   }>
 > {
+  type StateRow = {
+    name: string;
+    status: string;
+    lastProcessedEventId: bigint;
+    lastRebuildAt: Temporal.Instant | null;
+    lastError: string | null;
+    updatedAt: Temporal.Instant;
+  };
   const projections = registry.getAllProjections();
-  const stateRows = await db.select().from(projectionStateTable);
+  const stateRows = await selectMany<StateRow>(db, projectionStateTable);
   const stateByName = new Map(stateRows.map((r) => [r.name, r]));
 
   return [...projections.values()]

package/src/pipeline/projection-state.ts

@@ -1,6 +1,6 @@
-import { sql } from "drizzle-orm";
+// sql now comes from native dialect
 import type { DbConnection } from "../db/connection";
-import { bigint, index, instant, table as pgTable, text } from "../db/dialect";
+import { bigint, index, instant, table as pgTable, sql, text } from "../db/dialect";
 import { tableExists } from "../db/schema-inspection";
 import { unsafePushTables } from "../stack";
 

package/src/random/__tests__/generate.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   ADJECTIVES,
   generateAdjNounName,
@@ -12,16 +12,16 @@ describe("generateAdjNounName", () => {
     const name = generateAdjNounName();
     const [adj, noun, ...rest] = name.split("-");
     expect(rest).toEqual([]);
-    expect(ADJECTIVES).toContain(adj);
-    expect(NOUNS).toContain(noun);
+    expect(ADJECTIVES).toContain(adj!);
+    expect(NOUNS).toContain(noun!);
   });
 
   test("custom separator", () => {
     const name = generateAdjNounName({ separator: "_" });
     expect(name).toMatch(/^[a-z]+_[a-z]+$/);
     const [adj, noun] = name.split("_");
-    expect(ADJECTIVES).toContain(adj);
-    expect(NOUNS).toContain(noun);
+    expect(ADJECTIVES).toContain(adj!);
+    expect(NOUNS).toContain(noun!);
   });
 
   test("mit suffix: <adj>-<noun>-<suffix>", () => {
@@ -29,11 +29,11 @@ describe("generateAdjNounName", () => {
     const parts = name.split("-");
     expect(parts).toHaveLength(3);
     const [adj, noun, suffix] = parts;
-    expect(ADJECTIVES).toContain(adj);
-    expect(NOUNS).toContain(noun);
-    expect(suffix).toMatch(/^[a-z2-9]{3}$/);
+    expect(ADJECTIVES).toContain(adj!);
+    expect(NOUNS).toContain(noun!);
+    expect(suffix!).toMatch(/^[a-z2-9]{3}$/);
     // No-confusable: keine 0/1/o/l/i
-    expect(suffix).not.toMatch(/[01oli]/);
+    expect(suffix!).not.toMatch(/[01oli]/);
   });
 
   test("custom adjectives + nouns Wahl", () => {
@@ -94,7 +94,7 @@ describe("generateUniqueName", () => {
       },
     });
     expect(seen).toHaveLength(1);
-    expect(name).toBe(seen[0]);
+    expect(name).toBe(seen[0]!);
     // Clean = nur 2 Teile (adj + noun), kein suffix
     expect(name.split("-")).toHaveLength(2);
   });
@@ -112,11 +112,11 @@ describe("generateUniqueName", () => {
     expect(tried).toHaveLength(4);
     // Erste 3 ohne suffix
     for (let i = 0; i < 3; i++) {
-      expect(tried[i]?.split("-")).toHaveLength(2);
+      expect(tried[i]!.split("-")).toHaveLength(2);
     }
     // 4. Versuch hat suffix
-    expect(tried[3]?.split("-")).toHaveLength(3);
-    expect(name).toBe(tried[3]);
+    expect(tried[3]!.split("-")).toHaveLength(3);
+    expect(name).toBe(tried[3]!);
   });
 
   test("wirft wenn maxTotalAttempts erschöpft", async () => {

package/src/rate-limit/__tests__/{dispatcher-l3.integration.ts → dispatcher-l3.integration.test.ts}

@@ -1,5 +1,5 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { defineFeature, defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { z } from "zod";
 import { createTestUser, setupTestStack, type TestStack, TestUsers } from "../../stack";
 

package/src/rate-limit/__tests__/{middleware.integration.ts → middleware.integration.test.ts}

@@ -1,5 +1,5 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { Hono } from "hono";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { createTestRedis, type TestRedis } from "../../stack";
 import { authEndpointRateLimit, globalIpRateLimit } from "../middleware";
 import { createRateLimitResolver, type RateLimitResolver } from "../resolver";

package/src/rate-limit/__tests__/{resolver.integration.ts → resolver.integration.test.ts}

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { RateLimitError } from "../../errors";
 import { createTestRedis, type TestRedis } from "../../stack";
 import {

package/src/redis/__tests__/redis-options.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { redisClientOptionsFromEnv } from "../index";
 
 describe("redisClientOptionsFromEnv", () => {

package/src/search/__tests__/{meilisearch-adapter.integration.ts → meilisearch-adapter.integration.test.ts}

@@ -1,7 +1,7 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import type { TenantId } from "@cosmicdrift/kumiko-framework/engine";
 import { generateId as uuid } from "@cosmicdrift/kumiko-framework/utils";
 import { Meilisearch } from "meilisearch";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { createMeilisearchAdapter } from "../meilisearch-adapter";
 import type { SearchAdapter } from "../types";
 

package/src/search/__tests__/search-adapter.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test } from "vitest";
+import { beforeEach, describe, expect, test } from "bun:test";
 import { createInMemorySearchAdapter } from "../in-memory-adapter";
 import type { SearchAdapter } from "../types";
 

package/src/secrets/__tests__/dek-cache.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
-import { describe, expect, test, vi } from "vitest";
 import { createDekCache } from "../dek-cache";
 import type { MasterKeyProvider } from "../types";
 
@@ -153,8 +153,6 @@ describe("DekCache", () => {
     t = 5 * 60 * 1000 + 1; // just past 5 min
     await cache.unwrapDek(Buffer.from("x"), 1, provider);
     expect(provider.unwrapCallCount()).toBe(2);
-    // avoid vitest unused-import warning
-    void vi;
   });
 
   test("LRU: evicts oldest when maxEntries is reached", async () => {

package/src/secrets/__tests__/env-master-key-provider.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
-import { describe, expect, test } from "vitest";
 import { createEnvMasterKeyProvider } from "../env-master-key-provider";
 
 function env(vars: Record<string, string>): Record<string, string> {

package/src/secrets/__tests__/envelope.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
-import { describe, expect, test } from "vitest";
 import { createEnvMasterKeyProvider } from "../env-master-key-provider";
 import { decryptValue, encryptValue } from "../envelope";
 

package/src/secrets/__tests__/leak-guard.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { assertNoSecretLeak } from "../leak-guard";
 import { createSecret } from "../types";
 

package/src/secrets/__tests__/rotation.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
-import { describe, expect, test } from "vitest";
 import { createEnvMasterKeyProvider } from "../env-master-key-provider";
 import { decryptValue, encryptValue } from "../envelope";
 import { rewrapDek } from "../rotation";

package/src/stack/db.ts

@@ -1,5 +1,10 @@
-import { drizzle } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
+// Test-DB Factory: CREATE DATABASE → connect → createEventsTable.
+// Provider-agnostic via createConnection (DB_PROVIDER env).
+// postgres-js = default. DB_PROVIDER=bun = Bun.SQL (experimentell).
+
+import { createConnection } from "../db/api";
+import { createDatabase, databaseExists, dropDatabaseIfExists } from "../db/queries/test-stack";
+import { ensureTemporalPolyfill } from "../time/polyfill";
 import { generateId } from "../utils";
 
 function requireEnv(name: string): string {
@@ -13,88 +18,60 @@ function requireEnv(name: string): string {
 }
 
 export type TestDb = {
-  db: ReturnType<typeof drizzle>;
-  client: ReturnType<typeof postgres>;
+  db: unknown;
+  client: unknown;
   dbName: string;
   cleanup: () => Promise<void>;
 };
 
 export type CreateTestDbOptions = {
-  /** Override TEST_DATABASE_URL. Rare — mostly for tests that want a
-   *  non-default Postgres (e.g. a read-replica probe). */
   readonly baseUrl?: string;
-  /** Use a specific DB name instead of the default
-   *  `kumiko_test_<8chars>`. Combined with `persistent: true`, lets a
-   *  dev server keep state across restarts. Must be a legal Postgres
-   *  identifier — the caller is responsible for matching the usual
-   *  [a-z_0-9]+ shape. */
   readonly dbName?: string;
-  /** When true, cleanup() is a no-op and the DB survives. Also
-   *  changes CREATE DATABASE to IF-NOT-EXISTS semantics so restarts
-   *  reuse the same storage. Default false (test contract: fresh DB
-   *  per call, dropped on cleanup). */
   readonly persistent?: boolean;
 };
 
 /**
- * Accepts a baseUrl string (legacy shorthand used by most tests) OR an
- * options object. The string form is kept because thousands of tests
- * call `createTestDb()` with no args; only dev-server and niche tests
- * need the options form.
+ * Provider-agnostische Test-DB. createConnection liest DB_PROVIDER.
+ * Für Bun.SQL: DB_PROVIDER=bun setzen (experimentell — siehe db/bun-provider.ts).
  */
 export async function createTestDb(arg?: string | CreateTestDbOptions): Promise<TestDb> {
+  await ensureTemporalPolyfill();
   const opts: CreateTestDbOptions = typeof arg === "string" ? { baseUrl: arg } : (arg ?? {});
   const url = opts.baseUrl ?? requireEnv("TEST_DATABASE_URL");
-  // slice(-8) — the last 8 hex chars of a UUIDv7 are pure random (the
-  // front 48 bits are a timestamp, which would collide across workers
-  // that start within the same millisecond).
   const dbName = opts.dbName ?? `kumiko_test_${generateId().slice(-8)}`;
   const adminUrl = url.replace(/\/[^/]+$/, "/postgres");
 
-  const adminClient = postgres(adminUrl);
+  const admin = await createConnection(adminUrl, { maxConnections: 1 });
   try {
     if (opts.persistent) {
-      // Postgres has no CREATE DATABASE IF NOT EXISTS; emulate with a
-      // catalog probe so restarts are idempotent.
-      const existing = await adminClient<{ exists: boolean }[]>`
-        SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = ${dbName}) AS exists
-      `;
-      if (!existing[0]?.exists) {
-        await adminClient.unsafe(`CREATE DATABASE "${dbName}"`);
+      if (!(await databaseExists(admin.db, dbName))) {
+        await createDatabase(admin.db, dbName);
       }
     } else {
-      await adminClient.unsafe(`CREATE DATABASE "${dbName}"`);
+      await createDatabase(admin.db, dbName);
     }
   } finally {
-    await adminClient.end();
+    await admin.close();
   }
 
   const testUrl = url.replace(/\/[^/]+$/, `/${dbName}`);
-  const client = postgres(testUrl);
-  const db = drizzle(client);
+  const conn = await createConnection(testUrl);
 
-  // Every ES-entity writes events; auto-create the events table so tests that
-  // go straight to createTestDb (not setupTestStack) also work out of the box.
-  // In persistent mode this is idempotent: createEventsTable emits IF NOT
-  // EXISTS so a second boot is a no-op.
   const { createEventsTable } = await import("../event-store");
-  await createEventsTable(db);
+  await createEventsTable(conn.db);
 
   return {
-    db,
-    client,
+    db: conn.db,
+    client: conn.client,
     dbName,
     cleanup: async () => {
-      await client.end();
-      // Persistent mode: dev-server owns the DB lifecycle — don't drop
-      // on process exit. `yarn kumiko clean-test-dbs` is the escape
-      // hatch when you really want to start over.
+      await conn.close();
       if (!opts.persistent) {
-        const admin = postgres(adminUrl);
+        const admin2 = await createConnection(adminUrl, { maxConnections: 1 });
         try {
-          await admin.unsafe(`DROP DATABASE IF EXISTS "${dbName}"`);
+          await dropDatabaseIfExists(admin2.db, dbName);
         } finally {
-          await admin.end();
+          await admin2.close();
         }
       }
     },

package/src/stack/push-entity-projection-tables.ts

@@ -1,4 +1,3 @@
-import { getTableName } from "drizzle-orm";
 import { tableExists } from "../db/schema-inspection";
 import type { Registry } from "../engine/types";
 import { unsafePushTables } from "./table-helpers";
@@ -35,9 +34,8 @@ export async function pushEntityProjectionTables(
     if (!proj.isImplicit) continue;
     if (seen.has(proj.table)) continue;
     seen.add(proj.table);
-    // @cast-boundary drizzle-bridge — ProjectionTable + PgTable both round-trip
-    // through getTableName at runtime; the type system can't unify them.
-    const physical = getTableName(proj.table as Parameters<typeof getTableName>[0]);
+    const tableRec = proj.table as unknown as Record<symbol, unknown>;
+    const physical = tableRec[Symbol.for("kumiko:schema:Name")] as string;
     if (await tableExists(stack.db, `public.${physical}`)) {
       logInfo(`[kumiko-stack] table ${physical} already exists — skipping create`);
       continue;