@shipfox/api-workflows 12.1.0 → 12.2.0

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/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)

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')},

package/test/factories/workflow-model.ts

@@ -55,6 +55,7 @@ interface TestWorkflowJob {
   readonly if?: string | undefined;
   readonly success?: string | undefined;
   readonly outputs?: Readonly<Record<string, string>> | undefined;
+  readonly outputTypes?: WorkflowModel['jobs'][number]['outputTypes'] | undefined;
   readonly env?: WorkflowModel['env'] | undefined;
   readonly listening?: WorkflowModel['jobs'][number]['listening'] | undefined;
   readonly steps: readonly TestWorkflowStep[];
@@ -92,6 +93,7 @@ export function workflowModel(input: TestWorkflowModelInput = {}): WorkflowModel
       ...(job.if === undefined ? {} : {if: workflowExpression(job.if)}),
       ...(job.success === undefined ? {} : {success: job.success}),
       ...(job.outputs === undefined ? {} : {outputs: outputTemplates(job.outputs)}),
+      ...(job.outputTypes === undefined ? {} : {outputTypes: job.outputTypes}),
       ...(job.name === undefined ? {} : {name: job.name}),
       ...(job.executionName === undefined
         ? {}