@shipfox/api-workflows 13.0.0 → 14.0.0

package/src/presentation/routes/checkout-token.test.ts

@@ -179,6 +179,35 @@ describe('POST /runs/jobs/current/steps/:stepId/checkout-token', () => {
     });
   });
 
+  test('defaults a dev run checkout to its pinned source commit', async () => {
+    const devCommit = 'b'.repeat(40);
+    const {project, job, step} = await createRunningCheckoutStep({devCommit});
+    getProjectById.mockResolvedValue({project});
+    resolveCheckoutTarget.mockResolvedValue({
+      projectId: project.id,
+      connectionId: project.sourceConnectionId,
+      externalRepositoryId: project.sourceExternalRepositoryId,
+    });
+    createCheckoutSpec.mockResolvedValue({...githubSpec('ghs-dev-token'), ref: devCommit});
+    const token = await mintActiveLeaseToken({jobId: job.id});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: checkoutUrl(step.id, step.currentAttempt),
+      headers: {authorization: `Bearer ${token}`},
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toMatchObject({ref: devCommit});
+    expect(createCheckoutSpec).toHaveBeenCalledWith({
+      workspaceId: project.workspaceId,
+      connectionId: project.sourceConnectionId,
+      externalRepositoryId: project.sourceExternalRepositoryId,
+      ref: devCommit,
+      permissions: {contents: 'read'},
+    });
+  });
+
   test('returns checkout-unavailable when the run project no longer resolves', async () => {
     const {job, step} = await createRunningCheckoutStep({kind: 'checkout'});
     getProjectById.mockResolvedValue({project: null});
@@ -521,6 +550,7 @@ async function createRunningCheckoutStep(
   options: {
     kind?: 'setup' | 'checkout' | 'run';
     checkout?: CheckoutConfig;
+    devCommit?: string;
     status?: StepStatus;
   } = {},
 ) {
@@ -546,6 +576,21 @@ async function createRunningCheckoutStep(
       userId: crypto.randomUUID(),
     },
   });
+  if (options.devCommit) {
+    await db()
+      .update(workflowRuns)
+      .set({
+        origin: 'dev',
+        devSource: {
+          ref: 'feature/checkout',
+          commit: options.devCommit,
+          config_path: '.shipfox/workflows/checkout.yml',
+          initiated_by_user_id: crypto.randomUUID(),
+          replay_of_event_id: null,
+        },
+      })
+      .where(eq(workflowRuns.id, run.id));
+  }
   const [job] = await getJobsByWorkflowRunId(run.id);
   if (!job) throw new Error('Expected workflow job');
   await db().update(jobsTable).set({status: 'running'}).where(eq(jobsTable.id, job.id));

package/src/presentation/routes/checkout-token.ts

@@ -122,7 +122,7 @@ export function createCheckoutTokenRoute(clients: {
     handler: async (request, reply) => {
       const {stepId} = request.params;
       const {attempt} = request.query;
-      const {step, workspaceId, projectId, triggerReference} = await loadRunningLeasedStep({
+      const {step, workspaceId, projectId, triggerReference, run} = await loadRunningLeasedStep({
         runners: clients.runners,
         request,
         stepId,
@@ -138,6 +138,7 @@ export function createCheckoutTokenRoute(clients: {
         workspaceId,
         projectId,
         triggerReference,
+        run,
         integrations: clients.integrations,
         projects: clients.projects,
       });

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

@@ -1,8 +1,11 @@
 import {buildUserContext, setUserContext} from '@shipfox/api-auth-context';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
+import {eq} from 'drizzle-orm';
 import type {FastifyInstance} from 'fastify';
 import Fastify from 'fastify';
 import {serializerCompiler, validatorCompiler} from 'fastify-type-provider-zod';
+import {db} from '#db/db.js';
+import {workflowRuns} from '#db/schema/workflow-runs.js';
 import {createWorkflowRun, updateWorkflowRunStatus} from '#db/workflow-runs.js';
 import {workflowModel} from '#test/index.js';
 import {getRunAggregatesRoute} from './get-run-aggregates.js';
@@ -117,4 +120,57 @@ describe('GET /api/workflows/runs/aggregates', () => {
     expect(body.trigger_source).toEqual([{value: 'manual', count: 1}]);
     expect(body.workflow).toEqual([{value: deployDefinitionId, count: 1}]);
   });
+
+  test('filters faceted counts by origin so the Runs tab facet follows', async () => {
+    await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Synced',
+      model: workflowModel({name: 'Synced'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    const devRun = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Dev',
+      model: workflowModel({name: 'Dev'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    await db()
+      .update(workflowRuns)
+      .set({
+        origin: 'dev',
+        devSource: {
+          ref: 'fix-triage-prompt',
+          commit: 'abc123',
+          config_path: '.shipfox/workflows/triage-sentry.yml',
+          initiated_by_user_id: crypto.randomUUID(),
+          replay_of_event_id: null,
+        },
+      })
+      .where(eq(workflowRuns.id, devRun.id));
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs/aggregates?project_id=${projectId}&origin=dev`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    expect(body.status).toEqual([{value: 'pending', count: 1}]);
+    expect(body.trigger_source).toEqual([{value: 'manual', count: 1}]);
+    expect(body.workflow).toEqual([{value: devRun.definitionId, count: 1}]);
+  });
 });

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

@@ -26,6 +26,7 @@ export function getRunAggregatesRoute(projects: ProjectsModuleClient) {
         status,
         definition_id: definitionId,
         trigger_source: triggerSource,
+        origin,
         created_from: createdFrom,
         created_to: createdTo,
       } = request.query;
@@ -35,6 +36,7 @@ export function getRunAggregatesRoute(projects: ProjectsModuleClient) {
         status,
         definitionId,
         triggerSource,
+        origin,
         createdFrom: createdFrom ? new Date(createdFrom) : undefined,
         createdTo: createdTo ? new Date(createdTo) : undefined,
       };

package/src/presentation/routes/get-step-secrets.test.ts

@@ -210,6 +210,7 @@ describe('GET /runs/jobs/current/steps/:stepId/secrets', () => {
       workspaceId: run.workspaceId,
       projectId: run.projectId,
       triggerReference: null,
+      run: {origin: 'synced', devSource: null},
     });
   });
 });

package/src/presentation/routes/leased-step.ts

@@ -2,7 +2,10 @@ import {type LeasedJobContext, requireLeasedJobContext} from '@shipfox/api-auth-
 import type {RunnersInterModuleClient} from '@shipfox/api-runners-dto/inter-module';
 import {ClientError} from '@shipfox/node-fastify';
 import type {Step} from '#core/entities/step.js';
-import type {WorkflowRunTriggerReference} from '#core/entities/workflow-run.js';
+import type {
+  WorkflowRunOriginState,
+  WorkflowRunTriggerReference,
+} from '#core/entities/workflow-run.js';
 import {getJobScope, getStepByIdForJobExecution} from '#db/index.js';
 
 export interface LoadedRunningLeasedStep {
@@ -11,6 +14,8 @@ export interface LoadedRunningLeasedStep {
   workspaceId: string;
   projectId: string;
   triggerReference: WorkflowRunTriggerReference | null;
+  /** The run's origin state, forwarded for checkout fallbacks. */
+  run: WorkflowRunOriginState;
 }
 
 export async function loadRunningLeasedStep(params: {
@@ -59,5 +64,6 @@ export async function loadRunningLeasedStep(params: {
     workspaceId: scope.workspaceId,
     projectId: scope.projectId,
     triggerReference: scope.triggerReference,
+    run: scope.run,
   };
 }

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

@@ -164,6 +164,81 @@ describe('GET /api/workflows/runs', () => {
     expect(res.json().runs[0].trigger_reference).toBeNull();
   });
 
+  test('labels runs with the synced origin and no dev source by default', async () => {
+    await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Manual',
+      model: workflowModel({name: 'Manual'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs?project_id=${projectId}`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json().runs[0]).toMatchObject({origin: 'synced', dev_source: null});
+  });
+
+  test('filters runs by origin', async () => {
+    await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Synced',
+      model: workflowModel({name: 'Synced'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    const devRun = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId: crypto.randomUUID(),
+      name: 'Dev',
+      model: workflowModel({name: 'Dev'}),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    const initiatedByUserId = crypto.randomUUID();
+    await markDevRun(devRun.id, initiatedByUserId);
+
+    const res = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs?project_id=${projectId}&origin=dev`,
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json();
+    expect(body.runs.map((run: {id: string}) => run.id)).toEqual([devRun.id]);
+    expect(body.filtered_total_count).toBe(1);
+    expect(body.runs[0]).toMatchObject({
+      origin: 'dev',
+      dev_source: {
+        ref: 'fix-triage-prompt',
+        commit: 'abc123',
+        config_path: '.shipfox/workflows/triage-sentry.yml',
+        initiated_by_user_id: initiatedByUserId,
+        replay_of_event_id: null,
+      },
+    });
+  });
+
   test('returns empty array for project with no runs', async () => {
     const res = await app.inject({
       method: 'GET',
@@ -257,6 +332,67 @@ describe('GET /api/workflows/runs', () => {
     expect(next.json().runs.map((run: {id: string}) => run.id)).toEqual([first.id]);
   });
 
+  test('keeps the origin filter across cursor pages', async () => {
+    const devFirst = await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Dev first',
+      createdAt: new Date('2026-05-07T00:00:00.000Z'),
+    });
+    await markDevRun(devFirst.id);
+    await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Synced middle one',
+      createdAt: new Date('2026-05-07T01:00:00.000Z'),
+    });
+    const devSecond = await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Dev second',
+      createdAt: new Date('2026-05-07T02:00:00.000Z'),
+    });
+    await markDevRun(devSecond.id);
+    await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Synced middle two',
+      createdAt: new Date('2026-05-07T03:00:00.000Z'),
+    });
+    const devThird = await createRunAt({
+      workspaceId,
+      projectId,
+      name: 'Dev third',
+      createdAt: new Date('2026-05-07T04:00:00.000Z'),
+    });
+    await markDevRun(devThird.id);
+
+    const firstPage = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs?project_id=${projectId}&origin=dev&limit=2`,
+    });
+
+    expect(firstPage.statusCode).toBe(200);
+    const firstBody = firstPage.json();
+    expect(firstBody.runs.map((run: {name: string}) => run.name)).toEqual([
+      'Dev third',
+      'Dev second',
+    ]);
+    expect(firstBody.runs.every((run: {origin: string}) => run.origin === 'dev')).toBe(true);
+    expect(firstBody.filtered_total_count).toBe(3);
+
+    const secondPage = await app.inject({
+      method: 'GET',
+      url: `/api/workflows/runs?project_id=${projectId}&origin=dev&limit=2&cursor=${firstBody.next_cursor}`,
+    });
+
+    expect(secondPage.statusCode).toBe(200);
+    const secondBody = secondPage.json();
+    expect(secondBody.runs.map((run: {name: string}) => run.name)).toEqual(['Dev first']);
+    expect(secondBody.runs.every((run: {origin: string}) => run.origin === 'dev')).toBe(true);
+    expect(secondBody.next_cursor).toBeNull();
+  });
+
   test('invalid cursor returns stable client error', async () => {
     const res = await app.inject({
       method: 'GET',
@@ -309,3 +445,19 @@ async function createRunAt({
 
   return {...run, createdAt, updatedAt: createdAt};
 }
+
+async function markDevRun(runId: string, initiatedByUserId = crypto.randomUUID()) {
+  await db()
+    .update(workflowRuns)
+    .set({
+      origin: 'dev',
+      devSource: {
+        ref: 'fix-triage-prompt',
+        commit: 'abc123',
+        config_path: '.shipfox/workflows/triage-sentry.yml',
+        initiated_by_user_id: initiatedByUserId,
+        replay_of_event_id: null,
+      },
+    })
+    .where(eq(workflowRuns.id, runId));
+}

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

@@ -30,6 +30,7 @@ export function listRunsRoute(projects: ProjectsModuleClient) {
         status,
         definition_id: definitionId,
         trigger_source: triggerSource,
+        origin,
         created_from: createdFrom,
         created_to: createdTo,
       } = request.query;
@@ -44,6 +45,7 @@ export function listRunsRoute(projects: ProjectsModuleClient) {
         status,
         definitionId,
         triggerSource,
+        origin,
         createdFrom: createdFrom ? new Date(createdFrom) : undefined,
         createdTo: createdTo ? new Date(createdTo) : undefined,
       };

package/test/factories/workflow-run.ts

@@ -37,6 +37,8 @@ export const workflowRunFactory = Factory.define<WorkflowRun, WorkflowRunTransie
       workflowName: 'Test Workflow',
       nameOverride: null,
       status: 'pending',
+      origin: 'synced',
+      devSource: null,
       currentAttempt: 1,
       triggerProvider: null,
       triggerSource: 'manual',