chore(webapp): unexport internal shard descriptor type and apply format/lint

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: d-cs

apps/webapp/app/db.server.ts

@@ -32,16 +32,16 @@ import {
 } from "./v3/runOpsMigration/splitMode.server";
 import { computeRunOpsSplitReadEnabled } from "./v3/runOpsMigration/runOpsSplitReadGate";
 import { resolveRunOpsPoolKnobs } from "./v3/runOpsPoolKnobs.server";
-import { resolveShardResilience } from "./v3/transactionResilience.server";
-import { assertControlPlaneCoresidencyAdvisory } from "./v3/runOpsMigration/controlPlaneCoresidencySentinel.server";
-import { DATASOURCE_CONTEXT_KEY, startActiveSpan } from "./v3/tracer.server";
 import {
+  resolveShardResilience,
   controlPlaneTransactionResilience,
   registerTransactionResilience,
   resilienceForClient,
   runOpsLegacyTransactionResilience,
   runOpsTransactionResilience,
 } from "./v3/transactionResilience.server";
+import { assertControlPlaneCoresidencyAdvisory } from "./v3/runOpsMigration/controlPlaneCoresidencySentinel.server";
+import { DATASOURCE_CONTEXT_KEY, startActiveSpan } from "./v3/tracer.server";
 import type { Span } from "@opentelemetry/api";
 import { context, trace } from "@opentelemetry/api";
 import { queryPerformanceMonitor } from "./utils/queryPerformanceMonitor.server";
