style(run-ops): apply oxfmt

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

Author: d-cs

apps/webapp/app/db.server.ts

@@ -155,7 +155,9 @@ function tagDatasourceRunOps(
 // Same wrapper as captureInfrastructureErrors, bridged via double cast because
 // that helper is constrained to T extends @trigger.dev/database.PrismaClient.
 function captureInfraErrorsRunOps(client: RunOpsPrismaClient): RunOpsPrismaClient {
-  return captureInfrastructureErrors(client as unknown as PrismaClient) as unknown as RunOpsPrismaClient;
+  return captureInfrastructureErrors(
+    client as unknown as PrismaClient
+  ) as unknown as RunOpsPrismaClient;
 }
 
 export const prisma = singleton("prisma", () =>
@@ -260,8 +262,10 @@ export const runOpsNewPrismaClient: RunOpsPrismaClient = runOpsTopology.newRunOp
 export const runOpsNewReplicaClient: RunOpsPrismaClient = runOpsTopology.newRunOps.replica;
 // Legacy-typed aliases kept for the remaining consumers that still expect PrismaClient /
 // PrismaReplicaClient (idempotency residency, read-through, handlers, cascade cleanup).
-export const runOpsNewPrisma: PrismaClient = runOpsTopology.newRunOps.writer as unknown as PrismaClient;
-export const runOpsNewReplica: PrismaReplicaClient = runOpsTopology.newRunOps.replica as unknown as PrismaReplicaClient;
+export const runOpsNewPrisma: PrismaClient = runOpsTopology.newRunOps
+  .writer as unknown as PrismaClient;
+export const runOpsNewReplica: PrismaReplicaClient = runOpsTopology.newRunOps
+  .replica as unknown as PrismaReplicaClient;
 export const runOpsLegacyPrisma: PrismaClient = runOpsTopology.legacyRunOps.writer;
 export const runOpsLegacyReplica: PrismaReplicaClient = runOpsTopology.legacyRunOps.replica;
 

apps/webapp/app/v3/runOpsMigration/runEngineControlPlaneResolver.server.ts

@@ -6,10 +6,7 @@ import type {
 } from "@internal/run-engine";
 import type { RuntimeEnvironmentType } from "@trigger.dev/database";
 import { $replica } from "~/db.server";
-import {
-  authIncludeWithParent,
-  toAuthenticated,
-} from "~/models/runtimeEnvironment.server";
+import { authIncludeWithParent, toAuthenticated } from "~/models/runtimeEnvironment.server";
 import {
   ControlPlaneResolver as AppControlPlaneResolver,
   controlPlaneResolver,
@@ -64,9 +61,7 @@ export class RunEngineControlPlaneResolver implements EngineControlPlaneResolver
     });
   }
 
