fix(run-ops split): normalize run-ops-generation Prisma errors to the control-plane class at the store write boundary

The store can be backed by either the control-plane @trigger.dev/database client
or the @internal/run-ops-database client. These are separately generated clients,
each with its own copy of the Prisma runtime, so each has its own
PrismaClientKnownRequestError class object (identical code, distinct module
identity). A P2002 raised by the run-ops client is therefore not `instanceof` the
control-plane class, so the webapp's uniform
`error instanceof Prisma.PrismaClientKnownRequestError` P2002->422 conversion is
skipped and a raw 500 escapes (e.g. idempotent batch re-create returned 500 not 422).

PostgresRunStore now wraps its writer/replica clients so any foreign
known-request-error is re-thrown as the control-plane
Prisma.PrismaClientKnownRequestError (preserving code/message/meta/clientVersion),
including inside runInTransaction. This immunizes the whole class of routed-write
error catches regardless of which generated client backs the store.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: d-cs

internal-packages/run-store/src/PostgresRunStore.crossGenerationError.test.ts

@@ -0,0 +1,104 @@
+// Cross-generation Prisma error normalization LOCK.
+//
+// The store can be backed by the run-ops `@internal/run-ops-database` client, a SEPARATELY
+// generated Prisma client with its OWN `PrismaClientKnownRequestError` class object (distinct
+// module identity from `@trigger.dev/database`'s, even at the same version). A P2002 raised by
+// the run-ops client is therefore NOT `instanceof` the control-plane
+// `Prisma.PrismaClientKnownRequestError` — so the webapp's uniform P2002→422 conversion
+// (`error instanceof Prisma.PrismaClientKnownRequestError`) is skipped and a raw 500 escapes.
+//
+// PostgresRunStore normalizes at its write boundary: a routed NEW-client P2002 surfaces such
+// that a control-plane `instanceof` catch (the 422 path) sees it. This test drives a REAL
+// duplicate-key on the REAL run-ops-generation client (prisma17) through the store and asserts
+// the surfaced error is recognized by the control-plane class — the exact predicate every
+// routed-write caller uses. Fails before the normalization (raw foreign error ⇒ instanceof false).
+
+import { heteroRunOpsPostgresTest } from "@internal/testcontainers";
+import { Prisma } from "@trigger.dev/database";
+import type { RunOpsPrismaClient } from "@internal/run-ops-database";
+import { describe, expect } from "vitest";
+import { PostgresRunStore } from "./PostgresRunStore.js";
+import type { CreateBatchTaskRunData } from "./types.js";
+
+function makeDedicatedStore(prisma17: RunOpsPrismaClient) {
+  return new PostgresRunStore({
+    prisma: prisma17 as never,
+    readOnlyPrisma: prisma17 as never,
+    schemaVariant: "dedicated",
+  });
+}
+
+function batchData(overrides: Partial<CreateBatchTaskRunData> = {}): CreateBatchTaskRunData {
+  return {
+    id: `batch_${"x".repeat(24)}`,
+    friendlyId: "batch_dup_friendly",
+    runtimeEnvironmentId: "env_cgerr",
+    status: "PENDING",
+    runCount: 1,
+    expectedCount: 1,
+    batchVersion: "runengine:v2",
+    sealed: false,
+    ...overrides,
+  };
+}
+
+describe("PostgresRunStore — cross-generation Prisma error normalization", () => {
+  heteroRunOpsPostgresTest(
+    "a routed NEW-client P2002 surfaces as a control-plane instanceof Prisma.PrismaClientKnownRequestError",
+    async ({ prisma17 }) => {
+      const store = makeDedicatedStore(prisma17);
+
+      // First create succeeds; second collides on the unique friendlyId → NEW-generation P2002.
+      await store.createBatchTaskRun(batchData({ id: `batch_${"a".repeat(24)}` }));
+
+      let caught: unknown;
+      try {
+        await store.createBatchTaskRun(batchData({ id: `batch_${"b".repeat(24)}` }));
+      } catch (error) {
+        caught = error;
+      }
+
+      // The control-plane `instanceof` catch (the P2002→422 path the webapp uses) must see it.
+      expect(caught instanceof Prisma.PrismaClientKnownRequestError).toBe(true);
+      const known = caught as Prisma.PrismaClientKnownRequestError;
+      expect(known.code).toBe("P2002");
+      // code/message/meta are preserved through the normalization.
+      expect(typeof known.message).toBe("string");
+      expect(known.message.length).toBeGreaterThan(0);
+      expect(known.clientVersion).toBeTruthy();
+    }
+  );
+
+  heteroRunOpsPostgresTest(
+    "a NEW-client P2002 inside runInTransaction is also normalized to the control-plane class",
+    async ({ prisma17 }) => {
+      const store = makeDedicatedStore(prisma17);
+
+      await store.createBatchTaskRun(batchData({ id: `batch_${"c".repeat(24)}` }));
+
+      let caught: unknown;
+      try {
+        await store.runInTransaction(undefined, async (txStore) => {
+          await txStore.createBatchTaskRun(batchData({ id: `batch_${"d".repeat(24)}` }));
+        });
+      } catch (error) {
+        caught = error;
+      }
+
+      expect(caught instanceof Prisma.PrismaClientKnownRequestError).toBe(true);
+      expect((caught as Prisma.PrismaClientKnownRequestError).code).toBe("P2002");
+    }
+  );
+
+  heteroRunOpsPostgresTest(
+    "a successful NEW-client write is untouched by the normalization wrapper",
+    async ({ prisma17 }) => {
+      const store = makeDedicatedStore(prisma17);
+
+      const created = await store.createBatchTaskRun(batchData({ id: `batch_${"e".repeat(24)}` }));
+
+      expect(created.id).toBe(`batch_${"e".repeat(24)}`);
+      expect(created.friendlyId).toBe("batch_dup_friendly");
+    }
+  );
+});

