@shipfox/api-triggers 12.1.0 → 12.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-triggers",
   "license": "MIT",
-  "version": "12.1.0",
+  "version": "12.3.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -22,23 +22,23 @@
     "cron-parser": "^5.6.1",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-auth-context": "12.0.0",
-    "@shipfox/api-definitions-dto": "12.0.0",
-    "@shipfox/api-integration-core-dto": "12.0.0",
+    "@shipfox/api-auth-context": "12.2.0",
+    "@shipfox/api-definitions-dto": "12.3.0",
+    "@shipfox/api-integration-core-dto": "12.2.0",
     "@shipfox/api-triggers-dto": "9.0.2",
-    "@shipfox/api-workflows-dto": "12.1.0",
+    "@shipfox/api-workflows-dto": "12.3.0",
     "@shipfox/config": "1.2.4",
-    "@shipfox/expression": "2.0.0",
+    "@shipfox/expression": "2.2.0",
     "@shipfox/inter-module": "0.2.3",
     "@shipfox/node-drizzle": "0.3.5",
     "@shipfox/node-error-monitoring": "0.3.0",
-    "@shipfox/node-fastify": "0.4.1",
-    "@shipfox/node-module": "1.0.5",
-    "@shipfox/node-opentelemetry": "0.6.3",
+    "@shipfox/node-fastify": "0.4.2",
+    "@shipfox/node-module": "1.0.6",
+    "@shipfox/node-opentelemetry": "0.6.4",
     "@shipfox/node-outbox": "0.2.6",
     "@shipfox/node-postgres": "0.5.0",
