@malloy-publisher/server 0.0.235 → 0.0.236

package/src/storage/duckdb/EnvironmentRepository.ts

@@ -1,148 +0,0 @@
-import { Environment } from "../DatabaseInterface";
-import { DuckDBConnection } from "./DuckDBConnection";
-
-export class EnvironmentRepository {
-   constructor(private db: DuckDBConnection) {}
-
-   private generateId(): string {
-      return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-   }
-
-   private now(): Date {
-      return new Date();
-   }
-
-   async listEnvironments(): Promise<Environment[]> {
-      const rows = await this.db.all<Record<string, unknown>>(
-         "SELECT * FROM environments ORDER BY name",
-      );
-      return rows.map(this.mapToEnvironment);
-   }
-
-   async getEnvironmentById(id: string): Promise<Environment | null> {
-      const row = await this.db.get<Record<string, unknown>>(
-         "SELECT * FROM environments WHERE id = ?",
-         [id],
-      );
-      return row ? this.mapToEnvironment(row) : null;
-   }
-
-   async getEnvironmentByName(name: string): Promise<Environment | null> {
-      const row = await this.db.get<Record<string, unknown>>(
-         "SELECT * FROM environments WHERE name = ?",
-         [name],
-      );
-      return row ? this.mapToEnvironment(row) : null;
-   }
-
-   async createEnvironment(
-      environment: Omit<Environment, "id" | "createdAt" | "updatedAt">,
-   ): Promise<Environment> {
-      const id = this.generateId();
-      const now = this.now();
-
-      const params = [
-         id,
-         environment.name,
-         environment.path,
-         environment.description || null,
-         environment.metadata ? JSON.stringify(environment.metadata) : null,
-         now.toISOString(),
-         now.toISOString(),
-      ];
-
-      try {
-         await this.db.run(
-            `INSERT INTO environments (id, name, path, description, metadata, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?)`,
-            params,
-         );
-
-         return {
-            id,
-            ...environment,
-            createdAt: now,
-            updatedAt: now,
-         };
-      } catch (err: unknown) {
-         const error = err as Error;
-         // If unique constraint violation, return existing environment
-         if (
-            error.message?.includes("UNIQUE") ||
-            error.message?.includes("Constraint")
-         ) {
-            const existing = await this.db.get<Record<string, unknown>>(
-               "SELECT * FROM environments WHERE name = ?",
-               [environment.name],
-            );
-            if (existing) {
-               console.log("Returning existing environment");
-               return this.mapToEnvironment(existing);
-            }
-         }
-         throw error;
-      }
-   }
-
-   async updateEnvironment(
-      id: string,
-      updates: Partial<Environment>,
-   ): Promise<Environment> {
-      const existing = await this.getEnvironmentById(id);
-      if (!existing) {
-         throw new Error(`Environment with id ${id} not found`);
-      }
-
-      const now = this.now();
-      const setClauses: string[] = [];
-      const params: unknown[] = [];
-
-      if (updates.name !== undefined && updates.name !== existing.name) {
-         setClauses.push(`name = ?`);
-         params.push(updates.name);
-      }
-
-      if (updates.path !== undefined && updates.path !== existing.path) {
-         setClauses.push(`path = ?`);
-         params.push(updates.path);
-      }
-
-      if (updates.description !== undefined) {
-         setClauses.push(`description = ?`);
-         params.push(updates.description);
-      }
-      if (updates.metadata !== undefined) {
-         setClauses.push(`metadata = ?`);
-         params.push(JSON.stringify(updates.metadata));
-      }
-
-      setClauses.push(`updated_at = ?`);
-      params.push(now.toISOString());
-      params.push(id);
-
-      await this.db.run(
-         `UPDATE environments SET ${setClauses.join(", ")} WHERE id = ?`,
-         params,
-      );
-
-      return this.getEnvironmentById(id) as Promise<Environment>;
-   }
-
-   async deleteEnvironment(id: string): Promise<void> {
-      await this.db.run("DELETE FROM environments WHERE id = ?", [id]);
-   }
-
-   private mapToEnvironment(row: Record<string, unknown>): Environment {
-      return {
-         id: row.id as string,
-         name: row.name as string,
-         path: row.path as string,
-         description: row.description as string | undefined,
-         metadata: row.metadata
-            ? JSON.parse(row.metadata as string)
-            : undefined,
-         createdAt: new Date(row.created_at as string),
-         updatedAt: new Date(row.updated_at as string),
-      };
-   }
-}

