@shipfox/api-workflows 12.6.0 → 12.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-workflows",
   "license": "MIT",
-  "version": "12.6.0",
+  "version": "12.7.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -32,7 +32,7 @@
     "@shipfox/api-integration-core-dto": "12.2.0",
     "@shipfox/api-runners-dto": "12.4.0",
     "@shipfox/api-secrets-dto": "12.0.0",
-    "@shipfox/api-workflows-dto": "12.6.0",
+    "@shipfox/api-workflows-dto": "12.7.0",
     "@shipfox/api-workspaces-dto": "12.0.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/inter-module": "0.2.3",

package/src/core/entities/workflow-run.ts

@@ -107,4 +107,7 @@ export interface WorkflowRunDetail extends WorkflowRun {
   runAttempt: WorkflowRunAttempt;
   latestAttempt: number;
   jobs: WorkflowJobDetail[];
+  /** Whether any job execution of this attempt reached its runner, decided here so the detail
+   * and the list cannot answer it differently. */
+  hasStartedJobExecution: boolean;
 }

package/src/db/workflow-runs/queries.test.ts

@@ -14,6 +14,7 @@ import {
   listRunAttempts,
   listWorkflowRunJobSummaries,
   listWorkflowRunsByProject,
+  recordJobExecutionStartedAt,
   updateJobExecutionStatus,
   updateJobStatus,
   updateWorkflowRunStatus,
@@ -273,6 +274,32 @@ describe('workflow run queries', () => {
       ]);
 
       expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'pending', count: 2}]);