-    "@shipfox/node-temporal": "0.4.4",
-    "@shipfox/workflow-document": "3.0.0"
+    "@shipfox/node-temporal": "0.4.5",
+    "@shipfox/workflow-document": "3.0.1"
   },
   "imports": {
     "#*": "./dist/*"

package/src/core/route-event-to-job-listeners.test.ts

@@ -319,6 +319,103 @@ describe('routeEventToJobListeners', () => {
     expect(result).toMatchObject({engagedCount: 1, matchedJobCount: 1, acceptedJobCount: 1});
   });
 
+  it.each([
+    {
+      name: 'integer output',
+      filter: 'jobs.build.outputs.count + 1 == 43',
+      filterSnapshot: {jobs: {build: {outputs: {count: 42}}}},
+      filterOutputTypes: {build: {count: 'int'}},
+    },
+    {
+      name: 'timestamp output',
+      filter: 'jobs.build.outputs.createdAt < timestamp("2026-07-01T00:00:00Z")',
+      filterSnapshot: {jobs: {build: {outputs: {createdAt: '2026-06-30T12:00:00.000Z'}}}},
+      filterOutputTypes: {build: {createdAt: 'timestamp'}},
+    },
+    {
+      name: 'integer execution output',
+      filter: 'jobs.build.executions[0].outputs.count + 1 == 43',
+      filterSnapshot: {jobs: {build: {executions: [{outputs: {count: 42}}]}}},
+      filterOutputTypes: {build: {count: 'int'}},
+    },
+    {
+      name: 'timestamp execution output',
+      filter: 'jobs.build.executions[0].outputs.createdAt < timestamp("2026-07-01T00:00:00Z")',
+      filterSnapshot: {
+        jobs: {build: {executions: [{outputs: {createdAt: '2026-06-30T12:00:00.000Z'}}]}},
+      },
+      filterOutputTypes: {build: {createdAt: 'timestamp'}},
+    },
+    {
+      name: 'nested output',
+      filter: 'jobs.build.outputs.details.count + 1 == 43',
+      filterSnapshot: {jobs: {build: {outputs: {details: {count: 42}}}}},
+      filterOutputTypes: {
+        build: {details: {kind: 'object', fields: {count: 'int'}}},
+      },
+    },
+  ])('rehydrates a $name in listener filters', async ({
+    filter,
+    filterSnapshot,
+    filterOutputTypes,
+  }) => {
+    const workspaceId = crypto.randomUUID();
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: 'pull_request_review',
+      config: {
+        filter,
+        filter_snapshot: filterSnapshot,
+        filter_output_types: filterOutputTypes,
+      },
+    });
+
+    const result = await route({workspaceId});
+
+    expect(deliverEventToListener).toHaveBeenCalledTimes(1);
+    expect(listenerFilterErrored).not.toHaveBeenCalled();
+    expect(result).toMatchObject({engagedCount: 1, matchedJobCount: 1, acceptedJobCount: 1});
+  });
+
+  it.each([
+    'on',
+    'until',
+  ] as const)('rehydrates CEL scalar values in %s listener filter snapshots', async (kind) => {
+    const workspaceId = crypto.randomUUID();
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      kind,
+      source: 'github',
+      event: 'pull_request_review',
+      config: {
+        filter:
+          'run.number + 1 == 2 && run.created_at < timestamp("2026-07-01T00:00:00Z") && jobs.build.executions[0].index + 1 == 1 && jobs.build.executions[0].started_at < timestamp("2026-07-01T00:00:00Z") && jobs.build.executions[0].events[0].received_at < timestamp("2026-07-01T00:00:00Z")',
+        filter_snapshot: {
+          run: {number: 1, created_at: '2026-06-30T12:00:00.000Z'},
+          jobs: {
+            build: {
+              executions: [
+                {
+                  index: 0,
+                  started_at: '2026-06-30T12:00:00.000Z',
+                  finished_at: null,
+                  events: [{received_at: '2026-06-30T12:00:00.000Z'}],
+                },
+              ],
+            },
+          },
+        },
+      },
+    });
+
+    const result = await route({workspaceId});
+
+    expect(deliverEventToListener).toHaveBeenCalledTimes(1);
+    expect(listenerFilterErrored).not.toHaveBeenCalled();
+    expect(result).toMatchObject({engagedCount: 1, matchedJobCount: 1, acceptedJobCount: 1});
+  });
+
   it('does not deliver or record a decision when a listener filter returns false', async () => {
     const workspaceId = crypto.randomUUID();
     await jobListenerSubscriptionFactory.create({

package/src/core/route-event-to-job-listeners.ts

@@ -1,4 +1,8 @@
-import {projectWorkflowPredicateContext} from '@shipfox/expression';
+import {
+  type ListenerFilterOutputTypes,
+  listenerFilterOutputTypesSchema,
+} from '@shipfox/api-workflows-dto';
+import {projectWorkflowPredicateContext, rehydrateJsonExpressionRecord} from '@shipfox/expression';
 import {logger} from '@shipfox/node-opentelemetry';
 import {findMatchingJobListenerSubscriptions} from '#db/job-listener-subscriptions.js';
 import {evaluateStoredFilter, type StoredFilterEvaluation} from './config.js';
@@ -9,6 +13,8 @@ import {
   type WorkflowsModuleClient,
 } from './workflows-client.js';
 
+const LISTENER_INTEGER_PATTERN = /^-?\d+$/;
+
 export interface RouteEventToJobListenersParams {
   workflows: WorkflowsModuleClient;
   history: TriggerHistoryRecorder;
@@ -158,7 +164,10 @@ function evaluateListenerFilter(params: EvaluateListenerFilterParams): StoredFil
     value: filter,
     context: projectWorkflowPredicateContext(
       params.subscription.kind === 'on' ? 'listener.on' : 'listener.until',
-      {...snapshot.value, event: params.payload},
+      {
+        ...rehydrateListenerFilterSnapshot(snapshot.value, snapshot.outputTypes),
+        event: params.payload,
+      },
     ),
     invalidReason: 'Listener subscription filter must be a non-empty string when set',
     evaluationFailedReason: 'Listener filter evaluation failed',
@@ -168,22 +177,159 @@ function evaluateListenerFilter(params: EvaluateListenerFilterParams): StoredFil
 function readFilterSnapshot(
   subscription: JobListenerSubscription,
 ):
-  | {kind: 'valid'; value: Record<string, unknown>}
+  | {kind: 'valid'; value: Record<string, unknown>; outputTypes?: ListenerFilterOutputTypes}
   | {kind: 'invalid'; result: Extract<StoredFilterEvaluation, {kind: 'filter-error'}>} {
   const value = subscription.config.filter_snapshot;
-  if (value === undefined) return {kind: 'valid', value: {}};
-  if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-    return {kind: 'valid', value: value as Record<string, unknown>};
+  if (
+    value !== undefined &&
+    (value === null || typeof value !== 'object' || Array.isArray(value))
+  ) {
+    return {
+      kind: 'invalid',
+      result: {
+        kind: 'filter-error',
+        reason: 'Listener filter snapshot must be an object when set',
+      },
+    };
+  }
+
+  const outputTypesValue = subscription.config.filter_output_types;
+  if (outputTypesValue !== undefined) {
+    const parsedOutputTypes = listenerFilterOutputTypesSchema.safeParse(outputTypesValue);
+    if (!parsedOutputTypes.success) {
+      return {
+        kind: 'invalid',
+        result: {
+          kind: 'filter-error',
+          reason: 'Listener filter output types must be valid when set',
+        },
+      };
+    }
+    return {
+      kind: 'valid',
+      value: (value ?? {}) as Record<string, unknown>,
+      outputTypes: parsedOutputTypes.data,
+    };
   }
+
+  return {kind: 'valid', value: (value ?? {}) as Record<string, unknown>};
+}
+
+function rehydrateListenerFilterSnapshot(
+  snapshot: Record<string, unknown>,
+  outputTypes: ListenerFilterOutputTypes | undefined,
+): Record<string, unknown> {
+  let result = snapshot;
+  if (outputTypes !== undefined && isRecord(snapshot.jobs)) {
+    const jobs = Object.fromEntries(
+      Object.entries(snapshot.jobs).map(([jobKey, jobContext]) => {
+        const jobOutputTypes = Object.hasOwn(outputTypes, jobKey) ? outputTypes[jobKey] : undefined;
+        if (jobOutputTypes === undefined || !isRecord(jobContext)) {
+          return [jobKey, jobContext];
+        }
+
+        const outputs = isRecord(jobContext.outputs)
+          ? rehydrateJsonExpressionRecord(jobContext.outputs, jobOutputTypes)
+          : jobContext.outputs;
+        const executions = Array.isArray(jobContext.executions)
+          ? jobContext.executions.map((execution) => {
+              if (!isRecord(execution) || !isRecord(execution.outputs)) return execution;
+              return {
+                ...execution,
+                outputs: rehydrateJsonExpressionRecord(execution.outputs, jobOutputTypes),
+              };
+            })
+          : jobContext.executions;
+
+        return [
+          jobKey,
+          {
+            ...jobContext,
+            outputs,
+            executions,
+          },
+        ];
+      }),
+    );
+    result = {...snapshot, jobs};
+  }
+
+  const rehydrated = {...result};
+  if (isRecord(result.run)) rehydrated.run = rehydrateRunSnapshot(result.run);
+  if (isRecord(result.jobs)) rehydrated.jobs = rehydrateJobsSnapshot(result.jobs);
+  return rehydrated;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function rehydrateRunSnapshot(run: Record<string, unknown>): Record<string, unknown> {
+  const result = {...run};
+  if ('number' in run) result.number = rehydrateListenerInt(run.number);
+  if ('created_at' in run) result.created_at = rehydrateListenerTimestamp(run.created_at);
+  return result;
+}
+
+function rehydrateJobsSnapshot(jobs: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(jobs).map(([jobKey, value]) => [
+      jobKey,
+      isRecord(value) ? rehydrateJobSnapshot(value) : value,
+    ]),
+  );
+}
+
+function rehydrateJobSnapshot(job: Record<string, unknown>): Record<string, unknown> {
+  if (!Array.isArray(job.executions)) return job;
+
   return {
-    kind: 'invalid',
-    result: {
-      kind: 'filter-error',
-      reason: 'Listener filter snapshot must be an object when set',
-    },
+    ...job,
+    executions: job.executions.map((value) =>
+      isRecord(value) ? rehydrateExecutionSnapshot(value) : value,
+    ),
   };
 }
 
+function rehydrateExecutionSnapshot(execution: Record<string, unknown>): Record<string, unknown> {
+  const result = {...execution};
+  if ('index' in execution) result.index = rehydrateListenerInt(execution.index);
+  if ('started_at' in execution) {
+    result.started_at = rehydrateListenerTimestamp(execution.started_at);
+  }
+  if ('finished_at' in execution) {
+    result.finished_at = rehydrateListenerTimestamp(execution.finished_at);
+  }
+  if (Array.isArray(execution.events)) {
+    result.events = execution.events.map((value) =>
+      isRecord(value) ? rehydrateExecutionEventSnapshot(value) : value,
+    );
+  }
+  return result;
+}
+
+function rehydrateExecutionEventSnapshot(event: Record<string, unknown>): Record<string, unknown> {
+  if (!('received_at' in event)) return event;
+  return {...event, received_at: rehydrateListenerTimestamp(event.received_at)};
+}
+
+function rehydrateListenerInt(value: unknown): unknown {
+  if (typeof value === 'number' && Number.isSafeInteger(value)) return BigInt(value);
+  if (typeof value !== 'string' || !LISTENER_INTEGER_PATTERN.test(value)) return value;
+
+  try {
+    return BigInt(value);
+  } catch {
+    return value;
+  }
+}
+
+function rehydrateListenerTimestamp(value: unknown): unknown {
+  if (typeof value !== 'string') return value;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? value : date;
+}
+
 function listenerDisposition(subscription: JobListenerSubscription): 'fire' | 'resolve' {
   return subscription.kind === 'until' ? 'resolve' : 'fire';
 }

package/src/db/job-listener-subscriptions.test.ts

@@ -123,6 +123,7 @@ describe('job listener subscriptions', () => {
 
   it('persists listener filter snapshots verbatim in matcher config', async () => {
     const filterSnapshot = {jobs: {build: {outputs: {pr_number: 42}}}};
+    const filterOutputTypes = {build: {pr_number: 'int' as const}};
     const payload = buildActivatedPayload({
       on: [
         {
@@ -130,6 +131,7 @@ describe('job listener subscriptions', () => {
           event: 'pull_request_review',
           filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
           filter_snapshot: filterSnapshot,
+          filter_output_types: filterOutputTypes,
         },
       ],
       until: null,
@@ -142,6 +144,7 @@ describe('job listener subscriptions', () => {
     expect(rows[0]?.config).toEqual({
       filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
       filter_snapshot: filterSnapshot,
+      filter_output_types: filterOutputTypes,
     });
   });
 

package/src/db/job-listener-subscriptions.ts

@@ -17,6 +17,7 @@ export interface ListenerMatcher {
   inputs?: Readonly<Record<string, unknown>> | undefined;
   filter?: string | undefined;
   filter_snapshot?: Readonly<Record<string, unknown>> | undefined;
+  filter_output_types?: Readonly<Record<string, unknown>> | undefined;
 }
 
 export interface ProjectJobListenerSubscriptionsParams {
@@ -43,6 +44,9 @@ export async function projectJobListenerSubscriptions(
         if (matcher.inputs !== undefined) config.inputs = matcher.inputs;
         if (matcher.filter !== undefined) config.filter = matcher.filter;
         if (matcher.filter_snapshot !== undefined) config.filter_snapshot = matcher.filter_snapshot;
+        if (matcher.filter_output_types !== undefined) {
+          config.filter_output_types = matcher.filter_output_types;
+        }
 
         await tx
           .insert(jobListenerSubscriptions)