@shipfox/api-workflows 12.4.0 → 12.6.0

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

@@ -1,5 +1,8 @@
 import {WORKFLOW_RUN_JOB_PREVIEW_LIMIT} from '@shipfox/api-workflows-dto';
+import {eq} from 'drizzle-orm';
 import {buildModel, createTestRun} from '#test/helpers/workflow-runs.js';
+import {db} from '../db.js';
+import {jobs} from '../schema/jobs.js';
 import {
   createRerunWorkflowRun,
   createWorkflowRun,
@@ -272,6 +275,147 @@ describe('workflow run queries', () => {
       expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'pending', count: 2}]);
     });
 
+    test('returns execution evidence and counts its display status', 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 the run to have a job');
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('expected the job to have an execution');
+
+      await updateJobExecutionStatus({
+        jobExecutionId: execution.id,
+        status: 'running',
+        expectedVersion: execution.version,
+      });
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.preview).toMatchObject([
+        {
+          status: 'pending',
+          mode: 'one_shot',
+          listenerStatus: 'inactive',
+          executionStatus: 'running',
+        },
+      ]);
+      expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'running', count: 1}]);
+      expect(summary.get(run.id)?.rawStatusCounts).toEqual([{status: 'pending', count: 1}]);
+    });
+
+    test('counts an active listener without an execution', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {
+            listen: {
+              listening: {
+                on: [{source: 'github', event: 'push'}],
+                onResolve: 'finish',
+              },
+              steps: [{run: 'echo listen'}],
+            },
+          },
+        }),
+        triggerPayload: manualTrigger(),
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('expected the run to have a listener job');
+
+      await db().update(jobs).set({listenerStatus: 'listening'}).where(eq(jobs.id, job.id));
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.preview).toMatchObject([
+        {
+          mode: 'listening',
+          listenerStatus: 'listening',
+          executionStatus: null,
+        },
+      ]);
+      expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'listening', count: 1}]);
+      expect(summary.get(run.id)?.rawStatusCounts).toEqual([{status: 'pending', count: 1}]);
+    });
+
+    test('keeps a terminal verdict ahead of a running execution', 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 the run to have a job');
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('expected the job to have an execution');
+
+      await updateJobExecutionStatus({
+        jobExecutionId: execution.id,
+        status: 'running',
+        expectedVersion: execution.version,
+      });
+      await updateJobStatus({jobId: job.id, status: 'failed', expectedVersion: job.version});
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.preview).toMatchObject([
+        {status: 'failed', executionStatus: 'running'},
+      ]);
+      expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'failed', count: 1}]);
+      expect(summary.get(run.id)?.rawStatusCounts).toEqual([{status: 'failed', count: 1}]);
+    });
+
+    test('counts a skipped zero-execution job from its terminal verdict', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {
+            listen: {
+              listening: {
+                on: [{source: 'github', event: 'push'}],
+                onResolve: 'finish',
+              },
+              steps: [{run: 'echo listen'}],
+            },
+          },
+        }),
+        triggerPayload: manualTrigger(),
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('expected the run to have a listener job');
+
+      await db()
+        .update(jobs)
+        .set({status: 'skipped', listenerStatus: 'resolved'})
+        .where(eq(jobs.id, job.id));
+
+      const summary = await listWorkflowRunJobSummaries([
+        {id: run.id, currentAttempt: run.currentAttempt},
+      ]);
+
+      expect(summary.get(run.id)?.preview).toMatchObject([
+        {status: 'skipped', executionStatus: null},
+      ]);
+      expect(summary.get(run.id)?.statusCounts).toEqual([{status: 'skipped', count: 1}]);
+      expect(summary.get(run.id)?.rawStatusCounts).toEqual([{status: 'skipped', count: 1}]);
+    });
+
     // Checks the invariant the snapshot exists to protect: for a run inside the preview
     // bound, the statuses drawn and the statuses counted describe the same jobs and must
     // agree exactly. The read races a commit to give the anomaly a chance to appear, so this
@@ -445,13 +589,36 @@ function totalOf(summary: {statusCounts: Array<{count: number}>} | undefined): n
 
 /** Statuses the preview actually drew, counted. */
 function previewCounts(
-  summary: {preview: Array<{status: string}>} | undefined,
+  summary:
+    | {
+        preview: Array<{
+          status: string;
+          mode: string;
+          listenerStatus: string;
+          executionStatus: string | null;
+        }>;
+      }
+    | undefined,
 ): Record<string, number> {
   const counts: Record<string, number> = {};
-  for (const job of summary?.preview ?? []) counts[job.status] = (counts[job.status] ?? 0) + 1;
+  for (const job of summary?.preview ?? []) {
+    const status = previewDisplayStatus(job);
+    counts[status] = (counts[status] ?? 0) + 1;
+  }
   return counts;
 }
 
