@shipfox/api-workflows 12.1.0 → 12.3.0

package/src/db/workflow-runs/job-executions.test.ts

@@ -1,14 +1,21 @@
 import {WORKFLOWS_JOB_EXECUTION_TIMED_OUT} from '@shipfox/api-workflows-dto';
 import {and, eq, sql} from 'drizzle-orm';
-import {buildModel, workflowRunAttemptId} from '#test/helpers/workflow-runs.js';
+import {
+  MAX_JOB_OUTPUT_ENTRIES,
+  MAX_JOB_OUTPUT_VALUE_BYTES,
+} from '#core/step-config/job-output-limits.js';
+import {buildModel, template, workflowRunAttemptId} from '#test/helpers/workflow-runs.js';
 import {db} from '../db.js';
 import {workflowsOutbox} from '../schema/outbox.js';
 import {
+  applyStepResult,
   createWorkflowRun,
   failJobExecutionAsTimedOut,
+  finishStepAttempt,
   getFirstJobExecutionByJobId,
   getJobsByWorkflowRunId,
   getStepsByJobId,
+  markStepRunning,
   resolveJobExecutionAfterLeaseExpiry,
   updateJobExecutionStatus,
 } from '../workflow-runs.js';
@@ -96,4 +103,203 @@ describe('workflow run job executions', () => {
     const jobSteps = await getStepsByJobId(job.id);
     expect(jobSteps.every((step) => step.status === 'pending')).toBe(true);
   });
+
+  test('persists a structured job output when execution succeeds', async () => {
+    const run = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId,
+      model: buildModel({
+        jobs: {
+          build: {
+            steps: [{key: 'collect', run: 'echo build'}],
+            outputs: {findings: template('steps.collect.outputs.findings')},
+            outputTypes: {
+              findings: {
+                kind: 'list',
+                element: {kind: 'object', fields: {severity: 'string'}},
+              },
+            },
+          },
+        },
+      }),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    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 job execution');
+    await finishCollectedStep(job.id, {findings: [{severity: 'high'}]});
+
+    const resolved = await updateJobExecutionStatus({
+      jobExecutionId: execution.id,
+      status: 'succeeded',
+      expectedVersion: execution.version,
+    });
+
+    expect(resolved.outputs).toEqual({findings: [{severity: 'high'}]});
+    expect(Array.isArray(resolved.outputs?.findings)).toBe(true);
+    const persisted = await getFirstJobExecutionByJobId(job.id);
+    expect(persisted?.outputs).toEqual({findings: [{severity: 'high'}]});
+  });
+
+  test('persists JSON-safe typed integer and timestamp outputs when execution succeeds', async () => {
+    const run = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId,
+      model: buildModel({
+        jobs: {
+          build: {
+            steps: [{key: 'collect', run: 'echo build'}],
+            outputs: {
+              count: template('steps.collect.outputs.count'),
+              createdAt: template('run.created_at'),
+            },
+            outputTypes: {count: 'int', createdAt: 'timestamp'},
+          },
+        },
+      }),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    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 job execution');
+    await finishCollectedStep(job.id, {count: 42});
+
+    const resolved = await updateJobExecutionStatus({
+      jobExecutionId: execution.id,
+      status: 'succeeded',
+      expectedVersion: execution.version,
+    });
+
+    expect(resolved.outputs).toEqual({count: 42, createdAt: run.createdAt.toISOString()});
+    const persisted = await getFirstJobExecutionByJobId(job.id);
+    expect(persisted?.outputs).toEqual({count: 42, createdAt: run.createdAt.toISOString()});
+  });
+
+  test('fails a successful execution when a materialized job output is too large', async () => {
+    const run = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId,
+      model: buildModel({
+        jobs: {
+          build: {
+            steps: [{key: 'collect', run: 'echo build'}],
+            outputs: {payload: template('steps.collect.outputs.payload')},
+            outputTypes: {payload: {kind: 'list', element: 'string'}},
+          },
+        },
+      }),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    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 job execution');
+    await finishCollectedStep(job.id, {
+      payload: ['x'.repeat(MAX_JOB_OUTPUT_VALUE_BYTES - 1)],
+    });
+
+    const resolved = await updateJobExecutionStatus({
+      jobExecutionId: execution.id,
+      status: 'succeeded',
+      expectedVersion: execution.version,
+    });
+
+    expect(resolved).toMatchObject({status: 'failed', statusReason: 'unknown', outputs: null});
+  });
+
+  test('fails a successful execution when the persisted model has too many job outputs', async () => {
+    const outputs = Object.fromEntries(
+      Array.from({length: MAX_JOB_OUTPUT_ENTRIES + 1}, (_, index) => {
+        const key = `output${index}`;
+        return [key, template(`steps.collect.outputs.${key}`)];
+      }),
+    );
+    const run = await createWorkflowRun({
+      workspaceId,
+      projectId,
+      definitionId,
+      model: buildModel({
+        jobs: {
+          build: {
+            steps: [{key: 'collect', run: 'echo build'}],
+            outputs,
+          },
+        },
+      }),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    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 job execution');
+    await finishCollectedStep(job.id, {});
+
+    const resolved = await updateJobExecutionStatus({
+      jobExecutionId: execution.id,
+      status: 'succeeded',
+      expectedVersion: execution.version,
+    });
+
+    expect(resolved).toMatchObject({status: 'failed', statusReason: 'unknown', outputs: null});
+  });
 });
