test(webapp): route read-through presenter tests through the run store

The read-through presenter tests injected read clients the old way, so once
those reads moved onto the run store they fell through to the default database
and only passed where one happened to be reachable. Finish the run-store
injection seam on the affected presenters (default unchanged, so behavior is
identical) and wire each test to its own test-container stores.

Author: d-cs

apps/webapp/app/presenters/v3/ApiRunResultPresenter.server.ts

@@ -1,9 +1,8 @@
 import type { TaskRunExecutionResult } from "@trigger.dev/core/v3";
 import type { PrismaClientOrTransaction, PrismaReplicaClient } from "~/db.server";
-import { runOpsLegacyReplica } from "~/db.server";
 import { executionResultForTaskRun } from "~/models/taskRun.server";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
-import { readThroughRun } from "~/v3/runOpsMigration/readThrough.server";
+import { runStore as defaultRunStore } from "~/v3/runStore.server";
 import { BasePresenter } from "./basePresenter.server";
 
 type ApiRunResultReadThroughDeps = {
@@ -19,7 +18,8 @@ export class ApiRunResultPresenter extends BasePresenter {
   constructor(
     prisma?: PrismaClientOrTransaction,
     replica?: PrismaClientOrTransaction,
-    private readonly _readThrough?: ApiRunResultReadThroughDeps
+    private readonly _readThrough?: ApiRunResultReadThroughDeps,
+    private readonly runStore = defaultRunStore
   ) {
     super(prisma, replica);
   }
@@ -29,36 +29,14 @@ export class ApiRunResultPresenter extends BasePresenter {
     env: AuthenticatedEnvironment
   ): Promise<TaskRunExecutionResult | undefined> {
     return this.traceWithEnv("call", env, async (span) => {
-      // Single-run result poll routed through run-ops read-through. Split on: primary store first,
-      // then the LEGACY RUN-OPS READ REPLICA for runs that miss on new; past-retention ids return
-      // undefined -> the route's normal 404. Split off (single-DB / self-host): readThroughRun does
-      // one plain findFirst against the single client (passthrough). Both legs run the identical
-      // TaskRun(+attempts) lookup, inlined so the read resolves inside the router.
-      const result = await readThroughRun({
-        runId: friendlyId,
-        environmentId: env.id,
-        readNew: (client) =>
-          client.taskRun.findFirst({
-            // runops-routed-ok: readThroughRun new leg
-            where: { friendlyId, runtimeEnvironmentId: env.id },
-            include: { attempts: { orderBy: { createdAt: "desc" } } },
-          }),
-        readLegacy: (replica) =>
-          replica.taskRun.findFirst({
-            // runops-routed-ok: readThroughRun legacy leg
-            where: { friendlyId, runtimeEnvironmentId: env.id },
-            include: { attempts: { orderBy: { createdAt: "desc" } } },
-          }),
-        deps: {
-          splitEnabled: this._readThrough?.splitEnabled,
-          newClient: this._readThrough?.newClient ?? (this._prisma as PrismaReplicaClient),
-          legacyReplica: this._readThrough?.legacyReplica ?? runOpsLegacyReplica,
-          isPastRetention: this._readThrough?.isPastRetention,
-        },
-      });
-
-      const taskRun =
-        result.source === "new" || result.source === "legacy-replica" ? result.value : undefined;
+      // Single-run result poll routed through the run store, which selects the owning DB by
+      // run-id residency (id shape): a run-ops (NEW) id reads the new store, a cuid (LEGACY) id
+      // reads the legacy store. Single-DB / self-host collapses to one plain findFirst against the
+      // one store (passthrough). The identical TaskRun(+attempts) lookup runs inside the router.
+      const taskRun = await this.runStore.findRun(
+        { friendlyId, runtimeEnvironmentId: env.id },
+        { include: { attempts: { orderBy: { createdAt: "desc" } } } }
+      );
 
       if (!taskRun) {
         return undefined;

apps/webapp/app/presenters/v3/ApiWaitpointPresenter.server.ts

@@ -5,7 +5,7 @@ import { BasePresenter } from "./basePresenter.server";
 import { waitpointStatusToApiStatus } from "./WaitpointListPresenter.server";
 import { generateHttpCallbackUrl } from "~/services/httpCallback.server";
 import type { PrismaClientOrTransaction, PrismaReplicaClient } from "~/db.server";
-import { runStore } from "~/v3/runStore.server";
+import { runStore as defaultRunStore } from "~/v3/runStore.server";
 
 // Retained only to preserve the public constructor signature the route passes. Run-ops routing
 // (NEW vs LEGACY residency, replica reads) is now handled inside the injected `runStore`, so
@@ -21,7 +21,8 @@ export class ApiWaitpointPresenter extends BasePresenter {
   constructor(
     prismaClient?: PrismaClientOrTransaction,
     replicaClient?: PrismaClientOrTransaction,
-    private readonly readThroughDeps?: ApiWaitpointPresenterReadThroughDeps
+    private readonly readThroughDeps?: ApiWaitpointPresenterReadThroughDeps,
+    private readonly runStore = defaultRunStore
   ) {
     super(prismaClient, replicaClient);
   }
@@ -41,7 +42,7 @@ export class ApiWaitpointPresenter extends BasePresenter {
     return this.trace("call", async (span) => {
       // The store routes by the waitpointId's residency (id shape) and reads the owning
       // store's replica. waitpointId is pre-decoded from the friendlyId via WaitpointId.toId.
-      const waitpoint = await runStore.findWaitpoint({
+      const waitpoint = await this.runStore.findWaitpoint({
         where: {
           id: waitpointId,
           environmentId: environment.id,

apps/webapp/app/presenters/v3/WaitpointListPresenter.server.ts

@@ -11,7 +11,7 @@ import { type WaitpointSearchParams } from "~/components/runs/v3/WaitpointTokenF
 import { determineEngineVersion } from "~/v3/engineVersion.server";
 import { type WaitpointTokenStatus, type WaitpointTokenItem } from "@trigger.dev/core/v3";
 import { generateHttpCallbackUrl } from "~/services/httpCallback.server";
-import { runStore } from "~/v3/runStore.server";
+import { runStore as defaultRunStore } from "~/v3/runStore.server";
 
 const DEFAULT_PAGE_SIZE = 25;
 
@@ -94,7 +94,8 @@ export class WaitpointListPresenter extends BasePresenter {
       runOpsNew?: PrismaClientOrTransaction;
       runOpsLegacyReplica?: PrismaClientOrTransaction;
       splitEnabled?: boolean;
-    }
+    },
+    private readonly runStore = defaultRunStore
   ) {
     super(prismaClient, replicaClient);
   }
@@ -179,7 +180,7 @@ export class WaitpointListPresenter extends BasePresenter {
 
     const tokens = await this.#scanWaitpoints(
       () =>
-        runStore.findManyWaitpoints({
+        this.runStore.findManyWaitpoints({
           where: {
             environmentId: environment.id,
             type: "MANUAL",
@@ -307,7 +308,7 @@ export class WaitpointListPresenter extends BasePresenter {
 
   // Empty-state probe across both residencies (runStore fans out); no single runId.
   async #probeAnyToken(environmentId: string): Promise<boolean> {
-    const found = await runStore.findWaitpoint({
+    const found = await this.runStore.findWaitpoint({
       where: { environmentId, type: "MANUAL" },
     });
     return Boolean(found);

apps/webapp/app/presenters/v3/WaitpointPresenter.server.ts

@@ -4,7 +4,7 @@ import { clickhouseFactory } from "~/services/clickhouse/clickhouseFactoryInstan
 import { generateHttpCallbackUrl } from "~/services/httpCallback.server";
 import { logger } from "~/services/logger.server";
 import { controlPlaneResolver } from "~/v3/runOpsMigration/controlPlaneResolver.server";
-import { runStore } from "~/v3/runStore.server";
+import { runStore as defaultRunStore } from "~/v3/runStore.server";
 import { BasePresenter } from "./basePresenter.server";
 import { NextRunListPresenter, type NextRunListItem } from "./NextRunListPresenter.server";
 import { waitpointStatusToApiStatus } from "./WaitpointListPresenter.server";
@@ -21,7 +21,8 @@ export class WaitpointPresenter extends BasePresenter {
       newClient?: PrismaClientOrTransaction;
       legacyReplica?: PrismaClientOrTransaction;
       splitEnabled?: boolean;
-    }
+    },
+    private readonly runStore = defaultRunStore
   ) {
     super(prisma, replica);
   }
@@ -30,7 +31,7 @@ export class WaitpointPresenter extends BasePresenter {
     // Keyed by (friendlyId, environmentId) with no classifiable waitpoint id, so the run-store
     // probes NEW then LEGACY and reads each store's own replica — resolving the waitpoint whichever
     // run store owns it. When split is off it reads the single control-plane replica (passthrough).
-    return runStore.findWaitpoint({
+    return this.runStore.findWaitpoint({
       where: { friendlyId, environmentId },
       select: {
         id: true,
@@ -58,11 +59,11 @@ export class WaitpointPresenter extends BasePresenter {
   // The run-store fans the connection lookup out to both DBs and resolves each run id on its owning
   // DB (by id-shape residency), so we get the union without joining across the seam.
   async #connectedRunFriendlyIds(waitpointId: string): Promise<string[]> {
-    const runIds = await runStore.findWaitpointConnectedRunIds(waitpointId);
+    const runIds = await this.runStore.findWaitpointConnectedRunIds(waitpointId);
     if (runIds.length === 0) {
       return [];
     }
-    const runs = await runStore.findRuns({
+    const runs = await this.runStore.findRuns({
       where: { id: { in: runIds } },
       select: { friendlyId: true },
       take: 5,