feat(run-store): add full-row read overload to the run store

Add a no-args overload to findRun, findRunOrThrow and findRuns that
returns the whole TaskRun row, for callers that read a run without a
select or include.

Author: d-cs

internal-packages/run-store/src/PostgresRunStore.test.ts

@@ -1683,4 +1683,92 @@ describe("PostgresRunStore — read", () => {
     expect(run?.id).toBe(runId);
     expect(run?.status).toBe("PENDING");
   });
+
+  postgresTest("findRun by id with no projection returns the whole row", async ({ prisma }) => {
+    const { organization, project, environment } = await seedEnvironment(prisma);
+
+    const store = new PostgresRunStore({ prisma, readOnlyPrisma: prisma });
+    const runId = "run_find_full_row_1";
+
+    await store.createRun(
+      buildCreateRunInput({
+        runId,
+        organizationId: organization.id,
+        projectId: project.id,
+        runtimeEnvironmentId: environment.id,
+      })
+    );
+
+    const run = await store.findRun({ id: runId });
+
+    expect(run?.id).toBe(runId);
+    expect(run?.friendlyId).toBe("run_friendly_1");
+    expect(run?.status).toBe("PENDING");
+    expect(run?.taskIdentifier).toBe("my-task");
+    // The whole-row variant returns the full scalar set, not a projection.
+    expect(run?.payload).toBe("{}");
+    expect(run?.payloadType).toBe("application/json");
+  });
+
+  postgresTest("findRunOrThrow with no projection throws when no row matches", async ({ prisma }) => {
+    await seedEnvironment(prisma);
+
+    const store = new PostgresRunStore({ prisma, readOnlyPrisma: prisma });
+
+    await expect(store.findRunOrThrow({ id: "missing" })).rejects.toThrow();
+  });
+
+  postgresTest("findRuns with no projection returns whole rows", async ({ prisma }) => {
+    const { organization, project, environment } = await seedEnvironment(prisma);
+
+    const store = new PostgresRunStore({ prisma, readOnlyPrisma: prisma });
+
+    const earliest = new Date("2026-07-01T00:00:00.000Z");
+    const latest = new Date("2026-07-02T00:00:00.000Z");
+
+    const rows: Array<{ id: string; createdAt: Date }> = [
+      { id: "run_find_full_many_earliest", createdAt: earliest },
+      { id: "run_find_full_many_latest", createdAt: latest },
+    ];
+
+    for (const row of rows) {
+      await prisma.taskRun.create({
+        data: {
+          id: row.id,
+          engine: "V2",
+          status: "PENDING",
+          friendlyId: `${row.id}_friendly`,
+          runtimeEnvironmentId: environment.id,
+          environmentType: "DEVELOPMENT",
+          organizationId: organization.id,
+          projectId: project.id,
+          taskIdentifier: "my-task",
+          payload: "{}",
+          payloadType: "application/json",
+          traceContext: {},
+          traceId: `trace_${row.id}`,
+          spanId: `span_${row.id}`,
+          queue: "task/my-task",
+          isTest: false,
+          taskEventStore: "taskEvent",
+          depth: 0,
+          createdAt: row.createdAt,
+        },
+      });
+    }
+
+    const found = await store.findRuns({
+      where: { projectId: project.id },
+      orderBy: { createdAt: "desc" },
+    });
+
+    expect(found).toHaveLength(2);
+    expect(found.map((r) => r.id)).toEqual([
+      "run_find_full_many_latest",
+      "run_find_full_many_earliest",
+    ]);
+    // Whole rows include full scalar columns.
+    expect(found[0]?.taskIdentifier).toBe("my-task");
+    expect(found[0]?.payloadType).toBe("application/json");
+  });
 });

internal-packages/run-store/src/PostgresRunStore.ts

@@ -628,12 +628,16 @@ export class PostgresRunStore implements RunStore {
     args: { include: I },
     client?: PrismaClientOrTransaction
   ): Promise<Prisma.TaskRunGetPayload<{ include: I }> | null>;