+
+async function finishCollectedStep(jobId: string, output: Record<string, unknown>): Promise<void> {
+  const steps = await getStepsByJobId(jobId);
+  const step = steps.find((candidate) => candidate.key === 'collect');
+  if (!step) throw new Error('Expected collect step');
+
+  await db().transaction(async (tx) => {
+    const running = await markStepRunning(
+      {jobExecutionId: step.jobExecutionId, stepId: step.id},
+      tx,
+    );
+    if (!running) throw new Error('Expected pending collect step');
+    await finishStepAttempt(
+      {
+        stepId: step.id,
+        attempt: running.currentAttempt,
+        status: 'succeeded',
+        output,
+        response: null,
+        exitCode: 0,
+        logOutcome: 'drained',
+      },
+      tx,
+    );
+    await applyStepResult(
+      {
+        jobExecutionId: step.jobExecutionId,
+        stepId: step.id,
+        status: 'succeeded',
+        error: null,
+      },
+      tx,
+    );
+  });
+}

package/src/db/workflow-runs/job-executions.ts

@@ -4,7 +4,13 @@ import {WORKFLOWS_JOB_EXECUTION_TIMED_OUT} from '@shipfox/api-workflows-dto';
 import {and, asc, desc, eq, isNull, notInArray, sql} from 'drizzle-orm';
 import type {JobStatusReason} from '#core/entities/job.js';
 import type {JobExecution, JobExecutionStatus} from '#core/entities/job-execution.js';
-import {InterpolationUnresolvableError, JobNotFoundError} from '#core/errors.js';
+import {
+  InterpolationUnresolvableError,
+  JobNotFoundError,
+  JobOutputNotJsonSafeError,
+  JobOutputTooLargeError,
+  JobOutputTooManyEntriesError,
+} from '#core/errors.js';
 import {deriveJobExecutionOutputs} from '#core/job-transition/index.js';
 import {deriveCompletion, isTerminal} from '#core/step-transition/decide-step-transition.js';
 import type {RuntimeCompletionStatus} from '#core/workflow-scheduling/runtime-dag.js';