package/src/storage/duckdb/MaterializationRepository.spec.ts

@@ -1,191 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { DuckDBConnection } from "./DuckDBConnection";
-import { MaterializationRepository } from "./MaterializationRepository";
-import { initializeSchema } from "./schema";
-
-// Capture the SQL + params of reads (all) and writes (run) without touching a
-// real DuckDB.
-function fakeRepo() {
-   const calls: Array<{ sql: string; params: unknown[] }> = [];
-   const runCalls: Array<{ sql: string; params: unknown[] }> = [];
-   const db = {
-      all: async (sql: string, params: unknown[]) => {
-         calls.push({ sql, params });
-         return [];
-      },
-      run: async (sql: string, params: unknown[]) => {
-         runCalls.push({ sql, params });
-      },
-   } as unknown as DuckDBConnection;
-   return { repo: new MaterializationRepository(db), calls, runCalls };
-}
-
-describe("MaterializationRepository list bounds", () => {
-   it("per-package list is unbounded when no limit is given (no LIMIT clause)", async () => {
-      const { repo, calls } = fakeRepo();
-      await repo.list("env-1", "pkg-a");
-      expect(calls[0].sql).not.toContain("LIMIT");
-      expect(calls[0].sql).not.toContain("OFFSET");
-      expect(calls[0].params).toEqual(["env-1", "pkg-a"]);
-   });
-
-   it("per-package list honors an explicit limit/offset", async () => {
-      const { repo, calls } = fakeRepo();
-      await repo.list("env-1", "pkg-a", { limit: 5, offset: 10 });
-      expect(calls[0].sql).toContain("LIMIT ?");
-      expect(calls[0].sql).toContain("OFFSET ?");
-      expect(calls[0].params).toEqual(["env-1", "pkg-a", 5, 10]);
-   });
-
-   it("environment-scoped list always applies a default cap (500)", async () => {
-      const { repo, calls } = fakeRepo();
-      await repo.listByEnvironment("env-1");
-      expect(calls[0].sql).toContain("LIMIT ?");
-      expect(calls[0].params).toEqual(["env-1", 500]);
-   });
-
-   it("environment-scoped list honors an explicit limit over the default", async () => {
-      const { repo, calls } = fakeRepo();
-      await repo.listByEnvironment("env-1", { limit: 25 });
-      expect(calls[0].params).toEqual(["env-1", 25]);
-   });
-});
-
-// The restart-recovery anchor (MaterializationScheduler.recoveryAnchor) hangs on
-// getLatestScheduledFireAt's `json_extract_string(metadata,'$.trigger')` filter,
-// which a fake db can't exercise. Drive the real query against an in-memory
-// DuckDB so the trigger filter and ORDER BY are covered, not just the SQL shape.
-describe("MaterializationRepository.getLatestScheduledFireAt (real DuckDB)", () => {
-   const ENV_ID = "env-sched";
-   const PKG = "pkg-a";
-   const dbs: DuckDBConnection[] = [];
-
-   afterEach(async () => {
-      while (dbs.length) await dbs.pop()!.close();
-   });
-
-   async function freshRepo(): Promise<{
-      db: DuckDBConnection;
-      repo: MaterializationRepository;
-   }> {
-      const db = new DuckDBConnection(":memory:");
-      dbs.push(db);
-      await db.initialize();
-      await initializeSchema(db);
-      // materializations.environment_id is a FK to environments(id).
-      await db.run(
-         `INSERT INTO environments (id, name, path, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?)`,
-         [
-            ENV_ID,
-            "sched-env",
-            "/tmp/sched-env",
-            "2026-01-01T00:00:00.000Z",
-            "2026-01-01T00:00:00.000Z",
-         ],
-      );
-      return { db, repo: new MaterializationRepository(db) };
-   }
-
-   // Insert a terminal run directly (active_key NULL so repeated inserts for the
-   // same package don't trip the unique active-key index). `trigger === undefined`
-   // stores metadata NULL; `null` stores a trigger-less object; a string stores
-   // that trigger.
-   async function insertRun(
-      db: DuckDBConnection,
-      id: string,
-      createdAt: string,
-      trigger: string | null | undefined,
-   ): Promise<void> {
-      const metadata =
-         trigger === undefined
-            ? null
-            : JSON.stringify(
-                 trigger === null ? { note: "manual" } : { trigger },
-              );
-      await db.run(
-         `INSERT INTO materializations
-            (id, environment_id, package_name, status, active_key, metadata, manifest, created_at, updated_at)
-          VALUES (?, ?, ?, 'MANIFEST_FILE_READY', NULL, ?, NULL, ?, ?)`,
-         [id, ENV_ID, PKG, metadata, createdAt, createdAt],
-      );
-   }
-
-   const day = (d: string) => `2026-${d}T12:00:00.000Z`;
-
-   it("returns the created_at of the newest SCHEDULER run", async () => {
-      const { db, repo } = await freshRepo();
-      await insertRun(db, "s1", day("01-15"), "SCHEDULER");
-      await insertRun(db, "s2", day("03-15"), "SCHEDULER");
-      const at = await repo.getLatestScheduledFireAt(ENV_ID, PKG);
-      expect(at).not.toBeNull();
-      expect(at!.toISOString().slice(0, 10)).toBe("2026-03-15");
-   });
-
-   it("ignores ON_DEMAND and trigger-less runs even when they are newer", async () => {
-      const { db, repo } = await freshRepo();
-      await insertRun(db, "s1", day("02-01"), "SCHEDULER"); // the only match
-      await insertRun(db, "d1", day("06-01"), "ON_DEMAND"); // newer, wrong trigger
-      await insertRun(db, "n1", day("07-01"), null); // newer, no trigger key
-      await insertRun(db, "m1", day("08-01"), undefined); // newer, metadata NULL
-      const at = await repo.getLatestScheduledFireAt(ENV_ID, PKG);
-      expect(at).not.toBeNull();
-      expect(at!.toISOString().slice(0, 10)).toBe("2026-02-01");
-   });
-
-   it("returns null when the package has no SCHEDULER run", async () => {
-      const { db, repo } = await freshRepo();
-      await insertRun(db, "d1", day("06-01"), "ON_DEMAND");
-      await insertRun(db, "m1", day("07-01"), undefined);
-      expect(await repo.getLatestScheduledFireAt(ENV_ID, PKG)).toBeNull();
-   });
-
-   it("scopes to the requested package (ignores another package's SCHEDULER run)", async () => {
-      const { db, repo } = await freshRepo();
-      await db.run(
-         `INSERT INTO materializations
-            (id, environment_id, package_name, status, active_key, metadata, manifest, created_at, updated_at)
-          VALUES (?, ?, 'other-pkg', 'MANIFEST_FILE_READY', NULL, ?, NULL, ?, ?)`,
-         [
-            "x1",
-            ENV_ID,
-            JSON.stringify({ trigger: "SCHEDULER" }),
-            day("09-01"),
-            day("09-01"),
-         ],
-      );
-      expect(await repo.getLatestScheduledFireAt(ENV_ID, PKG)).toBeNull();
-   });
-});
-
-// The publisher tracks materialization *records*; dropping the physical tables
-// is opt-in (deleteMaterialization({ dropTables })) and otherwise the caller's
-// responsibility. These cascade deletes therefore remove records only — they
-// must never issue DDL — so a materialized table intentionally outlives the
-// record when an environment or package is deleted. Locking that in guards the
-// contract against a future refactor that "helpfully" adds a DROP here (which
-// would fire against a possibly-already-torn-down connection on env delete).
-//
-// This pins DDL out of the low-level record deletes; it does not close the
-// standalone GC gap (#901: nothing drops those tables today, so they accumulate
-// in the warehouse). #901's best-effort drop-before-teardown lives ABOVE these
-// methods, so adding it completes the design and leaves this test green.
-describe("MaterializationRepository cascade deletes are records-only", () => {
-   it("deleteByEnvironmentId issues a single DELETE and no DDL", async () => {
-      const { repo, runCalls } = fakeRepo();
-      await repo.deleteByEnvironmentId("env-1");
-      expect(runCalls.length).toBe(1);
-      expect(runCalls[0].sql).toContain("DELETE FROM materializations");
-      expect(runCalls[0].sql).not.toContain("DROP");
-      expect(runCalls[0].params).toEqual(["env-1"]);
-   });
-
-   it("deleteByPackage issues a single DELETE and no DDL", async () => {
-      const { repo, runCalls } = fakeRepo();
-      await repo.deleteByPackage("env-1", "pkg-a");
-      expect(runCalls.length).toBe(1);
-      expect(runCalls[0].sql).toContain("DELETE FROM materializations");
-      expect(runCalls[0].sql).not.toContain("DROP");
-      expect(runCalls[0].params).toEqual(["env-1", "pkg-a"]);
-   });
-});