@@ -277,7 +277,7 @@ export const webhookReplica: WebhookReplicaDatabase = singleton("webhookReplica"
 
 type RunOpsClients = { writer: PrismaClient; replica: PrismaReplicaClient };
 type NewRunOpsClients = { writer: RunOpsPrismaClient; replica: RunOpsPrismaClient };
-export type ShardTopologyDescriptor = {
+type ShardTopologyDescriptor = {
   key: string;
   url?: string;
   replicaUrl?: string;
@@ -1060,7 +1060,9 @@ function buildRunOpsClient({
 }): RunOpsPrismaClient {
   const isWriter = role === "writer";
   const setupLabel = isWriter ? "run-ops prisma client" : "run-ops read replica connection";
-  const connectedLabel = isWriter ? "run-ops prisma client connected" : "run-ops read replica connected";
+  const connectedLabel = isWriter
+    ? "run-ops prisma client connected"
+    : "run-ops read replica connected";
 
   const connectionUrl = buildPrismaConnectionUrl(url, {
     connectionLimit: connectionLimit.toString(),
@@ -1111,7 +1113,11 @@ function buildRunOpsClient({
     client.$on("error", (log) =>
       // The writer bridges P2002 -> 422 at the store boundary, so its infra errors are logged once
       // there (ignoreError). Replica errors are not on that write path, so they log normally.
-      logger.error("RunOpsPrismaClient error", { clientType, event: log, ...(isWriter ? { ignoreError: true } : {}) })
+      logger.error("RunOpsPrismaClient error", {
+        clientType,
+        event: log,
+        ...(isWriter ? { ignoreError: true } : {}),
+      })
     );
   }
 

apps/webapp/app/v3/runOpsMigration/mintShardAssignment.test.ts

@@ -485,9 +485,9 @@ describe("routableKeys bound (the shard descriptor keys this deployment can rout
   });
 
   it("returns new when the active list holds only non-routable keys (fail-safe to gen-1)", () => {
-    expect(
-      computeMintShard({ id: "env_1" }, deps({ set: ["z"] }, { routableKeys: ["a"] }))
-    ).toBe("new");
+    expect(computeMintShard({ id: "env_1" }, deps({ set: ["z"] }, { routableKeys: ["a"] }))).toBe(
+      "new"
+    );
   });
 
   it("rejects a per-org pin to a non-routable key and falls through to the hash", () => {
@@ -501,7 +501,10 @@ describe("routableKeys bound (the shard descriptor keys this deployment can rout
   it("with no routableKeys given, behaviour is unchanged", () => {
     const ids = envIds(200);
     for (const id of ids) {
-      const withBound = computeMintShard({ id }, deps({ set: ["a", "b"] }, { routableKeys: ["a", "b"] }));
+      const withBound = computeMintShard(
+        { id },
+        deps({ set: ["a", "b"] }, { routableKeys: ["a", "b"] })
+      );
       const without = computeMintShard({ id }, deps({ set: ["a", "b"] }));
       expect(withBound).toBe(without);
     }

apps/webapp/app/v3/runOpsPoolKnobs.server.ts

@@ -55,9 +55,7 @@ export function resolveRunOpsPoolKnobs(
 
   return {
     writerPoolTimeout:
-      k?.writerPoolTimeout ??
-      env.RUN_OPS_DATABASE_WRITER_POOL_TIMEOUT ??
-      env.DATABASE_POOL_TIMEOUT,
+      k?.writerPoolTimeout ?? env.RUN_OPS_DATABASE_WRITER_POOL_TIMEOUT ?? env.DATABASE_POOL_TIMEOUT,
     writerConnectionTimeout:
       k?.writerConnectionTimeout ??
       env.RUN_OPS_DATABASE_WRITER_CONNECTION_TIMEOUT ??

apps/webapp/app/v3/runStore.server.ts

@@ -1,5 +1,10 @@
 import { PostgresRunStore, RoutingRunStore, type RunStore } from "@internal/run-store";
-import { ownerEngine, resolveShard, type Residency, type ShardKey } from "@trigger.dev/core/v3/isomorphic";
+import {
+  ownerEngine,
+  resolveShard,
+  type Residency,
+  type ShardKey,
+} from "@trigger.dev/core/v3/isomorphic";
 import type { PrismaClient, PrismaReplicaClient } from "@trigger.dev/database";
 import type { RunOpsPrismaClient } from "@internal/run-ops-database";
 import {

apps/webapp/test/runOpsShards.test.ts

@@ -35,26 +35,39 @@ describe("parseRunOpsShards", () => {
     expect(run(JSON.stringify([{ ...valid, key: "ab" }])).success).toBe(false);
   });
   it("fails on duplicate keys", () => {
-    const b = { ...valid, replication: { slotName: "s2", publicationName: "p2", originGeneration: 3 } };
+    const b = {
+      ...valid,
+      replication: { slotName: "s2", publicationName: "p2", originGeneration: 3 },
+    };
     expect(run(JSON.stringify([valid, b])).success).toBe(false);
   });
   it("fails on duplicate origin generations", () => {
     const b = { ...valid, key: "b", url: "postgres://h/b" };
     expect(run(JSON.stringify([valid, b])).success).toBe(false);
   });
   it("fails when both url and aliasOf are set", () => {
-    expect(run(JSON.stringify([{ key: "a", region: "x", url: "postgres://h/db", aliasOf: "new" }])).success).toBe(false);
+    expect(
+      run(JSON.stringify([{ key: "a", region: "x", url: "postgres://h/db", aliasOf: "new" }]))
+        .success
+    ).toBe(false);
   });
   it("accepts aliasOf without url or replication", () => {
     expect(run(JSON.stringify([{ key: "a", region: "x", aliasOf: "new" }])).success).toBe(true);
   });
   it("fails on an origin generation below 2 or above 255", () => {
-    const mk = (g: number) => run(JSON.stringify([{ ...valid, replication: { slotName: "s", publicationName: "p", originGeneration: g } }]));
+    const mk = (g: number) =>
+      run(
+        JSON.stringify([
+          { ...valid, replication: { slotName: "s", publicationName: "p", originGeneration: g } },
+        ])
+      );
     expect(mk(1).success).toBe(false);
     expect(mk(256).success).toBe(false);
   });
   it("fails when a non-aliased descriptor omits replication", () => {
-    expect(run(JSON.stringify([{ key: "a", region: "x", url: "postgres://h/db" }])).success).toBe(false);
+    expect(run(JSON.stringify([{ key: "a", region: "x", url: "postgres://h/db" }])).success).toBe(
+      false
+    );
   });
 });
 

apps/webapp/test/transactionResilience.test.ts

@@ -9,7 +9,9 @@ describe("resolveTransactionResilience per-shard", () => {
   });
 
   it("accepts an arbitrary pool label and honours a maxWait override", () => {
-    expect(() => resolveTransactionResilience("run-ops-shard-z", { maxWaitMs: 1234 })).not.toThrow();
+    expect(() =>
+      resolveTransactionResilience("run-ops-shard-z", { maxWaitMs: 1234 })
+    ).not.toThrow();
     expect(resolveTransactionResilience("run-ops-shard-z", { maxWaitMs: 1234 }).maxWait).toBe(1234);
   });
 });