fix(webapp): resolve cross-table run parent/root/children in presenters

A v2 run can reference a legacy parent/root, or have legacy children, when a hierarchy straddles a runTableV2 flip. Prisma relation selects are bound to one table, so the run, span, and API-retrieve presenters returned null parent/root and dropped cross-table children. They now resolve parent/root by id (RunStore routes by id format) and children by a both-table predicate, via a shared hydrateParentAndRoot/hydrateChildRuns helper.

Author: d-cs

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

@@ -23,6 +23,7 @@ import {
 } from "~/v3/mollifier/readFallback.server";
 import { generatePresignedUrl } from "~/v3/objectStore.server";
 import { runStore } from "~/v3/runStore.server";
+import { hydrateParentAndRoot, hydrateChildRuns } from "~/v3/runHierarchy.server";
 import { tracer } from "~/v3/tracer.server";
 import { startSpanWithEnv } from "~/v3/tracing.server";
 
@@ -133,21 +134,28 @@ export class ApiRetrieveRunPresenter {
           attemptNumber: true,
           engine: true,
           taskEventStore: true,
-          parentTaskRun: {
-            select: commonRunSelect,
-          },
-          rootTaskRun: {
-            select: commonRunSelect,
-          },
-          childRuns: {
-            select: commonRunSelect,
-          },
+          parentTaskRunId: true,
+          rootTaskRunId: true,
         },
       },
       $replica
     );
 
-    if (pgRow) return { ...pgRow, isBuffered: false };
+    if (pgRow) {
+      // Resolve parent/root/children across both run tables. A single Prisma
+      // relation select is table-bound, so a v2 run's legacy parent (or a
+      // legacy run's v2 children), which arise in the mixed window, would come
+      // back null/empty. Resolve parent/root by id (RunStore routes by format)
+      // and children by a both-table predicate.
+      const { parentTaskRun, rootTaskRun } = await hydrateParentAndRoot(
+        { parentTaskRunId: pgRow.parentTaskRunId, rootTaskRunId: pgRow.rootTaskRunId },
+        commonRunSelect,
+        $replica
+      );
+      const childRuns = await hydrateChildRuns(pgRow.id, commonRunSelect, $replica);
+
+      return { ...pgRow, parentTaskRun, rootTaskRun, childRuns, isBuffered: false };
+    }
 
     // Postgres miss → fall back to the mollifier buffer. When the gate
     // diverted a trigger, the run lives in Redis until the drainer replays

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

@@ -9,6 +9,7 @@ import { isFinalRunStatus } from "~/v3/taskStatus";
 import { env } from "~/env.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
 import { runStore } from "~/v3/runStore.server";
+import { hydrateParentAndRoot } from "~/v3/runHierarchy.server";
 
 type Result = Awaited<ReturnType<RunPresenter["call"]>>;
 export type Run = Result["run"];
