feat(webapp): derive the runs-list Postgres select from visible columns

The list select is now built from the columns actually shown. A run's
payload and output are large, so they are only hydrated when a smart
column references them; everything else the presenter needs stays
selected regardless.

Author: ericallam

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

@@ -25,6 +25,11 @@ import { machinePresetFromRun } from "~/v3/machinePresets.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { isCancellableRunStatus, isFinalRunStatus, isPendingRunStatus } from "~/v3/taskStatus";
 import { runTriggeredAt } from "~/v3/runTimestamps";
+import {
+  deriveRunSelect,
+  type RunColumnId,
+  type SmartColumnSource,
+} from "~/components/runs/v3/runColumns";
 
 // Positive-only cache: only envs known to have runs are stored (empty envs are re-checked),
 // so "has runs" is monotonic and the TTL can be very long. Tiered memory + Redis.
@@ -81,6 +86,15 @@ export type RunListOptions = {
   pageSize?: number;
   // Run the empty-state "has any run ever" probe. Only the runs list consumes it.
   includeHasAnyRuns?: boolean;
+  /**
+   * Visible-column set used to derive the Postgres select. Omitted => the
+   * default select (all fields, no payload/output). Provided by the list route
+   * so payload/output are only hydrated when a smart column references them.
+   */
+  columns?: {
+    visibleStandardIds: RunColumnId[];
+    smartSources: SmartColumnSource[];
+  };
 };
 
 const DEFAULT_PAGE_SIZE = 25;
