refactor(webapp): hydrate parent-model TaskRun reads through the run store

Decompose the three reads that pulled TaskRun in through a parent model's
relation include (alert, batch results, attempt dependencies): query the
parent without the include, hydrate the run(s) via RunStore in a single
batched read, and stitch them back. Preserves field selection, ordering,
null handling and the query client. Adds container-backed tests for the
batch-results and cancel-dependencies paths.

Author: d-cs

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

@@ -1,6 +1,7 @@
 import { BatchTaskRunExecutionResult } from "@trigger.dev/core/v3";
-import { executionResultForTaskRun } from "~/models/taskRun.server";
+import { executionResultForTaskRun, TaskRunWithAttempts } from "~/models/taskRun.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { runStore } from "~/v3/runStore.server";
 import { BasePresenter } from "./basePresenter.server";
 
 export class ApiBatchResultsPresenter extends BasePresenter {
@@ -16,16 +17,8 @@ export class ApiBatchResultsPresenter extends BasePresenter {
         },
         include: {
           items: {
-            include: {
-              taskRun: {
-                include: {
-                  attempts: {
-                    orderBy: {
-                      createdAt: "desc",
-                    },
-                  },
-                },
-              },
+            select: {
+              taskRunId: true,
             },
           },
         },
@@ -35,10 +28,48 @@ export class ApiBatchResultsPresenter extends BasePresenter {
         return undefined;
       }
 
+      const taskRunIds = batchRun.items.map((item) => item.taskRunId);
+
+      if (taskRunIds.length === 0) {
+        return {
+          id: batchRun.friendlyId,
+          items: [],
+        };
+      }
+
+      const taskRuns = await runStore.findRuns(
+        {
+          where: { id: { in: taskRunIds } },
+          select: {
+            id: true,
+            friendlyId: true,
+            status: true,
+            taskIdentifier: true,
+            attempts: {
+              select: {
+                status: true,
+                output: true,
+                outputType: true,
+                error: true,
+              },
+              orderBy: {
+                createdAt: "desc",
+              },
+            },
+          },
+        },
+        this._prisma
+      );
+
+      const runMap = new Map(taskRuns.map((run) => [run.id, run]));
+
       return {
         id: batchRun.friendlyId,
         items: batchRun.items
-          .map((item) => executionResultForTaskRun(item.taskRun))
+          .map((item) => {
+            const run = runMap.get(item.taskRunId);
+            return run ? executionResultForTaskRun(run as TaskRunWithAttempts) : undefined;
+          })
           .filter(Boolean),
       };
     });

apps/webapp/app/v3/services/alerts/deliverAlert.server.ts

@@ -102,7 +102,7 @@ type DeploymentIntegrationMetadata = {
 
 export class DeliverAlertService extends BaseService {
   public async call(alertId: string) {
-    const alert: FoundAlert | null = await this._prisma.projectAlert.findFirst({
+    const alertWithoutRun = await this._prisma.projectAlert.findFirst({
       where: { id: alertId },
       include: {
         channel: true,
@@ -112,18 +112,6 @@ export class DeliverAlertService extends BaseService {
           },
         },
         environment: true,
-        taskRun: {
-          include: {
-            lockedBy: true,
-            lockedToVersion: true,
-            runtimeEnvironment: {
-              select: {
-                type: true,
-                branchName: true,
-              },
-            },
-          },
-        },
         workerDeployment: {
           include: {
             worker: {
@@ -142,10 +130,32 @@ export class DeliverAlertService extends BaseService {
       },
     });
 
-    if (!alert) {
+    if (!alertWithoutRun) {
       return;
     }
 
+    let taskRun: FoundAlert["taskRun"] = null;
+    if (alertWithoutRun.taskRunId) {
+      taskRun = await this.runStore.findRun(
+        { id: alertWithoutRun.taskRunId },
+        {
+          include: {
+            lockedBy: true,
+            lockedToVersion: true,
+            runtimeEnvironment: {
+              select: {
+                type: true,
+                branchName: true,
+              },
+            },
+          },
+        },
+        this._prisma
+      );
+    }
+
+    const alert: FoundAlert = { ...alertWithoutRun, taskRun };
+
     if (alert.status !== "PENDING") {
       return;
     }

apps/webapp/app/v3/services/cancelTaskAttemptDependencies.server.ts

@@ -10,15 +10,15 @@ export class CancelTaskAttemptDependenciesService extends BaseService {
       where: { id: attemptId },
       include: {
         dependencies: {
-          include: {
-            taskRun: true,
+          select: {
+            taskRunId: true,
           },
         },
         batchDependencies: {
           include: {
             runDependencies: {
-              include: {
-                taskRun: true,
+              select: {
+                taskRunId: true,
               },
             },
           },
@@ -45,14 +45,53 @@ export class CancelTaskAttemptDependenciesService extends BaseService {
       batchDependencies: taskAttempt.batchDependencies,
     });
 
+    // Hydrate the dependent runs from both relation paths in a single batched read,
+    // deduping the ids that feed the query while preserving the original iteration order.
+    const taskRunIds = new Set<string>();
+    for (const dependency of taskAttempt.dependencies) {
+      taskRunIds.add(dependency.taskRunId);
+    }
+    for (const batchDependency of taskAttempt.batchDependencies) {
+      for (const runDependency of batchDependency.runDependencies) {
+        taskRunIds.add(runDependency.taskRunId);
+      }
+    }
+
+    const runs =
+      taskRunIds.size > 0
+        ? await this.runStore.findRuns(
+            {
+              where: { id: { in: [...taskRunIds] } },
+              select: {
+                id: true,
+                engine: true,
+                status: true,
+                friendlyId: true,
+                taskEventStore: true,
+                createdAt: true,
+                completedAt: true,
+              },
+            },
+            this._prisma
+          )
+        : [];
+
+    const runMap = new Map(runs.map((run) => [run.id, run]));
+
     // TaskAttempt will either have dependencies or batchDependencies
     for (const dependency of taskAttempt.dependencies) {
-      await cancelRunService.call(dependency.taskRun);
+      const run = runMap.get(dependency.taskRunId);
+      if (run) {
+        await cancelRunService.call(run);
+      }
     }
 
     for (const batchDependency of taskAttempt.batchDependencies) {
       for (const runDependency of batchDependency.runDependencies) {
-        await cancelRunService.call(runDependency.taskRun);
+        const run = runMap.get(runDependency.taskRunId);
+        if (run) {
+          await cancelRunService.call(run);
+        }
       }
     }
   }