@@ -93,20 +94,8 @@ export class RunPresenter {
           completedAt: true,
           logsDeletedAt: true,
           annotations: true,
-          rootTaskRun: {
-            select: {
-              friendlyId: true,
-              spanId: true,
-              createdAt: true,
-            },
-          },
-          parentTaskRun: {
-            select: {
-              friendlyId: true,
-              spanId: true,
-              createdAt: true,
-            },
-          },
+          rootTaskRunId: true,
+          parentTaskRunId: true,
           runtimeEnvironment: {
             select: {
               id: true,
@@ -143,6 +132,15 @@ export class RunPresenter {
 
     const showLogs = showDeletedLogs || !run.logsDeletedAt;
 
+    // Resolve parent/root across both physical run tables: a v2 run can have a
+    // legacy parent/root (or vice versa) in the mixed window, which a
+    // table-bound Prisma relation select would miss.
+    const { parentTaskRun, rootTaskRun } = await hydrateParentAndRoot(
+      { parentTaskRunId: run.parentTaskRunId, rootTaskRunId: run.rootTaskRunId },
+      { friendlyId: true, spanId: true, createdAt: true },
+      this.#prismaClient
+    );
+
     const runData = {
       id: run.id,
       number: run.number,
@@ -154,8 +152,8 @@ export class RunPresenter {
       startedAt: run.startedAt,
       completedAt: run.completedAt,
       logsDeletedAt: showDeletedLogs ? null : run.logsDeletedAt,
-      rootTaskRun: run.rootTaskRun,
-      parentTaskRun: run.parentTaskRun,
+      rootTaskRun,
+      parentTaskRun,
       environment: {
         id: run.runtimeEnvironment.id,
         organizationId: run.runtimeEnvironment.organizationId,
@@ -184,7 +182,7 @@ export class RunPresenter {
       getTaskEventStoreTableForRun(run),
       run.runtimeEnvironment.id,
       run.traceId,
-      run.rootTaskRun?.createdAt ?? run.createdAt,
+      rootTaskRun?.createdAt ?? run.createdAt,
       run.completedAt ?? undefined,
       { includeDebugLogs: showDebug }
     );

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

@@ -587,22 +587,9 @@ export class SpanPresenter extends BasePresenter {
             filePath: true,
           },
         },
-        //relationships
-        rootTaskRun: {
-          select: {
-            taskIdentifier: true,
-            friendlyId: true,
-            spanId: true,
-            createdAt: true,
-          },
-        },
-        parentTaskRun: {
-          select: {
-            taskIdentifier: true,
-            friendlyId: true,
-            spanId: true,
-          },
-        },
+        //relationships (resolved across both run tables after the fetch)
+        rootTaskRunId: true,
+        parentTaskRunId: true,
         batch: {
           select: {
             friendlyId: true,
@@ -626,7 +613,31 @@ export class SpanPresenter extends BasePresenter {
       this._replica
     );
 
-    return run;
+    if (!run) {
+      return run;
+    }
+
+    // Resolve parent/root across both run tables: a v2 run can reference a
+    // legacy parent/root (or vice versa) in the mixed window, which a
+    // table-bound Prisma relation select on a single table would miss.
+    const [parentTaskRun, rootTaskRun] = await Promise.all([
+      run.parentTaskRunId
+        ? runStore.findRun(
+            { id: run.parentTaskRunId },
+            { select: { taskIdentifier: true, friendlyId: true, spanId: true } },
+            this._replica
+          )
+        : Promise.resolve(null),
+      run.rootTaskRunId
+        ? runStore.findRun(
+            { id: run.rootTaskRunId },
+            { select: { taskIdentifier: true, friendlyId: true, spanId: true, createdAt: true } },
+            this._replica
+          )
+        : Promise.resolve(null),
+    ]);
+
+    return { ...run, parentTaskRun, rootTaskRun };
   }
 
   async #getSpan({

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

@@ -0,0 +1,56 @@
+import type { Prisma, PrismaClientOrTransaction, PrismaReplicaClient } from "@trigger.dev/database";
+import { runStore } from "~/v3/runStore.server";
+
+type ReadClient = PrismaClientOrTransaction | PrismaReplicaClient;
+
+/**
+ * Resolve a run's parent and root runs across BOTH physical run tables.
+ *
+ * A run's `parentTaskRunId`/`rootTaskRunId` are plain scalar ids whose target
+ * may live in either `TaskRun` (legacy cuid) or `task_run_v2` (new ksuid) — for
+ * example a v2 child of a legacy parent, created while the org's `runTableV2`
+ * flag was mid-flip. A single Prisma relation select (`parentTaskRun { ... }`)
+ * is bound to one table and silently returns `null` for such a cross-table
+ * parent/root. Resolving each by id instead lets RunStore route to the correct
+ * table by id format. Pass the same `select` the caller would have used on the
+ * relation.
+ */
+export async function hydrateParentAndRoot<S extends Prisma.TaskRunSelect>(
+  ids: { parentTaskRunId: string | null; rootTaskRunId: string | null },
+  select: S,
+  client?: ReadClient
+): Promise<{
+  parentTaskRun: Prisma.TaskRunGetPayload<{ select: S }> | null;
+  rootTaskRun: Prisma.TaskRunGetPayload<{ select: S }> | null;
+}> {
+  const [parentTaskRun, rootTaskRun] = await Promise.all([
+    ids.parentTaskRunId
+      ? runStore.findRun({ id: ids.parentTaskRunId }, { select }, client)
+      : Promise.resolve(null),
+    ids.rootTaskRunId
+      ? runStore.findRun({ id: ids.rootTaskRunId }, { select }, client)
+      : Promise.resolve(null),
+  ]);
+
+  return {
+    parentTaskRun: parentTaskRun as Prisma.TaskRunGetPayload<{ select: S }> | null,
+    rootTaskRun: rootTaskRun as Prisma.TaskRunGetPayload<{ select: S }> | null,
+  };
+}
+
+/**
+ * A run's direct child runs across BOTH physical tables. Children reference the
+ * parent by the scalar `parentTaskRunId`, and a v2 parent can have legacy cuid
+ * children (or vice versa) in the mixed window, so this is a non-id predicate
+ * read that `findRuns` resolves against both tables.
+ */
+export async function hydrateChildRuns<S extends Prisma.TaskRunSelect>(
+  parentRunId: string,
+  select: S,
+  client?: ReadClient
+): Promise<Prisma.TaskRunGetPayload<{ select: S }>[]> {
+  return runStore.findRuns(
+    { where: { parentTaskRunId: parentRunId }, select },
+    client
+  ) as Promise<Prisma.TaskRunGetPayload<{ select: S }>[]>;
+}