internal-packages/run-store/src/PostgresRunStore.ts

@@ -346,22 +346,166 @@ const WAITPOINT_DEDICATED: DedicatedRelationSpec = {
   completedExecutionSnapshots: hydrateCompletedExecutionSnapshots,
 };
 
+// Cross-generation Prisma error normalization.
+//
+// The store can be backed by the control-plane `@trigger.dev/database` client OR the
+// run-ops `@internal/run-ops-database` client. Each is a SEPARATELY generated client with
+// its own copy of the Prisma runtime, so each has its OWN `PrismaClientKnownRequestError`
+// class object (identical code, distinct module identity). A P2002 from the run-ops client
+// is therefore NOT `instanceof` the control-plane class — so the webapp's uniform
+// `error instanceof Prisma.PrismaClientKnownRequestError` P2002→422 conversion is skipped and
+// a raw 500 escapes. The store normalizes at its write boundary: any foreign
+// known-request-error is re-thrown as the control-plane class so every routed-write caller's
+// `instanceof` works regardless of which client raised it.
+
+// `instanceof` can't detect a foreign generation's class, so key on the runtime `name` the
+// Prisma runtime stamps on every generation plus a string `code` (the P-code).
+function isForeignPrismaKnownRequestError(
+  error: unknown
+): error is {
+  name: string;
+  message: string;
+  code: string;
+  meta?: unknown;
+  clientVersion?: string;
+} {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    (error as { name?: unknown }).name === "PrismaClientKnownRequestError" &&
+    typeof (error as { code?: unknown }).code === "string" &&
+    !(error instanceof Prisma.PrismaClientKnownRequestError)
+  );
+}
+
+// Native + non-known-request errors are returned unchanged (caller re-throws the result).
+function normalizeRunOpsError(error: unknown): unknown {
+  if (!isForeignPrismaKnownRequestError(error)) {
+    return error;
+  }
+  return new Prisma.PrismaClientKnownRequestError(error.message, {
+    code: error.code,
+    clientVersion: error.clientVersion ?? "unknown",
+    meta: error.meta as Record<string, unknown> | undefined,
+  });
+}
+
+// Only these Prisma-model delegates carry the create/update/upsert writes that raise P2002;
+// `$queryRaw`/`$executeRaw`/`$transaction` are left untouched (raw queries here never raise a
+// duplicate-key, and wrapping their tagged-template/callback contract would break it).
+const RUN_OPS_DELEGATE_KEYS: ReadonlySet<string> = new Set([
+  "taskRun",
+  "taskRunAttempt",
+  "taskRunExecutionSnapshot",
+  "taskRunWaitpoint",
+  "taskRunCheckpoint",
+  "checkpoint",
+  "checkpointRestoreEvent",
+  "taskRunDependency",
+  "waitpoint",
+  "completedWaitpoint",
+  "waitpointRunConnection",
+  "batchTaskRun",
+  "batchTaskRunItem",
+]);
+
+// Every method call on a delegate rewrites ONLY its rejection reason; success is untouched.
+function wrapDelegateForErrorNormalization<D extends object>(delegate: D): D {
+  return new Proxy(delegate, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      return (...args: unknown[]) => {
+        let result: unknown;
+        try {
+          result = (value as (...a: unknown[]) => unknown).apply(target, args);
+        } catch (error) {
+          throw normalizeRunOpsError(error);
+        }
+        // Delegate methods return a thenable PrismaPromise; rewrite its rejection only.
+        if (result != null && typeof (result as { then?: unknown }).then === "function") {
+          return (result as Promise<unknown>).then(undefined, (error) => {
+            throw normalizeRunOpsError(error);
+          });
+        }
+        return result;
+      };
+    },
+  });
+}
+
+// Model delegates are wrapped; `$transaction` wraps its tx client so inner writes normalize
+// too; every other property (incl. `$queryRaw`/`$executeRaw`) passes through unchanged.
+export function wrapRunOpsClientForErrorNormalization<C extends RunOpsCapableClient>(client: C): C {
+  // Some tests inject a non-object fake (or nothing) as the client; only a real client can be
+  // proxied, and only a real client raises the foreign known-request-errors we normalize.
+  if (client == null || (typeof client !== "object" && typeof client !== "function")) {
+    return client;
+  }
+  const delegateCache = new Map<string, unknown>();
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && RUN_OPS_DELEGATE_KEYS.has(prop)) {
+        const cached = delegateCache.get(prop);
+        if (cached) {
+          return cached;
+        }
+        const delegate = Reflect.get(target, prop, receiver);
+        if (delegate == null || typeof delegate !== "object") {
+          return delegate;
+        }
+        const wrapped = wrapDelegateForErrorNormalization(delegate as object);
+        delegateCache.set(prop, wrapped);
+        return wrapped;
+      }
+
+      if (prop === "$transaction") {
+        const original = Reflect.get(target, prop, receiver);
+        if (typeof original !== "function") {
+          return original;
+        }
+        return (fnOrArray: unknown, ...rest: unknown[]) => {
+          // Interactive (callback) form: wrap the tx client so inner writes normalize too.
+          if (typeof fnOrArray === "function") {
+            const wrappedFn = (tx: RunOpsCapableClient) =>
+              (fnOrArray as (t: RunOpsCapableClient) => unknown)(
+                wrapRunOpsClientForErrorNormalization(tx)
+              );
+            return (original as (...a: unknown[]) => unknown).call(target, wrappedFn, ...rest);
+          }
+          return (original as (...a: unknown[]) => unknown).call(target, fnOrArray, ...rest);
+        };
+      }
+
+      return Reflect.get(target, prop, receiver);
+    },
+  }) as C;
+}
+
 /**
  * Typed write layer for the task-run row, backed by the `taskRun` Prisma model.
  *
  * Each method is a verbatim relocation of the Prisma statement that lives at a
  * specific call site today. Methods write through `(tx ?? this.prisma).taskRun`
- * so callers can opt into an existing transaction. Errors (including unique
- * constraint violations) propagate to the caller unchanged.
+ * so callers can opt into an existing transaction. Errors surface with unique
+ * constraint violations (P2002 etc.) normalized to the control-plane
+ * `Prisma.PrismaClientKnownRequestError` class (see `wrapRunOpsClientForErrorNormalization`),
+ * so `instanceof Prisma.PrismaClientKnownRequestError` works regardless of which
+ * generated client backs the store.
  */
 export class PostgresRunStore implements RunStore {
   private readonly prisma: RunOpsCapableClient;
   private readonly readOnlyPrisma: RunOpsCapableClient;
   private readonly schemaVariant: RunStoreSchemaVariant;
 
   constructor(options: PostgresRunStoreOptions) {
-    this.prisma = options.prisma;
-    this.readOnlyPrisma = options.readOnlyPrisma;
+    // Normalize foreign (run-ops-generation) Prisma known-request-errors to the control-plane
+    // class at the write boundary so callers' `instanceof Prisma.PrismaClientKnownRequestError`
+    // (P2002→422) works regardless of which generated client backs the store.
+    this.prisma = wrapRunOpsClientForErrorNormalization(options.prisma);
+    this.readOnlyPrisma = wrapRunOpsClientForErrorNormalization(options.readOnlyPrisma);
     this.schemaVariant = options.schemaVariant ?? "legacy";
   }