@shipfox/api-workflows 12.5.0 → 12.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-workflows",
   "license": "MIT",
-  "version": "12.5.0",
+  "version": "12.6.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.5.0",
+    "@shipfox/api-workflows-dto": "12.6.0",
     "@shipfox/api-workspaces-dto": "12.0.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/inter-module": "0.2.3",

package/src/db/index.ts

@@ -42,6 +42,7 @@ export type {
   WorkflowJobExecutionDepthParams,
   WorkflowRunAggregates,
   WorkflowRunFilters,
+  WorkflowRunJobRawStatusCount,
   WorkflowRunJobStatusCount,
   WorkflowRunJobSummary,
   WorkflowRunJobSummaryTarget,

package/src/db/schema/jobs.ts

@@ -61,6 +61,9 @@ export const jobs = pgTable(
     key: text('key').notNull(),
     mode: jobModeEnum('mode').notNull().default('one_shot'),
     name: text('name'),
+    // This is the job's execution verdict, not its runtime lifecycle. Active execution state
+    // lives on job_executions and must be read there when a surface needs to distinguish
+    // waiting from executing.
     status: jobStatusEnum('status').notNull().default('pending'),
     statusReason: jobStatusReasonEnum('status_reason'),
     carriedOver: boolean('carried_over').notNull().default(false),

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/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})),
   };
 }