package/src/storage/duckdb/MaterializationRepository.ts

@@ -1,336 +0,0 @@
-import {
-   BuildManifestResult,
-   Materialization,
-   MaterializationStatus,
-   MaterializationUpdate,
-} from "../DatabaseInterface";
-import { DuckDBConnection } from "./DuckDBConnection";
-
-const TERMINAL_STATUSES: ReadonlySet<MaterializationStatus> = new Set([
-   "MANIFEST_FILE_READY",
-   "FAILED",
-   "CANCELLED",
-]);
-
-/** Non-terminal statuses count as "active" for the single-active guard. */
-const ACTIVE_STATUSES: readonly MaterializationStatus[] = [
-   "PENDING",
-   "MANIFEST_ROWS_READY",
-];
-
-function activeKeyFor(environmentId: string, packageName: string): string {
-   return `${environmentId}|${packageName}`;
-}
-
-/**
- * Default cap for the environment-wide materialization list. That query spans
- * every package in the environment, so on a busy env (e.g. a frequent schedule)
- * the history grows without bound; when a caller passes no explicit limit, fall
- * back to this bound rather than loading and serializing every row. Callers that
- * page (the SDK "show more") always pass their own limit and are unaffected.
- */
-const DEFAULT_ENVIRONMENT_LIST_LIMIT = 500;
-
-/**
- * Thrown when an atomic insert loses a race on (environment, package) active
- * materialization. Surfaced separately from a generic DB error so the service
- * layer can translate to `MaterializationConflictError`.
- */
-export class DuplicateActiveMaterializationError extends Error {
-   constructor(environmentId: string, packageName: string) {
-      super(
-         `Active materialization already exists for (${environmentId}, ${packageName})`,
-      );
-   }
-}
-
-/**
- * DuckDB-backed repository for package materializations.
- *
- * A Materialization tracks a single build run for an (environment, package)
- * pair through its lifecycle: PENDING -> MANIFEST_ROWS_READY ->
- * MANIFEST_FILE_READY, or -> FAILED | CANCELLED.
- */
-export class MaterializationRepository {
-   constructor(private db: DuckDBConnection) {}
-
-   private generateId(): string {
-      return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-   }
-
-   private now(): Date {
-      return new Date();
-   }
-
-   // Per-package list: intentionally UNBOUNDED when no limit is passed —
-   // existing callers may rely on the full history for a single package. Only
-   // the environment-wide `listByEnvironment` (which spans every package)
-   // applies a default cap; do not add one here.
-   async list(
-      environmentId: string,
-      packageName: string,
-      options?: { limit?: number; offset?: number },
-   ): Promise<Materialization[]> {
-      let sql =
-         "SELECT * FROM materializations WHERE environment_id = ? AND package_name = ? ORDER BY created_at DESC";
-      const params: unknown[] = [environmentId, packageName];
-      if (options?.limit !== undefined) {
-         sql += " LIMIT ?";
-         params.push(options.limit);
-      }
-      if (options?.offset !== undefined) {
-         sql += " OFFSET ?";
-         params.push(options.offset);
-      }
-      const rows = await this.db.all<Record<string, unknown>>(sql, params);
-      return rows.map(this.mapRow);
-   }
-
-   /** All materializations across every package in an environment, newest first. */
-   async listByEnvironment(
-      environmentId: string,
-      options?: { limit?: number; offset?: number },
-   ): Promise<Materialization[]> {
-      let sql =
-         "SELECT * FROM materializations WHERE environment_id = ? ORDER BY created_at DESC";
-      const params: unknown[] = [environmentId];
-      // Always bound the result: an uncapped env-wide fetch is unbounded.
-      sql += " LIMIT ?";
-      params.push(options?.limit ?? DEFAULT_ENVIRONMENT_LIST_LIMIT);
-      if (options?.offset !== undefined) {
-         sql += " OFFSET ?";
-         params.push(options.offset);
-      }
-      const rows = await this.db.all<Record<string, unknown>>(sql, params);
-      return rows.map(this.mapRow);
-   }
-
-   /**
-    * `created_at` of the newest scheduler-fired (metadata.trigger=SCHEDULER)
-    * materialization for (env, package), or null if none. The standalone
-    * scheduler uses this to recover a missed occurrence across a restart:
-    * re-anchoring `nextFireAt` to `nextAfter(lastScheduledFire)` fires exactly
-    * one catch-up after downtime (then jumps forward), rather than skipping the
-    * occurrence entirely. `metadata` is a JSON column, so the trigger is read
-    * with `json_extract_string`.
-    */
-   async getLatestScheduledFireAt(
-      environmentId: string,
-      packageName: string,
-   ): Promise<Date | null> {
-      const row = await this.db.get<{ created_at: unknown }>(
-         `SELECT created_at FROM materializations
-           WHERE environment_id = ? AND package_name = ?
-             AND json_extract_string(metadata, '$.trigger') = 'SCHEDULER'
-           ORDER BY created_at DESC
-           LIMIT 1`,
-         [environmentId, packageName],
-      );
-      return row?.created_at ? new Date(row.created_at as string) : null;
-   }
-
-   async getById(id: string): Promise<Materialization | null> {
-      const row = await this.db.get<Record<string, unknown>>(
-         "SELECT * FROM materializations WHERE id = ?",
-         [id],
-      );
-      return row ? this.mapRow(row) : null;
-   }
-
-   async getActive(
-      environmentId: string,
-      packageName: string,
-   ): Promise<Materialization | null> {
-      const placeholders = ACTIVE_STATUSES.map(() => "?").join(", ");
-      const row = await this.db.get<Record<string, unknown>>(
-         `SELECT * FROM materializations WHERE environment_id = ? AND package_name = ? AND status IN (${placeholders})`,
-         [environmentId, packageName, ...ACTIVE_STATUSES],
-      );
-      return row ? this.mapRow(row) : null;
-   }
-
-   async create(
-      environmentId: string,
-      packageName: string,
-      status: MaterializationStatus = "PENDING",
-      metadata: Record<string, unknown> | null = null,
-   ): Promise<Materialization> {
-      const id = this.generateId();
-      const now = this.now();
-      const iso = now.toISOString();
-      // Set active_key iff the row is in a non-terminal state. The unique
-      // index on active_key makes the race-free conditional insert: a second
-      // concurrent create on the same (environment, package) fails here rather
-      // than in a check-then-write window.
-      const activeKey = TERMINAL_STATUSES.has(status)
-         ? null
-         : activeKeyFor(environmentId, packageName);
-      const metadataJson = metadata ? JSON.stringify(metadata) : null;
-
-      try {
-         const rows = await this.db.all<Record<string, unknown>>(
-            `INSERT INTO materializations (id, environment_id, package_name, status, active_key, metadata, manifest, created_at, updated_at)
-            VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)
-            RETURNING *`,
-            [
-               id,
-               environmentId,
-               packageName,
-               status,
-               activeKey,
-               metadataJson,
-               iso,
-               iso,
-            ],
-         );
-         return this.mapRow(rows[0]);
-      } catch (err) {
-         if (isUniqueViolation(err, "idx_materializations_active_key")) {
-            throw new DuplicateActiveMaterializationError(
-               environmentId,
-               packageName,
-            );
-         }
-         throw err;
-      }
-   }
-
-   async update(
-      id: string,
-      updates: MaterializationUpdate,
-   ): Promise<Materialization> {
-      const now = this.now();
-      const setClauses: string[] = [];
-      const params: unknown[] = [];
-
-      if (updates.status !== undefined) {
-         setClauses.push(`status = ?`);
-         params.push(updates.status);
-         // Clear active_key on any transition to a terminal state; set it on
-         // any transition to a non-terminal state. The unique index
-         // guarantees we can never end up with two active rows for the same
-         // (environment, package).
-         if (TERMINAL_STATUSES.has(updates.status)) {
-            setClauses.push(`active_key = NULL`);
-         } else {
-            setClauses.push(
-               `active_key = environment_id || '|' || package_name`,
-            );
-         }
-      }
-      if (updates.startedAt !== undefined) {
-         setClauses.push(`started_at = ?`);
-         params.push(updates.startedAt.toISOString());
-      }
-      if (updates.completedAt !== undefined) {
-         setClauses.push(`completed_at = ?`);
-         params.push(updates.completedAt.toISOString());
-      }
-      if (updates.error !== undefined) {
-         setClauses.push(`error = ?`);
-         params.push(updates.error);
-      }
-      if (updates.metadata !== undefined) {
-         setClauses.push(`metadata = ?`);
-         params.push(
-            updates.metadata ? JSON.stringify(updates.metadata) : null,
-         );
-      }
-      if (updates.manifest !== undefined) {
-         setClauses.push(`manifest = ?`);
-         params.push(
-            updates.manifest ? JSON.stringify(updates.manifest) : null,
-         );
-      }
-
-      setClauses.push(`updated_at = ?`);
-      params.push(now.toISOString());
-      params.push(id);
-
-      await this.db.run(
-         `UPDATE materializations SET ${setClauses.join(", ")} WHERE id = ?`,
-         params,
-      );
-
-      const updated = await this.getById(id);
-      if (!updated) {
-         throw new Error(`Materialization ${id} not found after update`);
-      }
-      return updated;
-   }
-
-   async deleteById(id: string): Promise<void> {
-      await this.db.run("DELETE FROM materializations WHERE id = ?", [id]);
-   }
-
-   // Cascade deletes remove the publisher's records only; they intentionally
-   // issue no DDL. Dropping the physical tables is opt-in
-   // (deleteMaterialization({ dropTables })) and otherwise the caller's
-   // responsibility, so a materialized table outlives its record when an
-   // environment or package is deleted. Adding a DROP here would also risk
-   // firing against a connection already torn down by the delete path.
-   //
-   // Standalone caveat (#901): with no control plane owning physical GC,
-   // nothing drops those tables today, so they accumulate in the warehouse.
-   // That is an open follow-up, not a settled contract — its best-effort
-   // drop-before-teardown belongs ABOVE these methods, so it completes this
-   // design rather than moving DDL into the low-level record deletes.
-   async deleteByEnvironmentId(environmentId: string): Promise<void> {
-      await this.db.run(
-         "DELETE FROM materializations WHERE environment_id = ?",
-         [environmentId],
-      );
-   }
-
-   async deleteByPackage(
-      environmentId: string,
-      packageName: string,
-   ): Promise<void> {
-      await this.db.run(
-         "DELETE FROM materializations WHERE environment_id = ? AND package_name = ?",
-         [environmentId, packageName],
-      );
-   }
-
-   private mapRow(row: Record<string, unknown>): Materialization {
-      const metadata = parseJsonColumn<Record<string, unknown>>(row.metadata);
-      return {
-         id: row.id as string,
-         environmentId: row.environment_id as string,
-         packageName: row.package_name as string,
-         status: row.status as MaterializationStatus,
-         manifest: parseJsonColumn<BuildManifestResult>(row.manifest),
-         metadata,
-         startedAt: row.started_at ? new Date(row.started_at as string) : null,
-         completedAt: row.completed_at
-            ? new Date(row.completed_at as string)
-            : null,
-         error: row.error != null ? (row.error as string) : null,
-         createdAt: new Date(row.created_at as string),
-         updatedAt: new Date(row.updated_at as string),
-      };
-   }
-}
-
-/** Parse a nullable JSON text column, returning null on absence or parse error. */
-function parseJsonColumn<T>(value: unknown): T | null {
-   if (value == null) return null;
-   try {
-      return JSON.parse(value as string) as T;
-   } catch {
-      return null;
-   }
-}
-
-/**
- * DuckDB surfaces unique-constraint violations as plain Errors whose message
- * mentions the violated index. We match on the index name rather than a
- * generic substring so we don't misclassify unrelated constraint errors.
- */
-function isUniqueViolation(err: unknown, indexName: string): boolean {
-   if (!(err instanceof Error)) return false;
-   const msg = err.message;
-   return (
-      msg.includes(indexName) || /duplicate key|unique constraint/i.test(msg)
-   );
-}