+  findRun(
+    where: Prisma.TaskRunWhereInput,
+    client?: PrismaClientOrTransaction
+  ): Promise<TaskRun | null>;
   async findRun(
     where: Prisma.TaskRunWhereInput,
-    args: { select?: Prisma.TaskRunSelect; include?: Prisma.TaskRunInclude },
+    argsOrClient?: { select?: Prisma.TaskRunSelect; include?: Prisma.TaskRunInclude } | PrismaClientOrTransaction,
     client?: PrismaClientOrTransaction
   ): Promise<unknown> {
-    const prisma = client ?? this.readOnlyPrisma;
+    const { args, prisma } = this.#resolveReadArgs(argsOrClient, client);
 
     return prisma.taskRun.findFirst({
       where,
@@ -651,12 +655,16 @@ export class PostgresRunStore implements RunStore {
     args: { include: I },
     client?: PrismaClientOrTransaction
   ): Promise<Prisma.TaskRunGetPayload<{ include: I }>>;
+  findRunOrThrow(
+    where: Prisma.TaskRunWhereInput,
+    client?: PrismaClientOrTransaction
+  ): Promise<TaskRun>;
   async findRunOrThrow(
     where: Prisma.TaskRunWhereInput,
-    args: { select?: Prisma.TaskRunSelect; include?: Prisma.TaskRunInclude },
+    argsOrClient?: { select?: Prisma.TaskRunSelect; include?: Prisma.TaskRunInclude } | PrismaClientOrTransaction,
     client?: PrismaClientOrTransaction
   ): Promise<unknown> {
-    const prisma = client ?? this.readOnlyPrisma;
+    const { args, prisma } = this.#resolveReadArgs(argsOrClient, client);
 
     return prisma.taskRun.findFirstOrThrow({
       where,
@@ -686,6 +694,16 @@ export class PostgresRunStore implements RunStore {
     },
     client?: PrismaClientOrTransaction
   ): Promise<Prisma.TaskRunGetPayload<{ include: I }>[]>;
+  findRuns(
+    args: {
+      where: Prisma.TaskRunWhereInput;
+      orderBy?: Prisma.TaskRunOrderByWithRelationInput | Prisma.TaskRunOrderByWithRelationInput[];
+      take?: number;
+      skip?: number;
+      cursor?: Prisma.TaskRunWhereUniqueInput;
+    },
+    client?: PrismaClientOrTransaction
+  ): Promise<TaskRun[]>;
   async findRuns(
     args: {
       where: Prisma.TaskRunWhereInput;
@@ -702,4 +720,41 @@ export class PostgresRunStore implements RunStore {
 
     return prisma.taskRun.findMany(args);
   }
+
+  /**
+   * The single-row read methods (`findRun`, `findRunOrThrow`) accept either
+   * `(where, { select | include }, client?)` or the full-row `(where, client?)`.
+   * Disambiguate the second positional arg: a `{ select }` / `{ include }`
+   * projection object vs. a Prisma client. A projection object always carries a
+   * `select` or `include` key; a Prisma client never does. Anything else (e.g.
+   * `undefined`) is treated as "no projection, no explicit client".
+   */
+  #resolveReadArgs(
+    argsOrClient:
+      | { select?: Prisma.TaskRunSelect; include?: Prisma.TaskRunInclude }
+      | PrismaClientOrTransaction
+      | undefined,
+    client: PrismaClientOrTransaction | undefined
+  ): {
+    args: { select?: Prisma.TaskRunSelect; include?: Prisma.TaskRunInclude };
+    prisma: PrismaClientOrTransaction | PrismaReplicaClient;
+  } {
+    const isProjection =
+      typeof argsOrClient === "object" &&
+      argsOrClient !== null &&
+      ("select" in argsOrClient || "include" in argsOrClient);
+
+    if (isProjection) {
+      return {
+        args: argsOrClient as { select?: Prisma.TaskRunSelect; include?: Prisma.TaskRunInclude },
+        prisma: client ?? this.readOnlyPrisma,
+      };
+    }
+
+    // No projection: the second positional arg, when present, is the client.
+    return {
+      args: {},
+      prisma: (argsOrClient as PrismaClientOrTransaction | undefined) ?? this.readOnlyPrisma,
+    };
+  }
 }

internal-packages/run-store/src/types.ts

@@ -331,6 +331,7 @@ export interface RunStore {
     args: { include: I },
     client?: PrismaClientOrTransaction
   ): Promise<Prisma.TaskRunGetPayload<{ include: I }> | null>;
+  findRun(where: Prisma.TaskRunWhereInput, client?: PrismaClientOrTransaction): Promise<TaskRun | null>;
 
   findRunOrThrow<S extends Prisma.TaskRunSelect>(
     where: Prisma.TaskRunWhereInput,
@@ -342,6 +343,7 @@ export interface RunStore {
     args: { include: I },
     client?: PrismaClientOrTransaction
   ): Promise<Prisma.TaskRunGetPayload<{ include: I }>>;
+  findRunOrThrow(where: Prisma.TaskRunWhereInput, client?: PrismaClientOrTransaction): Promise<TaskRun>;
 
   findRuns<S extends Prisma.TaskRunSelect>(
     args: {
@@ -365,4 +367,14 @@ export interface RunStore {
     },
     client?: PrismaClientOrTransaction
   ): Promise<Prisma.TaskRunGetPayload<{ include: I }>[]>;
+  findRuns(
+    args: {
+      where: Prisma.TaskRunWhereInput;
+      orderBy?: Prisma.TaskRunOrderByWithRelationInput | Prisma.TaskRunOrderByWithRelationInput[];
+      take?: number;
+      skip?: number;
+      cursor?: Prisma.TaskRunWhereUniqueInput;
+    },
+    client?: PrismaClientOrTransaction
+  ): Promise<TaskRun[]>;
 }