+function previewDisplayStatus(job: {
+  status: string;
+  mode: string;
+  listenerStatus: string;
+  executionStatus: string | null;
+}): string {
+  if (['succeeded', 'failed', 'cancelled', 'skipped'].includes(job.status)) return job.status;
+  if (job.mode === 'listening' && job.listenerStatus === 'listening') return 'listening';
+  return job.executionStatus ?? 'pending';
+}
+
 /** The same shape read off the totals, so the two halves can be compared directly. */
 function statusCountMap(
   summary: {statusCounts: Array<{status: string; count: number}>} | undefined,

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

@@ -5,7 +5,8 @@ import {
   timestampIdCursorWhere,
 } from '@shipfox/node-drizzle';
 import {and, asc, count, desc, eq, gte, lte, type SQL, sql} from 'drizzle-orm';
-import type {JobStatus} from '#core/entities/job.js';
+import type {JobMode, JobStatus, ListenerStatus} from '#core/entities/job.js';
+import type {JobExecutionStatus} from '#core/entities/job-execution.js';
 import type {
   JobExecutionDetail,
   StepDetail,
@@ -52,6 +53,9 @@ export interface WorkflowRunJobSummary {
   key: string;
   name: string | null;
   status: JobStatus;
+  mode: JobMode;
+  listenerStatus: ListenerStatus;
+  executionStatus: JobExecutionStatus | null;
   position: number;
 }
 
@@ -212,14 +216,23 @@ export interface WorkflowRunJobSummaryTarget {
  * A page row's jobs: a bounded slice to draw, and totals describing all of them.
  *
  * 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.
+ * server-side is what lets a row report a failure that sits past the preview. Counts use the
+ * display status derived from the job verdict, listener state, and selected execution state;
+ * the row keeps the verdict and evidence separate so the client can apply the same display
+ * rule as run detail.
  */
 export interface WorkflowRunJobsSummary {
   preview: WorkflowRunJobSummary[];
   statusCounts: WorkflowRunJobStatusCount[];
+  rawStatusCounts: WorkflowRunJobRawStatusCount[];
 }
 
 export interface WorkflowRunJobStatusCount {
+  status: JobStatus | 'listening';
+  count: number;
+}
+
+export interface WorkflowRunJobRawStatusCount {
   status: JobStatus;
   count: number;
 }
@@ -262,23 +275,64 @@ export async function listWorkflowRunJobSummaries(
 
   const {previewRows, countRows} = await db().transaction(
     async (tx) => {
+      // Pick the execution the detail view would display once per job before either list
+      // statement touches it. The existing (job_id, sequence) index supports the latest
+      // execution ordering, while the status-first expression preserves the rule that an
+      // active execution wins over a newer completed retry.
+      const selectedExecution = tx.$with('selected_execution').as(
+        tx
+          .selectDistinctOn([jobExecutions.jobId], {
+            jobId: jobExecutions.jobId,
+            executionStatus: sql<JobExecutionStatus>`${jobExecutions.status}`.as(
+              'execution_status',
+            ),
+          })
+          .from(jobExecutions)
+          .innerJoin(jobs, eq(jobExecutions.jobId, jobs.id))
+          .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+          .where(attemptFilter)
+          .orderBy(
+            asc(jobExecutions.jobId),
+            sql`case when ${jobExecutions.status} = 'running' then 0 else 1 end`,
+            desc(jobExecutions.sequence),
+            desc(jobExecutions.id),
+          ),
+      );
+
       const ranked = tx
+        .with(selectedExecution)
         .select({
           workflowRunId: workflowRunAttempts.workflowRunId,
           id: jobs.id,
           key: jobs.key,
           name: jobs.name,
           status: jobs.status,
+          mode: jobs.mode,
+          listenerStatus: jobs.listenerStatus,
+          executionStatus: selectedExecution.executionStatus,
           position: jobs.position,
-          rank: sql<number>`row_number() over (partition by ${workflowRunAttempts.workflowRunId} order by ${jobs.position} asc, ${jobs.id} asc)`.as(
-            'rank',
-          ),
+          jobRank:
+            sql<number>`row_number() over (partition by ${workflowRunAttempts.workflowRunId} order by ${jobs.position} asc, ${jobs.id} asc)`.as(
+              'job_rank',
+            ),
         })
         .from(jobs)
         .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+        .leftJoin(selectedExecution, eq(selectedExecution.jobId, jobs.id))
         .where(attemptFilter)
         .as('ranked');
 
+      const executionDisplayStatus = sql<JobExecutionStatus | null>`
+        ${selectedExecution.executionStatus}
+      `;
+      const displayStatus = sql<WorkflowRunJobStatusCount['status']>`
+        case
+          when ${jobs.status} in ('succeeded', 'failed', 'cancelled', 'skipped') then ${jobs.status}::text
+          when ${jobs.mode} = 'listening' and ${jobs.listenerStatus} = 'listening' then 'listening'
+          when ${executionDisplayStatus} is not null then ${executionDisplayStatus}::text
+          else 'pending'
+        end
+      `;
       return {
         previewRows: await tx
           .select({
@@ -287,21 +341,27 @@ export async function listWorkflowRunJobSummaries(
             key: ranked.key,
             name: ranked.name,
             status: ranked.status,
+            mode: ranked.mode,
+            listenerStatus: ranked.listenerStatus,
+            executionStatus: ranked.executionStatus,
             position: ranked.position,
           })
           .from(ranked)
-          .where(lte(ranked.rank, WORKFLOW_RUN_JOB_PREVIEW_LIMIT))
+          .where(lte(ranked.jobRank, WORKFLOW_RUN_JOB_PREVIEW_LIMIT))
           .orderBy(asc(ranked.workflowRunId), asc(ranked.position), asc(ranked.id)),
         countRows: await tx
+          .with(selectedExecution)
           .select({
             workflowRunId: workflowRunAttempts.workflowRunId,
-            status: jobs.status,
+            rawStatus: jobs.status,
+            status: displayStatus,
             count: count(),
           })
           .from(jobs)
           .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+          .leftJoin(selectedExecution, eq(selectedExecution.jobId, jobs.id))
           .where(attemptFilter)
-          .groupBy(workflowRunAttempts.workflowRunId, jobs.status),
+          .groupBy(workflowRunAttempts.workflowRunId, jobs.status, displayStatus),
       };
     },
     {isolationLevel: 'repeatable read', accessMode: 'read only'},
@@ -310,8 +370,10 @@ export async function listWorkflowRunJobSummaries(
   for (const {workflowRunId, ...summary} of previewRows) {
     summaryFor(summaries, workflowRunId).preview.push(summary);
   }
-  for (const {workflowRunId, status, count: statusCount} of countRows) {
-    summaryFor(summaries, workflowRunId).statusCounts.push({status, count: statusCount});
+  for (const {workflowRunId, rawStatus, status, count: statusCount} of countRows) {
+    const summary = summaryFor(summaries, workflowRunId);
+    appendStatusCount(summary.rawStatusCounts, rawStatus, statusCount);
+    appendStatusCount(summary.statusCounts, status, statusCount);
   }
 
   return summaries;
@@ -323,11 +385,24 @@ function summaryFor(
 ): WorkflowRunJobsSummary {
   const existing = summaries.get(workflowRunId);
   if (existing) return existing;
-  const created: WorkflowRunJobsSummary = {preview: [], statusCounts: []};
+  const created: WorkflowRunJobsSummary = {preview: [], statusCounts: [], rawStatusCounts: []};
   summaries.set(workflowRunId, created);
   return created;
 }
 
+function appendStatusCount<T extends string>(
+  counts: Array<{status: T; count: number}>,
+  status: T,
+  count: number,
+): void {
+  const existing = counts.find((entry) => entry.status === status);
+  if (existing) {
+    existing.count += count;
+  } else {
+    counts.push({status, count});
+  }
+}
+
 export async function listWorkflowRunsByProject(projectId: string): Promise<WorkflowRun[]> {
   const result = await listWorkflowRuns({projectId, limit: 100});
   return result.runs;

package/src/db/workflow-runs.ts

@@ -47,6 +47,7 @@ export type {
   WorkflowRunAggregates,
   WorkflowRunCursor,
   WorkflowRunFilters,
+  WorkflowRunJobRawStatusCount,
   WorkflowRunJobStatusCount,
   WorkflowRunJobSummary,
   WorkflowRunJobSummaryTarget,

package/src/presentation/dto/job.ts

@@ -56,6 +56,7 @@ export function toJobExecutionDto(jobExecution: JobExecution): JobExecutionDto {
     name: jobExecution.name,
     status: jobExecution.status,
     status_reason: jobExecution.statusReason,
+    status_reason_message: jobExecution.statusReasonMessage,
     runner: jobExecution.runner,
     trigger_events: jobExecution.triggerEvents,
     outputs: jobExecution.outputs,

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

@@ -33,7 +33,7 @@ export function toRunDto(run: WorkflowRun, latestAttempt = run.currentAttempt):
   };
 }
 
-const EMPTY_JOBS: WorkflowRunJobsSummary = {preview: [], statusCounts: []};
+const EMPTY_JOBS: WorkflowRunJobsSummary = {preview: [], statusCounts: [], rawStatusCounts: []};
 
 export function toRunListItemDto(
   run: WorkflowRun,
@@ -46,9 +46,13 @@ export function toRunListItemDto(
       key: job.key,
       name: job.name,
       status: job.status,
+      mode: job.mode,
+      listener_status: job.listenerStatus,
+      execution_status: job.executionStatus,
       position: job.position,
     })),
-    job_status_counts: jobs.statusCounts.map(({status, count}) => ({status, count})),
+    job_status_counts: jobs.rawStatusCounts.map(({status, count}) => ({status, count})),
+    job_display_status_counts: jobs.statusCounts.map(({status, count}) => ({status, count})),
   };
 }
 

package/src/presentation/subscribers/on-failure-annotations.test.ts

@@ -230,7 +230,12 @@ describe('failure annotations', () => {
   });
 
   it('projects a job failure from the current execution origin', async () => {
-    const payload = jobTerminatedPayload({status: 'failed'});
+    const payload = jobTerminatedPayload({
+      status: 'failed',
+      statusReason: 'output_too_large',
+      statusReasonMessage:
+        'Job output "payload" exceeds the per-value size limit of 16384 bytes (measured 16385 bytes; overshoot 1 bytes).',
+    });
     dbMocks.getJobScope.mockResolvedValue({
       workspaceId: '44444444-4444-4444-8444-444444444444',
       projectId: '55555555-5555-4555-8555-555555555555',
@@ -264,6 +269,47 @@ describe('failure annotations', () => {
         }),
       }),
     );
+    expect(replaceOrRemoveAnnotation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        annotation: expect.objectContaining({
+          body: expect.stringContaining('measured 16385 bytes; overshoot 1 bytes'),
+        }),
+      }),
+    );
+  });
+
+  it('projects an output-invalid job failure with its status message', async () => {
+    const payload = jobTerminatedPayload({
+      statusReason: 'output_invalid',
+      statusReasonMessage: 'Job output "payload" cannot be persisted as JSON: undefined.',
+    });
+    dbMocks.getJobScope.mockResolvedValue({
+      workspaceId: '44444444-4444-4444-8444-444444444444',
+      projectId: '55555555-5555-4555-8555-555555555555',
+      triggerReference: null,
+    });
+    dbMocks.getWorkflowRunAttemptById.mockResolvedValue({attempt: 3});
+    dbMocks.getJobExecutionFailureOrigin.mockResolvedValue({
+      jobExecutionId: payload.jobExecutionId,
+      stepId: '77777777-7777-4777-8777-777777777777',
+      stepName: 'Run tests',
+      stepStatus: 'succeeded',
+      stepAttempt: 1,
+      stepError: null,
+      attemptStatus: 'succeeded',
+      attemptError: null,
+      attemptExitCode: 0,
+    });
+
+    await onJobTerminatedFailureAnnotation(annotations)(payload);
+
+    expect(replaceOrRemoveAnnotation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        annotation: expect.objectContaining({
+          body: expect.stringContaining('Job output "payload" cannot be persisted as JSON'),
+        }),
+      }),
+    );
   });
 
   it('projects a condition evaluation error from a skipped job', async () => {

package/src/presentation/subscribers/on-failure-annotations.ts

@@ -16,7 +16,13 @@ import {
 } from '#db/index.js';
 import {recordWorkflowFailureAnnotationFailed} from '#metrics/instance.js';
 
-const JOB_FAILURE_ANNOTATION_REASONS = new Set(['timed_out', 'runner_lost', 'condition_errored']);
+const JOB_FAILURE_ANNOTATION_REASONS = new Set([
+  'timed_out',
+  'runner_lost',
+  'condition_errored',
+  'output_too_large',
+  'output_invalid',
+]);
 
 export function onStepAttemptTerminatedFailureAnnotation(
   annotations: AnnotationsInterModuleClient,
@@ -123,7 +129,7 @@ export function onJobTerminatedFailureAnnotation(annotations: AnnotationsInterMo
         },
         context: failureContext('job', payload.jobId),
         failed: true,
-        body: jobFailureBody(payload.statusReason, origin),
+        body: jobFailureBody(payload.statusReason, payload.statusReasonMessage, origin),
       });
     } catch (error) {
       recordFailureAnnotationFailure(error, 'lookup', {jobId: payload.jobId});
@@ -200,6 +206,7 @@ function stepFailureBody(
 
 function jobFailureBody(
   reason: string | null,
+  statusReasonMessage: string | null | undefined,
   origin: {
     stepName: string;
     attemptStatus: string | null;
@@ -220,6 +227,7 @@ function jobFailureBody(
     '',
     progress,
     `Reason: \`${reason ?? 'unknown'}\``,
+    statusReasonMessage ? `Failure: ${statusReasonMessage}` : null,
     message ? `Failure: ${message}` : null,
     exitCode,
   ]

package/test/helpers/workflow-runs.ts

@@ -132,6 +132,7 @@ export async function jobTerminatedEvents(jobId: string) {
         workflowRunId: string;
         status: string;
         statusReason: string | null;
+        statusReasonMessage?: string | null;
       },
   );
 }