refactor(webapp): route presenter TaskRun reads through the run store

d-cs · d-cs · commit 5683952331df · 2026-06-18T16:12:57.000+01:00
Relocate the dashboard presenter TaskRun reads to the RunStore read
methods, preserving the exact client per site. Behavior-preserving.
diff --git a/apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts b/apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts
@@ -22,6 +22,7 @@ import {
   type SyntheticRun,
 } from "~/v3/mollifier/readFallback.server";
 import { generatePresignedUrl } from "~/v3/objectStore.server";
+import { runStore } from "~/v3/runStore.server";
 import { tracer } from "~/v3/tracer.server";
 import { startSpanWithEnv } from "~/v3/tracing.server";
 
@@ -110,38 +111,41 @@ export class ApiRetrieveRunPresenter {
     friendlyId: string,
     env: AuthenticatedEnvironment,
   ): Promise<FoundRun | null> {
-    const pgRow = await $replica.taskRun.findFirst({
-      where: {
+    const pgRow = await runStore.findRun(
+      {
         friendlyId,
         runtimeEnvironmentId: env.id,
       },
-      select: {
-        ...commonRunSelect,
-        traceId: true,
-        payload: true,
-        payloadType: true,
-        output: true,
-        outputType: true,
-        error: true,
-        attempts: {
-          select: {
-            id: true,
+      {
+        select: {
+          ...commonRunSelect,
+          traceId: true,
+          payload: true,
+          payloadType: true,
+          output: true,
+          outputType: true,
+          error: true,
+          attempts: {
+            select: {
+              id: true,
+            },
+          },
+          attemptNumber: true,
+          engine: true,
+          taskEventStore: true,
+          parentTaskRun: {
+            select: commonRunSelect,
+          },
+          rootTaskRun: {
+            select: commonRunSelect,
+          },
+          childRuns: {
+            select: commonRunSelect,
           },
-        },
-        attemptNumber: true,
-        engine: true,
-        taskEventStore: true,
-        parentTaskRun: {
-          select: commonRunSelect,
-        },
-        rootTaskRun: {
-          select: commonRunSelect,
-        },
-        childRuns: {
-          select: commonRunSelect,
         },
       },
-    });
+      $replica
+    );
 
     if (pgRow) return { ...pgRow, isBuffered: false };
 
diff --git a/apps/webapp/app/presenters/v3/ApiRunResultPresenter.server.ts b/apps/webapp/app/presenters/v3/ApiRunResultPresenter.server.ts
@@ -1,6 +1,7 @@
 import { TaskRunExecutionResult } from "@trigger.dev/core/v3";
 import { executionResultForTaskRun } from "~/models/taskRun.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { runStore } from "~/v3/runStore.server";
 import { BasePresenter } from "./basePresenter.server";
 
 export class ApiRunResultPresenter extends BasePresenter {
@@ -9,19 +10,22 @@ export class ApiRunResultPresenter extends BasePresenter {
     env: AuthenticatedEnvironment
   ): Promise<TaskRunExecutionResult | undefined> {
     return this.traceWithEnv("call", env, async (span) => {
-      const taskRun = await this._prisma.taskRun.findFirst({
-        where: {
+      const taskRun = await runStore.findRun(
+        {
           friendlyId,
           runtimeEnvironmentId: env.id,
         },
-        include: {
-          attempts: {
-            orderBy: {
-              createdAt: "desc",
+        {
+          include: {
+            attempts: {
+              orderBy: {
+                createdAt: "desc",
+              },
             },
           },
         },
-      });
+        this._prisma
+      );
 
       if (!taskRun) {
         return undefined;
diff --git a/apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts b/apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts
@@ -13,6 +13,7 @@ import { getTaskIdentifiers } from "~/models/task.server";
 import { RunsRepository } from "~/services/runsRepository/runsRepository.server";
 import { regionForDisplay } from "~/runEngine/concerns/workerQueueSplit.server";
 import { machinePresetFromRun } from "~/v3/machinePresets.server";
+import { runStore } from "~/v3/runStore.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { isCancellableRunStatus, isFinalRunStatus, isPendingRunStatus } from "~/v3/taskStatus";
 
@@ -206,11 +207,12 @@ export class NextRunListPresenter {
     let hasAnyRuns = runs.length > 0;
 
     if (!hasAnyRuns) {
-      const firstRun = await this.replica.taskRun.findFirst({
-        where: {
+      const firstRun = await runStore.findRun(
+        {
           runtimeEnvironmentId: environmentId,
         },
-      });
+        this.replica
+      );
 
       if (firstRun) {
         hasAnyRuns = true;
diff --git a/apps/webapp/app/presenters/v3/RunPresenter.server.ts b/apps/webapp/app/presenters/v3/RunPresenter.server.ts
@@ -8,6 +8,7 @@ import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
 import { isFinalRunStatus } from "~/v3/taskStatus";
 import { env } from "~/env.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
+import { runStore } from "~/v3/runStore.server";
 
 type Result = Awaited<ReturnType<RunPresenter["call"]>>;
 export type Run = Result["run"];
@@ -62,57 +63,8 @@ export class RunPresenter {
     // buffer view. `findFirstOrThrow` would log a `PrismaClient error`
     // every tick of the page poll, masking real DB issues with synthetic
     // not-found noise.
-    const run = await this.#prismaClient.taskRun.findFirst({
-      select: {
-        id: true,
-        createdAt: true,
-        taskEventStore: true,
-        taskIdentifier: true,
-        number: true,
-        traceId: true,
-        spanId: true,
-        parentSpanId: true,
-        friendlyId: true,
-        status: true,
-        startedAt: true,
-        completedAt: true,
-        logsDeletedAt: true,
-        annotations: true,
-        rootTaskRun: {
-          select: {
-            friendlyId: true,
-            spanId: true,
-            createdAt: true,
-          },
-        },
-        parentTaskRun: {
-          select: {
-            friendlyId: true,
-            spanId: true,
-            createdAt: true,
-          },
-        },
-        runtimeEnvironment: {
-          select: {
-            id: true,
-            type: true,
-            slug: true,
-            organizationId: true,
-            orgMember: {
-              select: {
-                user: {
-                  select: {
-                    id: true,
-                    name: true,
-                    displayName: true,
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-      where: {
+    const run = await runStore.findRun(
+      {
         friendlyId: runFriendlyId,
         project: {
           slug: projectSlug,
@@ -125,7 +77,59 @@ export class RunPresenter {
           },
         },
       },
-    });
+      {
+        select: {
+          id: true,
+          createdAt: true,
+          taskEventStore: true,
+          taskIdentifier: true,
+          number: true,
+          traceId: true,
+          spanId: true,
+          parentSpanId: true,
+          friendlyId: true,
+          status: true,
+          startedAt: true,
+          completedAt: true,
+          logsDeletedAt: true,
+          annotations: true,
+          rootTaskRun: {
+            select: {
+              friendlyId: true,
+              spanId: true,
+              createdAt: true,
+            },
+          },
+          parentTaskRun: {
+            select: {
+              friendlyId: true,
+              spanId: true,
+              createdAt: true,
+            },
+          },
+          runtimeEnvironment: {
+            select: {
+              id: true,
+              type: true,
+              slug: true,
+              organizationId: true,
+              orgMember: {
+                select: {
+                  user: {
+                    select: {
+                      id: true,
+                      name: true,
+                      displayName: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      this.#prismaClient
+    );
 
     if (!run) {
       throw new RunNotInPgError(runFriendlyId);
diff --git a/apps/webapp/app/presenters/v3/RunStreamPresenter.server.ts b/apps/webapp/app/presenters/v3/RunStreamPresenter.server.ts
@@ -6,6 +6,7 @@ import { ABORT_REASON_SEND_ERROR, createSSELoader, SendFunction } from "~/utils/
 import { throttle } from "~/utils/throttle";
 import { getMollifierBuffer } from "~/v3/mollifier/mollifierBuffer.server";
 import { deserialiseMollifierSnapshot } from "~/v3/mollifier/mollifierSnapshot.server";
+import { runStore } from "~/v3/runStore.server";
 import { tracePubSub } from "~/v3/services/tracePubSub.server";
 
 const PING_INTERVAL = 5_000;
@@ -36,8 +37,8 @@ export class RunStreamPresenter {
         // Scope the lookup to organizations the requesting user is a member
         // of, matching RunPresenter's run lookup. Unauthorized and missing
         // runs are indistinguishable (both 404).
-        const run = await prismaClient.taskRun.findFirst({
-          where: {
+        const run = await runStore.findRun(
+          {
             friendlyId: runFriendlyId,
             project: {
               organization: {
@@ -49,10 +50,13 @@ export class RunStreamPresenter {
               },
             },
           },
-          select: {
-            traceId: true,
+          {
+            select: {
+              traceId: true,
+            },
           },
-        });
+          prismaClient
+        );
 
         // Fall back to the mollifier buffer when the run isn't in PG yet.
         // The buffered run has no execution events to stream, but we still
diff --git a/apps/webapp/app/presenters/v3/SessionListPresenter.server.ts b/apps/webapp/app/presenters/v3/SessionListPresenter.server.ts
@@ -10,6 +10,7 @@ import {
 } from "~/services/sessionsRepository/sessionsRepository.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { findCurrentWorkerFromEnvironment } from "~/v3/models/workerDeployment.server";
+import { runStore } from "~/v3/runStore.server";
 import { startActiveSpan } from "~/v3/tracer.server";
 
 export type SessionListOptions = {
@@ -189,14 +190,17 @@ export class SessionListPresenter {
         // pointer could surface another tenant's run. The list query above
         // is already env-scoped; the run lookup needs the same fence.
         return currentRunIds.length > 0
-          ? this.replica.taskRun.findMany({
-              where: {
-                id: { in: currentRunIds },
-                projectId,
-                runtimeEnvironmentId: environmentId,
+          ? runStore.findRuns(
+              {
+                where: {
+                  id: { in: currentRunIds },
+                  projectId,
+                  runtimeEnvironmentId: environmentId,
+                },
+                select: { id: true, friendlyId: true },
               },
-              select: { id: true, friendlyId: true },
-            })
+              this.replica
+            )
           : [];
       }
     );
diff --git a/apps/webapp/app/presenters/v3/SessionPresenter.server.ts b/apps/webapp/app/presenters/v3/SessionPresenter.server.ts
@@ -6,6 +6,7 @@ import { chatSnapshotStorageKey } from "~/services/realtime/chatSnapshot.server"
 import { resolveSessionByIdOrExternalId } from "~/services/realtime/sessions.server";
 import { logger } from "~/services/logger.server";
 import { generatePresignedUrl } from "~/v3/objectStore.server";
+import { runStore } from "~/v3/runStore.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { startActiveSpan } from "~/v3/tracer.server";
 
@@ -96,10 +97,13 @@ export class SessionPresenter {
       async (span) => {
         span.setAttribute("runIds.count", runIds.length);
         return runIds.length > 0
-          ? this.replica.taskRun.findMany({
-              where: { id: { in: runIds } },
-              select: { id: true, friendlyId: true, status: true },
-            })
+          ? runStore.findRuns(
+              {
+                where: { id: { in: runIds } },
+                select: { id: true, friendlyId: true, status: true },
+              },
+              this.replica
+            )
           : [];
       }
     );
@@ -110,10 +114,13 @@ export class SessionPresenter {
         (await startActiveSpan(
           "SessionPresenter.findCurrentRunFallback",
           () =>
-            this.replica.taskRun.findFirst({
-              where: { id: session.currentRunId! },
-              select: { id: true, friendlyId: true, status: true },
-            })
+            runStore.findRun(
+              { id: session.currentRunId! },
+              {
+                select: { id: true, friendlyId: true, status: true },
+              },
+              this.replica
+            )
         ))
       : null;
 
diff --git a/apps/webapp/app/presenters/v3/SpanPresenter.server.ts b/apps/webapp/app/presenters/v3/SpanPresenter.server.ts
diff --git a/apps/webapp/app/presenters/v3/TestTaskPresenter.server.ts b/apps/webapp/app/presenters/v3/TestTaskPresenter.server.ts