@@ -207,7 +213,14 @@ async function updateJobExecutionStatusAtVersion(
         secrets: params.secrets,
       });
     } catch (error) {
-      if (!(error instanceof InterpolationUnresolvableError)) throw error;
+      if (
+        !(error instanceof InterpolationUnresolvableError) &&
+        !(error instanceof JobOutputNotJsonSafeError) &&
+        !(error instanceof JobOutputTooLargeError) &&
+        !(error instanceof JobOutputTooManyEntriesError)
+      ) {
+        throw error;
+      }
       status = 'failed';
       statusReason = 'unknown';
       outputs = null;

package/src/db/workflow-runs/job-status.test.ts

@@ -473,7 +473,8 @@ describe('workflow run queries', () => {
     async function seedPendingJob() {
       const run = await createTestRun({workspaceId, projectId, definitionId});
       const jobId = (await getJobsByWorkflowRunId(run.id))[0]?.id as string;
-      return {run, jobId};
+      const execution = await getFirstJobExecutionByJobId(jobId);
+      return {run, jobId, jobExecutionId: execution?.id};
     }
 
     test.each([
@@ -482,13 +483,19 @@ describe('workflow run queries', () => {
       'cancelled',
       'skipped',
     ] as const)('writes one terminated event when a job becomes %s', async (status) => {
-      const {run, jobId} = await seedPendingJob();
+      const {run, jobId, jobExecutionId} = await seedPendingJob();
 
       await updateJobStatus({jobId, status, expectedVersion: 1});
 
       const events = await jobTerminatedEvents(jobId);
       expect(events).toHaveLength(1);
-      expect(events[0]).toMatchObject({jobId, workflowRunId: run.id, status, statusReason: null});
+      expect(events[0]).toMatchObject({
+        jobId,
+        jobExecutionId,
+        workflowRunId: run.id,
+        status,
+        statusReason: null,
+      });
     });
 
     test('writes status reason on the terminated event', async () => {

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

@@ -3,6 +3,7 @@ import {
   buildModel,
   conditionTrace,
   jobByKey,
+  template,
   workflowRunAttemptId,
 } from '#test/helpers/workflow-runs.js';
 import {db} from '../db.js';
@@ -148,6 +149,54 @@ describe('evaluateJobActivations', () => {
     expect(result).toEqual([{kind: 'start-job', jobId: notify.id}]);
   });
 
+  it('rehydrates typed dependency outputs before activation evaluation', async () => {
+    const run = await createWorkflowRun({
+      ...scope,
+      name: 'typed dependency outputs',
+      model: buildModel({
+        jobs: {
+          build: {
+            steps: [{key: 'collect', run: 'npm run build'}],
+            outputs: {
+              count: template('steps.collect.outputs.count'),
+              createdAt: template('run.created_at'),
+            },
+            outputTypes: {count: 'int', createdAt: 'timestamp'},
+          },
+          notify: {
+            needs: 'build',
+            if: 'jobs.build.outputs.count + 1 == 43 && jobs.build.outputs.createdAt < timestamp("2026-07-01T00:00:00Z")',
+            steps: [{run: './notify.sh'}],
+          },
+        },
+      }),
+      triggerPayload: {
+        source: 'manual',
+        event: 'fire',
+        subscriptionId: crypto.randomUUID(),
+        userId: crypto.randomUUID(),
+      },
+    });
+    const build = await jobByKey(run.id, 'build');
+    const notify = await jobByKey(run.id, 'notify');
+    await updateJobStatus({
+      jobId: build.id,
+      status: 'succeeded',
+      expectedVersion: build.version,
+    });
+    await db()
+      .update(jobs)
+      .set({outputs: {count: '42', createdAt: '2026-06-30T12:00:00.000Z'}})
+      .where(eq(jobs.id, build.id));
+
+    const result = await evaluateJobActivations({
+      runAttemptId: await workflowRunAttemptId(run.id),
+      jobs: [{jobId: notify.id, expectedVersion: notify.version}],
+    });
+
+    expect(result).toEqual([{kind: 'start-job', jobId: notify.id}]);
+  });
+
   it('records condition_errored when predicate evaluation fails closed', async () => {
     const run = await createWorkflowRun({
       ...scope,

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

@@ -1,5 +1,6 @@
 import {readPersistedWorkflowModel} from '@shipfox/api-definitions-dto';
 import {WORKFLOWS_JOB_TERMINATED} from '@shipfox/api-workflows-dto';
+import type {ExpressionType} from '@shipfox/expression';
 import {and, asc, desc, eq, inArray, notInArray, sql} from 'drizzle-orm';
 import {isJobTerminal, type Job, type JobStatus, type JobStatusReason} from '#core/entities/job.js';
 import type {JobExecution} from '#core/entities/job-execution.js';
@@ -24,6 +25,16 @@ import {toWorkflowRun, workflowRuns} from '../schema/workflow-runs.js';
 import {getWorkflowRunById} from './queries.js';
 import {getWorkflowContextForJob, optimisticLockRetry, TERMINAL_JOB_STATUSES} from './shared.js';
 
+function outputTypesByJobKey(
+  model: ReturnType<typeof readPersistedWorkflowModel> | null,
+): ReadonlyMap<string, Readonly<Record<string, ExpressionType>>> {
+  return new Map(
+    (model?.jobs ?? []).flatMap((job) =>
+      job.outputTypes === undefined ? [] : [[job.key, job.outputTypes] as const],
+    ),
+  );
+}
+
 export async function getJobsByWorkflowRunAttemptId(workflowRunAttemptId: string): Promise<Job[]> {
   const rows = await db()
     .select()
@@ -81,9 +92,17 @@ export async function getDirectDependencyJobContexts(
   jobId: string,
   tx?: Tx,
 ): Promise<JobContextInput[]> {
-  const targetRows = await (tx ?? db()).select().from(jobs).where(eq(jobs.id, jobId)).limit(1);
+  const targetRows = await (tx ?? db())
+    .select({job: jobs, attempt: workflowRunAttempts})
+    .from(jobs)
+    .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+    .where(eq(jobs.id, jobId))
+    .limit(1);
   const target = targetRows[0];
-  if (!target || target.dependencies.length === 0) return [];
+  if (!target || target.job.dependencies.length === 0) return [];
+  const model =
+    target.attempt.model === null ? null : readPersistedWorkflowModel(target.attempt.model);
+  const outputTypes = outputTypesByJobKey(model);
 
   const rows = await (tx ?? db())
     .select({job: jobs, execution: jobExecutions})
@@ -91,8 +110,8 @@ export async function getDirectDependencyJobContexts(
     .leftJoin(jobExecutions, eq(jobExecutions.jobId, jobs.id))
     .where(
       and(
-        eq(jobs.workflowRunAttemptId, target.workflowRunAttemptId),
-        inArray(jobs.key, target.dependencies),
+        eq(jobs.workflowRunAttemptId, target.job.workflowRunAttemptId),
+        inArray(jobs.key, target.job.dependencies),
       ),
     )
     .orderBy(asc(jobs.position), asc(jobs.id), asc(jobExecutions.sequence), asc(jobExecutions.id));
@@ -101,7 +120,12 @@ export async function getDirectDependencyJobContexts(
   for (const row of rows) {
     let context = contextsByJobId.get(row.job.id);
     if (!context) {
-      context = {job: toJob(row.job), executions: []};
+      const jobOutputTypes = outputTypes.get(row.job.key);
+      context = {
+        job: toJob(row.job),
+        ...(jobOutputTypes === undefined ? {} : {outputTypes: jobOutputTypes}),
+        executions: [],
+      };
       contextsByJobId.set(row.job.id, context);
     }
     if (row.execution)
@@ -243,6 +267,17 @@ async function directDependencyContextsByJobKey(
   const dependencyKeys = new Set(targetJobs.flatMap((job) => job.dependencies));
   if (dependencyKeys.size === 0) return new Map();
 
+  const [attempt] = await tx
+    .select({model: workflowRunAttempts.model})
+    .from(workflowRunAttempts)
+    .where(eq(workflowRunAttempts.id, runAttemptId))
+    .limit(1);
+  const model =
+    attempt === undefined || attempt.model === null
+      ? null
+      : readPersistedWorkflowModel(attempt.model);
+  const outputTypes = outputTypesByJobKey(model);
+
   const rows = await tx
     .select({job: jobs, execution: jobExecutions})
     .from(jobs)
@@ -254,7 +289,12 @@ async function directDependencyContextsByJobKey(
   for (const row of rows) {
     let context = contextsByJobKey.get(row.job.key);
     if (!context) {
-      context = {job: toJob(row.job), executions: []};
+      const jobOutputTypes = outputTypes.get(row.job.key);
+      context = {
+        job: toJob(row.job),
+        ...(jobOutputTypes === undefined ? {} : {outputTypes: jobOutputTypes}),
+        executions: [],
+      };
       contextsByJobKey.set(row.job.key, context);
     }
     if (row.execution)
@@ -307,11 +347,18 @@ export async function updateJobStatusAtVersion(
   // version match lets a single caller win. Emitting here, in the same transaction,
   // makes the terminal fact fire exactly once across all paths.
   if (isJobTerminal(job.status)) {
+    const [currentExecution] = await tx
+      .select({id: jobExecutions.id})
+      .from(jobExecutions)
+      .where(eq(jobExecutions.jobId, job.id))
+      .orderBy(desc(jobExecutions.sequence), desc(jobExecutions.id))
+      .limit(1);
     const identity = await getWorkflowContextForJob(job.id, tx);
     await writeWorkflowsOutboxEvent(tx, {
       type: WORKFLOWS_JOB_TERMINATED,
       payload: {
         jobId: job.id,
+        jobExecutionId: currentExecution?.id ?? null,
         workflowRunId: identity.workflowRunId,
         workflowRunAttemptId: identity.workflowRunAttemptId,
         status: job.status,

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

@@ -35,7 +35,12 @@ export async function writeJobStepsSettledOutbox(
 
 export async function writeStepAttemptTerminatedOutbox(
   tx: Tx,
-  params: {stepId: string; attempt: number; logOutcome: LogOutcomeDto},
+  params: {
+    stepId: string;
+    attempt: number;
+    status: 'succeeded' | 'failed' | 'cancelled';
+    logOutcome: LogOutcomeDto;
+  },
 ): Promise<void> {
   const identity = await getStepAttemptTerminatedOutboxIdentity(tx, params.stepId);
 
@@ -49,6 +54,7 @@ export async function writeStepAttemptTerminatedOutbox(
       projectId: identity.projectId,
       stepId: params.stepId,
       attempt: params.attempt,
+      status: params.status,
       logOutcome: params.logOutcome,
     },
   });

package/src/db/workflow-runs/run-create.test.ts

@@ -578,6 +578,62 @@ describe('workflow run queries', () => {
       });
     });
 
+    test('creates a run with indexed structured dependency output config', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {
+            review: {
+              steps: [{key: 'inspect', run: 'echo inspect'}],
+              outputs: {findings: template('steps.inspect.outputs.findings')},
+              outputTypes: {
+                findings: {
+                  kind: 'list',
+                  element: {kind: 'object', fields: {severity: 'string'}},
+                },
+              },
+            },
+            summarize: {
+              needs: 'review',
+              steps: [
+                {
+                  key: 'consume',
+                  run: `test "${template('jobs.review.outputs.findings[0].severity')}" = high\necho "structured severity=${template('jobs.review.outputs.findings[0].severity')}"`,
+                },
+              ],
+            },
+          },
+        }),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+        resolveAgentDefaults: resolveTestAgentDefaults,
+      });
+
+      const summarize = (await getJobsByWorkflowRunId(run.id)).find(
+        (job) => job.key === 'summarize',
+      );
+      if (!summarize) throw new Error('Expected summarize job');
+      const [, consume] = await getStepsByJobId(summarize.id);
+      expect(consume?.configPlan).toMatchObject({
+        env: {
+          __sf_0: {
+            segments: [
+              {
+                kind: 'deferred',
+                expression: {source: 'jobs.review.outputs.findings[0].severity'},
+              },
+            ],
+          },
+        },
+      });
+    });
+
     test('persists the parsed model on the run attempt', async () => {
       const model = buildModel({
         env: {RUN_ID: template('run.id')},