@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

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

@@ -4,13 +4,15 @@
 // items-create.integration im Showcase abgedeckt — nicht ausreichend
 // für Framework-Code der von jeder App genutzt wird.
 
-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 { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
 import { createEntity, createNumberField, createTextField } from "../../engine";
 import { createEventsTable } from "../../event-store";
-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 entity = createEntity({
@@ -20,13 +22,14 @@ const entity = createEntity({
     rank: createNumberField({ sortable: true }),
   },
 });
-const table = buildDrizzleTable("pagerItem", entity);
+const table = buildEntityTable("pagerItem", entity);
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let tdb: TenantDb;
 const admin = TestUsers.admin;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await unsafeCreateEntityTable(testDb.db, entity, "pagerItem");
   await createEventsTable(testDb.db);
@@ -38,7 +41,9 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`TRUNCATE kumiko_events, read_pager_items RESTART IDENTITY CASCADE`);
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_pager_items RESTART IDENTITY CASCADE`,
+  );
 });
 
 describe("event-store-executor.list — offset + totalCount (Tier 2.6d)", () => {

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__/migrate-generator.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+import type { EntityTableMeta } from "../entity-table-meta";
+import {
+  diffSnapshots,
+  generateMigration,
+  renderMigrationSql,
+  snapshotFromMetas,
+} from "../migrate-generator";
+
+function meta(
+  tableName: string,
+  extraColumn?: EntityTableMeta["columns"][number],
+): EntityTableMeta {
+  return {
+    tableName,
+    source: "unmanaged",
+    indexes: [],
+    columns: [
+      { name: "id", pgType: "uuid", notNull: true, primaryKey: true },
+      ...(extraColumn ? [extraColumn] : []),
+    ],
+  };
+}
+
+describe("snapshotFromMetas", () => {
+  test("sorts tables by name for stable snapshots", () => {
+    const snap = snapshotFromMetas([meta("zebras"), meta("apples")]);
+    expect(snap.tables.map((t) => t.tableName)).toEqual(["apples", "zebras"]);
+    expect(snap.version).toBe(1);
+  });
+});
+
+describe("diffSnapshots", () => {
+  test("null prev → all tables are new", () => {
+    const next = snapshotFromMetas([meta("tasks")]);
+    const diff = diffSnapshots(null, next);
+    expect(diff.newTables.map((t) => t.tableName)).toEqual(["tasks"]);
+    expect(diff.droppedTables).toEqual([]);
+  });
+
+  test("detects dropped table and new column", () => {
+    const prev = snapshotFromMetas([meta("tasks"), meta("legacy")]);
+    const next = snapshotFromMetas([
+      meta("tasks", { name: "title", pgType: "text", notNull: true }),
+    ]);
+    const diff = diffSnapshots(prev, next);
+    expect(diff.droppedTables).toEqual(["legacy"]);
+    expect(diff.changedTables[0]?.newColumns.map((c) => c.name)).toEqual(["title"]);
+  });
+});
+
+describe("renderMigrationSql / generateMigration", () => {
+  test("emits CREATE TABLE for new tables", () => {
+    const diff = diffSnapshots(null, snapshotFromMetas([meta("tasks")]));
+    const sql = renderMigrationSql(diff, { name: "init", sequenceNumber: 1 });
+    expect(sql).toContain('CREATE TABLE IF NOT EXISTS "tasks"');
+    expect(sql).toContain("Migration 0001_init");
+  });
+
+  test("generateMigration bundles snapshot + sql", () => {
+    const out = generateMigration({
+      metas: [meta("tasks")],
+      prevSnapshot: null,
+      name: "init",
+      sequenceNumber: 1,
+    });
+    expect(out.snapshot.tables).toHaveLength(1);
+    expect(out.sqlContent).toContain("0001_init");
+    expect(out.filename).toBe("0001_init.sql");
+  });
+});

package/src/db/__tests__/migrate-runner.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { splitSqlStatements } from "../migrate-runner";
+
+describe("splitSqlStatements", () => {
+  test("splits on semicolons and strips line comments", () => {
+    const sql = `
+      CREATE TABLE "a" (id uuid); -- inline comment
+      CREATE TABLE "b" (id uuid);
+    `;
+    expect(splitSqlStatements(sql)).toEqual([
+      'CREATE TABLE "a" (id uuid);',
+      'CREATE TABLE "b" (id uuid);',
+    ]);
+  });
+
+  test("filters empty segments", () => {
+    expect(splitSqlStatements("-- only comments\n; ;")).toEqual([]);
+  });
+});

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__/pg-error.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { constraintOf, extractPgError, isTableAlreadyExists, isUniqueViolation } from "../pg-error";
+
+describe("extractPgError", () => {
+  test("reads code from top-level postgres-js error", () => {
+    const info = extractPgError({ code: "23505", constraint_name: "users_email_uq" });
+    expect(info).toEqual({ code: "23505", constraint_name: "users_email_uq" });
+  });
+
+  test("unwraps DrizzleQueryError.cause", () => {
+    const info = extractPgError({
+      message: "wrapper",
+      cause: { code: "23505", constraint_name: "uq" },
+    });
+    expect(info?.code).toBe("23505");
+  });
+
+  test("returns null for non-objects", () => {
+    expect(extractPgError("nope")).toBeNull();
+  });
+});
+
+describe("isUniqueViolation", () => {
+  test("true for SQLSTATE 23505", () => {
+    expect(isUniqueViolation({ code: "23505" })).toBe(true);
+  });
+
+  test("false otherwise", () => {
+    expect(isUniqueViolation({ code: "23503" })).toBe(false);
+  });
+});
+
+describe("isTableAlreadyExists", () => {
+  test("true for SQLSTATE 42P07", () => {
+    expect(isTableAlreadyExists({ code: "42P07" })).toBe(true);
+  });
+});
+
+describe("constraintOf", () => {
+  test("returns constraint_name when present", () => {
+    expect(constraintOf({ constraint_name: "users_email_uq" })).toBe("users_email_uq");
+  });
+});

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