+      expect(summary.get(run.id)?.hasStartedJobExecution).toBe(false);
+    });
+
+    test('reports when any current-attempt job execution has started', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'echo build'}]}}}),
+        triggerPayload: manualTrigger(),
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('Expected workflow job');
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('Expected workflow job execution');
+
+      await recordJobExecutionStartedAt({
+        jobExecutionId: execution.id,
+        startedAt: new Date('2026-05-07T01:00:05.000Z'),
+      });
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.hasStartedJobExecution).toBe(true);
     });
 
     test('returns execution evidence and counts its display status', async () => {

package/src/db/workflow-runs/queries.ts

@@ -213,7 +213,8 @@ export interface WorkflowRunJobSummaryTarget {
 }
 
 /**
- * A page row's jobs: a bounded slice to draw, and totals describing all of them.
+ * A page row's jobs: a bounded slice to draw, totals describing all of them, and whether any
+ * execution has reached a runner.
  *
  * The preview is what a row can show; `statusCounts` is what it can say. Keeping the counts
  * server-side is what lets a row report a failure that sits past the preview. Counts use the
@@ -225,6 +226,7 @@ export interface WorkflowRunJobsSummary {
   preview: WorkflowRunJobSummary[];
   statusCounts: WorkflowRunJobStatusCount[];
   rawStatusCounts: WorkflowRunJobRawStatusCount[];
+  hasStartedJobExecution: boolean;
 }
 
 export interface WorkflowRunJobStatusCount {
@@ -253,8 +255,8 @@ export interface WorkflowRunJobRawStatusCount {
  * attempt 1's run metadata with attempt 2's jobs, and the row would report a status its strip
  * contradicts.
  *
- * The two reads share one repeatable-read snapshot. They describe the same jobs at the same
- * instant, and the strip combines them into a single glyph row, so under the default
+ * The reads share one repeatable-read snapshot. They describe the same jobs and executions at
+ * the same instant, and the strip combines them into a single glyph row, so under the default
  * read-committed isolation a job settling between the statements would draw a pending glyph
  * beside a summary counting it as failed. Sequential inside one transaction is the cost of
  * that; at a four-second poll the extra round trip does not register.
@@ -321,6 +323,14 @@ export async function listWorkflowRunJobSummaries(
         .leftJoin(selectedExecution, eq(selectedExecution.jobId, jobs.id))
         .where(attemptFilter)
         .as('ranked');
+      // Correlated per job rather than a grouped scan of `job_executions`: an aggregate over the
+      // whole table cannot have the page's filter pushed into it, so it would read every execution
+      // ever recorded on each poll and grow with history rather than with the page.
+      const hasStartedJobExecution = sql<boolean>`bool_or(exists (
+        select 1
+        from ${jobExecutions}
+        where ${jobExecutions.jobId} = ${jobs.id} and ${jobExecutions.startedAt} is not null
+      ))`;
 
       const executionDisplayStatus = sql<JobExecutionStatus | null>`
         ${selectedExecution.executionStatus}
@@ -356,6 +366,7 @@ export async function listWorkflowRunJobSummaries(
             rawStatus: jobs.status,
             status: displayStatus,
             count: count(),
+            hasStartedJobExecution,
           })
           .from(jobs)
           .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
@@ -370,10 +381,18 @@ export async function listWorkflowRunJobSummaries(
   for (const {workflowRunId, ...summary} of previewRows) {
     summaryFor(summaries, workflowRunId).preview.push(summary);
   }
-  for (const {workflowRunId, rawStatus, status, count: statusCount} of countRows) {
+  for (const {
+    workflowRunId,
+    rawStatus,
+    status,
+    count: statusCount,
+    hasStartedJobExecution,
+  } of countRows) {
     const summary = summaryFor(summaries, workflowRunId);
     appendStatusCount(summary.rawStatusCounts, rawStatus, statusCount);
     appendStatusCount(summary.statusCounts, status, statusCount);
+    // One row per (run, verdict, display status), so the run's answer is the OR of its groups.
+    summary.hasStartedJobExecution ||= hasStartedJobExecution;
   }
 
   return summaries;
@@ -385,7 +404,12 @@ function summaryFor(
 ): WorkflowRunJobsSummary {
   const existing = summaries.get(workflowRunId);
   if (existing) return existing;
-  const created: WorkflowRunJobsSummary = {preview: [], statusCounts: [], rawStatusCounts: []};
+  const created: WorkflowRunJobsSummary = {
+    preview: [],
+    statusCounts: [],
+    rawStatusCounts: [],
+    hasStartedJobExecution: false,
+  };
   summaries.set(workflowRunId, created);
   return created;
 }
@@ -606,6 +630,8 @@ function hydrateWorkflowRunDetail(
     runAttempt: toWorkflowRunAttempt(attempt),
     latestAttempt,
     jobs: [],
+    // Read off the same rows the executions come from, so the flag cannot contradict them.
+    hasStartedJobExecution: rows.some((row) => row.jobExecution?.startedAt != null),
   };
   const jobById = new Map<string, WorkflowJobDetail>();
   const jobExecutionById = new Map<string, JobExecutionDetail>();

package/src/presentation/dto/workflow-run.ts

@@ -33,7 +33,12 @@ export function toRunDto(run: WorkflowRun, latestAttempt = run.currentAttempt):
   };
 }
 
-const EMPTY_JOBS: WorkflowRunJobsSummary = {preview: [], statusCounts: [], rawStatusCounts: []};
+const EMPTY_JOBS: WorkflowRunJobsSummary = {
+  preview: [],
+  statusCounts: [],
+  rawStatusCounts: [],
+  hasStartedJobExecution: false,
+};
 
 export function toRunListItemDto(
   run: WorkflowRun,
@@ -53,6 +58,7 @@ export function toRunListItemDto(
     })),
     job_status_counts: jobs.rawStatusCounts.map(({status, count}) => ({status, count})),
     job_display_status_counts: jobs.statusCounts.map(({status, count}) => ({status, count})),
+    has_started_job_execution: jobs.hasStartedJobExecution,
   };
 }
 

package/src/presentation/routes/get-run.test.ts

@@ -21,6 +21,7 @@ import {
   getJobExecutionsByJobId,
   getJobsByWorkflowRunId,
   getStepsByJobId,
+  recordJobExecutionStartedAt,
   updateWorkflowRunStatus,
 } from '#db/workflow-runs.js';
 import {workflowModel} from '#test/index.js';
@@ -137,6 +138,36 @@ describe('GET /api/workflows/runs/:id', () => {
     expect(body.jobs[0]).not.toHaveProperty('finished_at');
   });
 
+  // The run list decides this from the same executions, so a run detail that answered it from
+  // its own payload could drift from the row the user clicked through.
+  test('reports whether any job execution of the attempt reached its runner', async () => {
+    const run = await createWorkflowRun({
+      workspaceId,
+      projectId: crypto.randomUUID(),
+      definitionId: crypto.randomUUID(),
+      model: workflowModel({name: 'Test', jobs: {build: {steps: [{run: 'npm build'}]}}}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+
+    const before = await app.inject({method: 'GET', url: `/api/workflows/runs/${run.id}`});
+    expect(before.json().has_started_job_execution).toBe(false);
+
+    const [job] = await getJobsByWorkflowRunId(run.id);
+    const [execution] = await getJobExecutionsByJobId(job?.id ?? '');
+    await recordJobExecutionStartedAt({
+      jobExecutionId: execution?.id ?? '',
+      startedAt: new Date('2026-05-07T01:00:05.000Z'),
+    });
+
+    const after = await app.inject({method: 'GET', url: `/api/workflows/runs/${run.id}`});
+    expect(after.json().has_started_job_execution).toBe(true);
+  });
+
   test('does not aggregate latest_attempt for a first attempt without lineage', async () => {
     const latestAttemptSpy = vi.spyOn(dbIndex, 'getLatestAttempt');
     const run = await createWorkflowRun({

package/src/presentation/routes/get-run.ts

@@ -63,6 +63,7 @@ export function getRunRoute(projects: ProjectsModuleClient) {
         ...toRunDto(run, run.latestAttempt),
         run_attempt: toRunAttemptDto(run.runAttempt),
         jobs: jobDtos,
+        has_started_job_execution: run.hasStartedJobExecution,
       };
     },
   });

package/src/presentation/routes/list-runs.test.ts

@@ -99,7 +99,11 @@ describe('GET /api/workflows/runs', () => {
     expect(body.runs[0].workflow_name).toBeDefined();
     expect(body.runs[0].trigger_source).toBe('manual');
     // The runs list carries run-level timing (null until the run starts).
-    expect(body.runs[0]).toMatchObject({started_at: null, finished_at: null});
+    expect(body.runs[0]).toMatchObject({
+      started_at: null,
+      finished_at: null,
+      has_started_job_execution: false,
+    });
     expect(body.next_cursor).toBeNull();
     expect(body.filtered_total_count).toBe(2);
   });