-  async resolveAuthenticatedEnv(
-    environmentId: string
-  ): Promise<ResolvedAuthenticatedEnv | null> {
+  async resolveAuthenticatedEnv(environmentId: string): Promise<ResolvedAuthenticatedEnv | null> {
     // Mirror findEnvironmentById's data source ($replica) and auth shape, but the
     // engine needs `git` too. A single findFirst with `include: authIncludeWithParent`
     // returns all RuntimeEnvironment scalars (including `git`) on the row, so we map
@@ -94,4 +89,6 @@ export class RunEngineControlPlaneResolver implements EngineControlPlaneResolver
 }
 
 // Module-level singleton over the app resolver singleton.
-export const runEngineControlPlaneResolver = new RunEngineControlPlaneResolver(controlPlaneResolver);
+export const runEngineControlPlaneResolver = new RunEngineControlPlaneResolver(
+  controlPlaneResolver
+);

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

@@ -76,8 +76,7 @@ export function buildRunStore(deps: BuildRunStoreDeps): RunStore {
 // RUN_OPS_SPLIT_ENABLED. Reads must fan out across both DBs so a run that lives on the new
 // DB stays visible even with the flag off (matches the db.server topology factory). The flag
 // governs write/mint residency + migration via isSplitEnabled(), not read visibility.
-const ROUTING_ENABLED =
-  !!env.TASK_RUN_DATABASE_URL && !!env.TASK_RUN_LEGACY_DATABASE_URL;
+const ROUTING_ENABLED = !!env.TASK_RUN_DATABASE_URL && !!env.TASK_RUN_LEGACY_DATABASE_URL;
 
 // Resolve the run-ops handles, tolerating contexts where they are absent — tests that mock
 // ~/db.server minimally omit them, and accessing a missing export under vi.mock throws. A

apps/webapp/test/runDetailLoaders.controlPlane.readthrough.test.ts

@@ -118,7 +118,10 @@ describe("run-detail loaders cross-DB read-through (dedicated run-ops client)",
       expect(found!.id).toBe(run.id);
 
       const authorized = await cp14.project.findFirst({
-        where: { id: found!.projectId, organization: { members: { some: { userId: cp.member.id } } } },
+        where: {
+          id: found!.projectId,
+          organization: { members: { some: { userId: cp.member.id } } },
+        },
         select: { id: true },
       });
       expect(authorized).not.toBeNull();
@@ -148,7 +151,10 @@ describe("run-detail loaders cross-DB read-through (dedicated run-ops client)",
       expect(found).not.toBeNull();
 
       const authorized = await cp14.project.findFirst({
-        where: { id: found!.projectId, organization: { members: { some: { userId: cp.stranger.id } } } },
+        where: {
+          id: found!.projectId,
+          organization: { members: { some: { userId: cp.stranger.id } } },
+        },
         select: { id: true },
       });
       expect(authorized).toBeNull();
@@ -165,7 +171,15 @@ describe("run-detail loaders cross-DB read-through (dedicated run-ops client)",
 
       const found = await runStore.findRun(
         { friendlyId: run.friendlyId },
-        { select: { id: true, idempotencyKey: true, taskIdentifier: true, projectId: true, runtimeEnvironmentId: true } }
+        {
+          select: {
+            id: true,
+            idempotencyKey: true,
+            taskIdentifier: true,
+            projectId: true,
+            runtimeEnvironmentId: true,
+          },
+        }
       );
       const env = await resolver.resolveAuthenticatedEnv(found!.runtimeEnvironmentId);
       expect(env!.slug).toBe(cp.environment.slug);

apps/webapp/test/v3/runOpsMigration/controlPlaneRepoint.server.test.ts

@@ -127,26 +127,23 @@ heteroPostgresTest(
 
 // --- Relaxed-cache (no latency regression) -------------------------
 
-heteroPostgresTest(
-  "relaxed (longer TTL) cache still hits on the new DB",
-  async ({ prisma17 }) => {
-    const { environment } = await seedControlPlane(prisma17);
-    const { client: counting, reads } = countQueries(prisma17);
-    const resolver = new ControlPlaneResolver({
-      controlPlanePrimary: counting,
-      controlPlaneReplica: counting,
-      // Relaxed: a much longer TTL than the default — same-provider resolution is cheap.
-      cache: new ControlPlaneCache({ ttlMs: 300_000, maxEntries: 10_000 }),
-      splitEnabled: () => true,
-    });
+heteroPostgresTest("relaxed (longer TTL) cache still hits on the new DB", async ({ prisma17 }) => {
+  const { environment } = await seedControlPlane(prisma17);
+  const { client: counting, reads } = countQueries(prisma17);
+  const resolver = new ControlPlaneResolver({
+    controlPlanePrimary: counting,
+    controlPlaneReplica: counting,
+    // Relaxed: a much longer TTL than the default — same-provider resolution is cheap.
+    cache: new ControlPlaneCache({ ttlMs: 300_000, maxEntries: 10_000 }),
+    splitEnabled: () => true,
+  });
 
-    expect(await resolver.resolveEnv(environment.id)).toMatchObject({ id: environment.id });
-    expect(reads()).toBe(1);
-    // Second read served from the relaxed cache — no extra DB round-trip.
-    await resolver.resolveEnv(environment.id);
-    expect(reads()).toBe(1);
-  }
-);
+  expect(await resolver.resolveEnv(environment.id)).toMatchObject({ id: environment.id });
+  expect(reads()).toBe(1);
+  // Second read served from the relaxed cache — no extra DB round-trip.
+  await resolver.resolveEnv(environment.id);
+  expect(reads()).toBe(1);
+});
 
 // --- Cross-version transition (legacy DB -> new DB) -----------------------
 

apps/webapp/test/v3/runOpsMigration/distinctDbSentinel.server.test.ts

@@ -37,7 +37,9 @@ describe("probeDistinctDatabases", () => {
     async ({ postgresContainer14, uri14 }) => {
       const otherDb = `sentinel_other_${Date.now()}`;
       const admin = new PrismaClient({
-        datasources: { db: { url: urlWithDatabase(postgresContainer14.getConnectionUri(), "postgres") } },
+        datasources: {
+          db: { url: urlWithDatabase(postgresContainer14.getConnectionUri(), "postgres") },
+        },
       });
       try {
         await admin.$executeRawUnsafe(`CREATE DATABASE "${otherDb}"`);

apps/webapp/test/v3/runOpsMigration/runEngineControlPlaneResolver.server.test.ts

@@ -119,25 +119,28 @@ async function seedWorker(
 }
 
 describe("RunEngineControlPlaneResolver adapter", () => {
-  heteroPostgresTest("resolveEnv maps app ResolvedEnv onto ResolvedEngineEnv", async ({ prisma14 }) => {
-    const { organization, project, environment } = await seedEnv(prisma14, "PRODUCTION");
-    const adapter = new RunEngineControlPlaneResolver(buildAppResolver(prisma14));
+  heteroPostgresTest(
+    "resolveEnv maps app ResolvedEnv onto ResolvedEngineEnv",
+    async ({ prisma14 }) => {
+      const { organization, project, environment } = await seedEnv(prisma14, "PRODUCTION");
+      const adapter = new RunEngineControlPlaneResolver(buildAppResolver(prisma14));
 
-    const env = await adapter.resolveEnv(environment.id);
-    expect(env).not.toBeNull();
-    expect(env!.id).toBe(environment.id);
-    expect(env!.type).toBe("PRODUCTION");
-    expect(env!.projectId).toBe(project.id);
-    expect(env!.organizationId).toBe(organization.id);
-    // Nested + concurrency fields the run-engine MinimalAuthenticatedEnvironment requires.
-    expect(env!.project.id).toBe(project.id);
-    expect(env!.organization.id).toBe(organization.id);
-    expect(env!.maximumConcurrencyLimit).toBe(9);
-    expect(env!.concurrencyLimitBurstFactor.toNumber()).toBe(2);
-    expect(env!.archivedAt).toBeNull();
+      const env = await adapter.resolveEnv(environment.id);
+      expect(env).not.toBeNull();
+      expect(env!.id).toBe(environment.id);
+      expect(env!.type).toBe("PRODUCTION");
+      expect(env!.projectId).toBe(project.id);
+      expect(env!.organizationId).toBe(organization.id);
+      // Nested + concurrency fields the run-engine MinimalAuthenticatedEnvironment requires.
+      expect(env!.project.id).toBe(project.id);
+      expect(env!.organization.id).toBe(organization.id);
+      expect(env!.maximumConcurrencyLimit).toBe(9);
+      expect(env!.concurrencyLimitBurstFactor.toNumber()).toBe(2);
+      expect(env!.archivedAt).toBeNull();
 
-    expect(await adapter.resolveEnv("env_missing")).toBeNull();
-  });
+      expect(await adapter.resolveEnv("env_missing")).toBeNull();
+    }
+  );
 
   heteroPostgresTest(
     "resolveWorkerVersion (deployed, no workerId) resolves the promoted MANAGED deployment",
@@ -156,7 +159,9 @@ describe("RunEngineControlPlaneResolver adapter", () => {
       });
       expect(version).not.toBeNull();
       expect(version!.worker.id).toBe(seeded.worker.id);
-      expect(version!.deployment?.id).toBe("deployment" in seeded ? seeded.deployment.id : undefined);
+      expect(version!.deployment?.id).toBe(
+        "deployment" in seeded ? seeded.deployment.id : undefined
+      );
       expect(version!.tasks.map((t) => t.slug)).toContain("my-task");
     }
   );
@@ -182,13 +187,14 @@ describe("RunEngineControlPlaneResolver adapter", () => {
     }
   );
 
-  heteroPostgresTest("assertEnvExists resolves for a present env, rejects for a missing one", async ({
-    prisma14,
-  }) => {
-    const { environment } = await seedEnv(prisma14, "PRODUCTION");
-    const adapter = new RunEngineControlPlaneResolver(buildAppResolver(prisma14));
+  heteroPostgresTest(
+    "assertEnvExists resolves for a present env, rejects for a missing one",
+    async ({ prisma14 }) => {
+      const { environment } = await seedEnv(prisma14, "PRODUCTION");
+      const adapter = new RunEngineControlPlaneResolver(buildAppResolver(prisma14));
 
-    await expect(adapter.assertEnvExists(environment.id)).resolves.toBeUndefined();
-    await expect(adapter.assertEnvExists("env_missing")).rejects.toThrow();
-  });
+      await expect(adapter.assertEnvExists(environment.id)).resolves.toBeUndefined();
+      await expect(adapter.assertEnvExists("env_missing")).rejects.toThrow();
+    }
+  );
 });