@@ -159,6 +173,7 @@ export class NextRunListPresenter {
       cursor,
       pageSize = DEFAULT_PAGE_SIZE,
       includeHasAnyRuns = false,
+      columns,
     }: RunListOptions
   ) {
     //get the time values from the raw values (including a default period)
@@ -255,7 +270,12 @@ export class NextRunListPresenter {
       return date > now ? now : date;
     }
 
+    const runSelect = columns
+      ? deriveRunSelect(columns.visibleStandardIds, columns.smartSources)
+      : undefined;
+
     const { runs, pagination } = await runsRepository.listRuns({
+      runSelect,
       organizationId,
       environmentId,
       projectId,
@@ -335,6 +355,10 @@ export class NextRunListPresenter {
           rootTaskRunId: run.rootTaskRunId,
           metadata: run.metadata,
           metadataType: run.metadataType,
+          payload: run.payload,
+          payloadType: run.payloadType,
+          output: run.output,
+          outputType: run.outputType,
           machinePreset: run.machinePreset ? machinePresetFromRun(run)?.name : undefined,
           queue: {
             name: run.queue.replace("task/", ""),

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

@@ -0,0 +1,29 @@
+import {
+  resolveColumnLayout,
+  visibleSmartSources,
+  visibleStandardIds,
+  type RunColumnId,
+  type SmartColumnSource,
+} from "~/components/runs/v3/runColumns";
+
+/**
+ * Read the runs-list column state (`cols`/`sc`) off the request and resolve the
+ * column set the presenter needs to derive its Postgres select. Gates are
+ * resolved permissively here because they do not affect the always-selected
+ * fields; only the referenced smart-column sources change what is hydrated.
+ */
+export function getRunColumnsForSelect(request: Request): {
+  visibleStandardIds: RunColumnId[];
+  smartSources: SmartColumnSource[];
+} {
+  const url = new URL(request.url);
+  const layout = resolveColumnLayout(
+    { cols: url.searchParams.getAll("cols"), sc: url.searchParams.getAll("sc") },
+    { isManagedCloud: true, isDevelopment: false }
+  );
+
+  return {
+    visibleStandardIds: visibleStandardIds(layout.visible),
+    smartSources: visibleSmartSources(layout.visible),
+  };
+}

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs._index/route.tsx

@@ -52,6 +52,7 @@ import { findProjectBySlug } from "~/models/project.server";
 import { findEnvironmentBySlug } from "~/models/runtimeEnvironment.server";
 import { getRunFiltersFromRequest } from "~/presenters/RunFilters.server";
 import { NextRunListPresenter } from "~/presenters/v3/NextRunListPresenter.server";
+import { getRunColumnsForSelect } from "~/presenters/v3/runColumnsFromRequest.server";
 import { clickhouseFactory } from "~/services/clickhouse/clickhouseFactoryInstance.server";
 import {
   setRootOnlyFilterPreference,
@@ -123,6 +124,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
     projectId: project.id,
     ...filters,
     includeHasAnyRuns: true,
+    columns: getRunColumnsForSelect(request),
   });
 
   // Only persist rootOnly when no tasks are filtered. While a task filter is active,

apps/webapp/app/services/runsRepository/clickhouseRunsRepository.server.ts

@@ -15,9 +15,51 @@ import { decodeRunsCursor, encodeRunsCursor } from "./runsCursor.server";
 import { runStore } from "~/v3/runStore.server";
 import { type PrismaClientOrTransaction } from "~/db.server";
 
-import { boundedIn } from "@trigger.dev/database";
+import { boundedIn, type Prisma } from "@trigger.dev/database";
+import { type ListedRun } from "./runsRepository.server";
 type RunCursorRow = { runId: string; createdAt: number };
 
+/**
+ * Default hydrate select for the runs list, used when a caller does not derive
+ * one from the visible columns (bulk actions, the live poll). Kept in sync with
+ * the `ListedRun` payload type.
+ */
+const LIST_RUN_DEFAULT_SELECT = {
+  id: true,
+  friendlyId: true,
+  taskIdentifier: true,
+  taskVersion: true,
+  runtimeEnvironmentId: true,
+  status: true,
+  createdAt: true,
+  queueTimestamp: true,
+  scheduleId: true,
+  startedAt: true,
+  lockedAt: true,
+  delayUntil: true,
+  updatedAt: true,
+  completedAt: true,
+  isTest: true,
+  spanId: true,
+  idempotencyKey: true,
+  ttl: true,
+  expiredAt: true,
+  costInCents: true,
+  baseCostInCents: true,
+  usageDurationMs: true,
+  runTags: true,
+  depth: true,
+  rootTaskRunId: true,
+  batchId: true,
+  metadata: true,
+  metadataType: true,
+  machinePreset: true,
+  queue: true,
+  workerQueue: true,
+  region: true,
+  annotations: true,
+} satisfies Prisma.TaskRunSelect;
+
 /**
  * Hydrates a set of rows for a ClickHouse-derived run-id set against the given
  * read client. The closure MUST select `id` so `#hydrateRunsByIds` can key
@@ -264,52 +306,22 @@ export class ClickHouseRunsRepository implements IRunsRepository {
 
     const store = this.options.runStore ?? runStore;
 
-    let runs = await this.#hydrateRunsByIds(runIds, (client, ids) =>
+    const select: Prisma.TaskRunSelect = options.runSelect
+      ? { ...options.runSelect, id: true }
+      : LIST_RUN_DEFAULT_SELECT;
+
+    let runs = await this.#hydrateRunsByIds<ListedRun>(runIds, (client, ids) =>
       store.findRuns(
         {
           where: {
             id: {
               in: boundedIn(ids),
             },
           },
-          select: {
-            id: true,
-            friendlyId: true,
-            taskIdentifier: true,
-            taskVersion: true,
-            runtimeEnvironmentId: true,
-            status: true,
-            createdAt: true,
-            queueTimestamp: true,
-            scheduleId: true,
-            startedAt: true,
-            lockedAt: true,
-            delayUntil: true,
-            updatedAt: true,
-            completedAt: true,
-            isTest: true,
-            spanId: true,
-            idempotencyKey: true,
-            ttl: true,
-            expiredAt: true,
-            costInCents: true,
-            baseCostInCents: true,
-            usageDurationMs: true,
-            runTags: true,
-            depth: true,
-            rootTaskRunId: true,
-            batchId: true,
-            metadata: true,
-            metadataType: true,
-            machinePreset: true,
-            queue: true,
-            workerQueue: true,
-            region: true,
-            annotations: true,
-          },
+          select,
         },
         client
-      )
+      ) as Promise<ListedRun[]>
     );
 
     // ClickHouse is slightly delayed, so we're going to do in-memory status filtering too

apps/webapp/app/services/runsRepository/runsRepository.server.ts

@@ -127,9 +127,28 @@ export type ListedRun = Prisma.TaskRunGetPayload<{
     region: true;
     annotations: true;
   };
-}>;
+}> & {
+  /**
+   * Large source blobs hydrated only when a smart column references them (see
+   * `runSelect`). Absent from the default list select.
+   */
+  payload?: string;
+  payloadType?: string;
+  output?: string | null;
+  outputType?: string;
+};
 
-export type ListRunsOptions = RunListInputOptions & Pagination;
+export type ListRunsOptions = RunListInputOptions &
+  Pagination & {
+    /**
+     * Overrides the default list `select`. The runs list derives this from the
+     * visible columns so only the fields a shown column needs are hydrated (in
+     * particular payload/output are omitted unless a smart column asks). Must
+     * include `id` for hydration keying; behaviour-critical fields are enforced
+     * by the caller's `deriveRunSelect`.
+     */
+    runSelect?: Prisma.TaskRunSelect;
+  };
 
 export type TagListOptions = {
   organizationId: string;