@shipfox/api-triggers 2.0.0

package/src/db/event-queries.ts

@@ -0,0 +1,140 @@
+import {paginateTimestampIdRows, timestampIdCursorWhere} from '@shipfox/node-drizzle';
+import {and, asc, count, desc, eq, gte, inArray, lte, type SQL} from 'drizzle-orm';
+import type {PgColumn} from 'drizzle-orm/pg-core';
+import type {TriggerDecision} from '#core/entities/decision.js';
+import type {
+  TriggerEventOutcome,
+  TriggerReceivedEvent,
+  TriggerReceivedEventSummary,
+} from '#core/entities/received-event.js';
+import {db} from './db.js';
+import {toTriggerDecision, triggersDecisions} from './schema/decisions.js';
+import {
+  toTriggerReceivedEvent,
+  toTriggerReceivedEventSummary,
+  triggerReceivedEventSummaryColumns,
+  triggersReceivedEvents,
+} from './schema/received-events.js';
+
+export interface TriggerEventCursor {
+  receivedAt: Date;
+  id: string;
+}
+
+export interface TriggerEventListFilters {
+  source?: string[] | undefined;
+  event?: string[] | undefined;
+  outcomes?: TriggerEventOutcome[] | undefined;
+  from?: Date | undefined;
+  to?: Date | undefined;
+}
+
+export interface ListTriggerEventsParams {
+  workspaceId: string;
+  limit: number;
+  cursor?: TriggerEventCursor | undefined;
+  filters?: TriggerEventListFilters | undefined;
+}
+
+export interface ListTriggerEventsResult {
+  events: TriggerReceivedEventSummary[];
+  nextCursor: TriggerEventCursor | null;
+}
+
+function listConditions(params: ListTriggerEventsParams): SQL[] {
+  const {workspaceId, cursor, filters} = params;
+  const conditions: SQL[] = [eq(triggersReceivedEvents.workspaceId, workspaceId)];
+  const cursorCondition = timestampIdCursorWhere({
+    timestampColumn: triggersReceivedEvents.receivedAt,
+    idColumn: triggersReceivedEvents.id,
+    cursor: cursor ? {createdAt: cursor.receivedAt, id: cursor.id} : undefined,
+  });
+  if (cursorCondition) conditions.push(cursorCondition);
+  if (filters?.source?.length)
+    conditions.push(inArray(triggersReceivedEvents.source, filters.source));
+  if (filters?.event?.length) conditions.push(inArray(triggersReceivedEvents.event, filters.event));
+  if (filters?.outcomes?.length)
+    conditions.push(inArray(triggersReceivedEvents.outcome, filters.outcomes));
+  if (filters?.from) conditions.push(gte(triggersReceivedEvents.receivedAt, filters.from));
+  if (filters?.to) conditions.push(lte(triggersReceivedEvents.receivedAt, filters.to));
+  return conditions;
+}
+
+export async function listTriggerEvents(
+  params: ListTriggerEventsParams,
+): Promise<ListTriggerEventsResult> {
+  const rows = await db()
+    .select(triggerReceivedEventSummaryColumns)
+    .from(triggersReceivedEvents)
+    .where(and(...listConditions(params)))
+    .orderBy(desc(triggersReceivedEvents.receivedAt), desc(triggersReceivedEvents.id))
+    .limit(params.limit + 1);
+
+  const page = paginateTimestampIdRows({rows, limit: params.limit, timestampKey: 'receivedAt'});
+
+  return {
+    events: page.pageRows.map(toTriggerReceivedEventSummary),
+    nextCursor: page.nextCursor
+      ? {receivedAt: page.nextCursor.createdAt, id: page.nextCursor.id}
+      : null,
+  };
+}
+
+export async function getTriggerEventById(id: string): Promise<TriggerReceivedEvent | undefined> {
+  const [row] = await db()
+    .select()
+    .from(triggersReceivedEvents)
+    .where(eq(triggersReceivedEvents.id, id))
+    .limit(1);
+  return row ? toTriggerReceivedEvent(row) : undefined;
+}
+
+export interface TriggerEventFacet {
+  value: string;
+  count: number;
+}
+
+export interface ListTriggerEventFacetsResult {
+  sources: TriggerEventFacet[];
+  events: TriggerEventFacet[];
+}
+
+// Distinct filter values for a workspace, capped so one noisy integration can't flood
+// the dropdown. Workspace-unfiltered by design: a stable option list, not one that
+// shifts as the other filters change. The (workspace_id, source) / (workspace_id, event)
+// indexes back the group-by. Ties break on the value so the order is deterministic.
+const FACET_LIMIT = 50;
+
+async function listFacet(workspaceId: string, column: PgColumn): Promise<TriggerEventFacet[]> {
+  const rows = await db()
+    .select({value: column, count: count()})
+    .from(triggersReceivedEvents)
+    .where(eq(triggersReceivedEvents.workspaceId, workspaceId))
+    .groupBy(column)
+    .orderBy(desc(count()), asc(column))
+    .limit(FACET_LIMIT);
+  return rows.map((row) => ({value: row.value as string, count: Number(row.count)}));
+}
+
+export async function listTriggerEventFacets(params: {
+  workspaceId: string;
+}): Promise<ListTriggerEventFacetsResult> {
+  const [sources, events] = await Promise.all([
+    listFacet(params.workspaceId, triggersReceivedEvents.source),
+    listFacet(params.workspaceId, triggersReceivedEvents.event),
+  ]);
+  return {sources, events};
+}
+
+// `received_event_id` is a globally-unique uuid, so the parent-event lookup is the
+// workspace gate; the decision query needs no separate workspace predicate.
+export async function listDecisionsByReceivedEventId(
+  receivedEventId: string,
+): Promise<TriggerDecision[]> {
+  const rows = await db()
+    .select()
+    .from(triggersDecisions)
+    .where(eq(triggersDecisions.receivedEventId, receivedEventId))
+    .orderBy(asc(triggersDecisions.createdAt), asc(triggersDecisions.id));
+  return rows.map(toTriggerDecision);
+}

package/src/db/index.ts

@@ -0,0 +1,51 @@
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+export {
+  advanceCronSchedule,
+  claimDueCronSchedules,
+  countDueCronSchedules,
+  deleteCronScheduleForSubscription,
+  getCronScheduleBySubscriptionId,
+  syncCronSchedule,
+} from './cron-schedules.js';
+export {closeDb, db, type Executor, schema, type Tx} from './db.js';
+export {
+  getTriggerEventById,
+  type ListTriggerEventFacetsResult,
+  type ListTriggerEventsParams,
+  type ListTriggerEventsResult,
+  listDecisionsByReceivedEventId,
+  listTriggerEventFacets,
+  listTriggerEvents,
+  type TriggerEventCursor,
+  type TriggerEventFacet,
+  type TriggerEventListFilters,
+} from './event-queries.js';
+export {
+  type FindMatchingJobListenerSubscriptionsParams,
+  findMatchingJobListenerSubscriptions,
+  type ListenerMatcher,
+  type ProjectJobListenerSubscriptionsParams,
+  projectJobListenerSubscriptions,
+  removeJobListenerSubscriptionsForJob,
+} from './job-listener-subscriptions.js';
+export {
+  type CronScheduleDb,
+  type CronScheduleInsertDb,
+  toCronSchedule,
+  triggersCronSchedules,
+} from './schema/cron-schedules.js';
+export {jobListenerSubscriptions} from './schema/job-listener-subscriptions.js';
+export {triggersOutbox} from './schema/outbox.js';
+export {triggerSubscriptions} from './schema/subscriptions.js';
+export {
+  deleteSubscriptionsForDefinition,
+  findMatchingSubscriptions,
+  getManualSubscriptionByDefinitionId,
+  getTriggerSubscriptionById,
+  listSubscriptionsByWorkflowDefinitionIds,
+  projectDefinitionTriggers,
+} from './subscriptions.js';
+
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');

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

@@ -0,0 +1,270 @@
+import type {WorkflowsJobActivatedEventDto} from '@shipfox/api-workflows-dto';
+import {eq} from 'drizzle-orm';
+import {db} from '#db/db.js';
+import {jobListenerSubscriptions} from '#db/schema/job-listener-subscriptions.js';
+import {onJobActivated} from '#presentation/subscribers/on-job-activated.js';
+import {onJobTerminated} from '#presentation/subscribers/on-job-terminated.js';
+import {jobListenerSubscriptionFactory} from '#test/index.js';
+import {findMatchingJobListenerSubscriptions} from './job-listener-subscriptions.js';
+
+function buildActivatedPayload(
+  overrides: Partial<WorkflowsJobActivatedEventDto> = {},
+): WorkflowsJobActivatedEventDto {
+  const payload = {
+    jobId: crypto.randomUUID(),
+    workflowRunId: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    mode: 'listening',
+    on: [{source: 'github', event: 'pull_request_review', inputs: {state: 'approved'}}],
+    until: [{source: 'github', event: 'pull_request', filter: 'payload.action == "closed"'}],
+    ...overrides,
+  };
+  return payload as WorkflowsJobActivatedEventDto;
+}
+
+function listJobSubscriptions(jobId: string) {
+  return db()
+    .select()
+    .from(jobListenerSubscriptions)
+    .where(eq(jobListenerSubscriptions.jobId, jobId));
+}
+
+describe('job listener subscriptions', () => {
+  it('projects one row per activated listener matcher with its ordinal', async () => {
+    const payload = buildActivatedPayload({
+      on: [
+        {source: 'github', event: 'pull_request_review', inputs: {state: 'approved'}},
+        {source: 'github', event: 'check_suite'},
+      ],
+      until: [{source: 'github', event: 'pull_request'}],
+    });
+
+    await onJobActivated(payload);
+
+    const rows = await listJobSubscriptions(payload.jobId);
+    expect(rows).toHaveLength(3);
+    expect(rows.map((row) => [row.kind, row.matcherOrdinal]).sort()).toEqual([
+      ['on', 0],
+      ['on', 1],
+      ['until', 0],
+    ]);
+    expect(rows.find((row) => row.matcherOrdinal === 0 && row.kind === 'on')?.config).toEqual({
+      inputs: {state: 'approved'},
+    });
+  });
+
+  it('does not project subscriptions for one-shot jobs', async () => {
+    const payload = buildActivatedPayload({mode: 'one_shot'});
+
+    await onJobActivated(payload);
+
+    const rows = await listJobSubscriptions(payload.jobId);
+    expect(rows).toHaveLength(0);
+  });
+
+  it('is idempotent for the same activated listener payload', async () => {
+    const payload = buildActivatedPayload();
+
+    await onJobActivated(payload);
+    await onJobActivated(payload);
+
+    const rows = await listJobSubscriptions(payload.jobId);
+    expect(rows).toHaveLength(2);
+  });
+
+  it('prunes stale matcher ordinals when a listener is re-projected with fewer matchers', async () => {
+    const payload = buildActivatedPayload({
+      on: [
+        {source: 'github', event: 'pull_request_review', inputs: {state: 'approved'}},
+        {source: 'github', event: 'check_suite'},
+      ],
+      until: [{source: 'github', event: 'pull_request'}],
+    });
+
+    await onJobActivated(payload);
+    await onJobActivated({
+      ...payload,
+      on: [{source: 'github', event: 'pull_request_review', inputs: {state: 'approved'}}],
+      until: null,
+    });
+
+    const rows = await listJobSubscriptions(payload.jobId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.kind).toBe('on');
+    expect(rows[0]?.matcherOrdinal).toBe(0);
+  });
+
+  it('preserves duplicate source and event matchers by ordinal', async () => {
+    const payload = buildActivatedPayload({
+      on: [
+        {
+          source: 'github',
+          event: 'pull_request_review',
+          filter: 'payload.review.state == "approved"',
+        },
+        {
+          source: 'github',
+          event: 'pull_request_review',
+          filter: 'payload.review.state == "changes_requested"',
+        },
+      ],
+      until: null,
+    });
+
+    await onJobActivated(payload);
+
+    const rows = await listJobSubscriptions(payload.jobId);
+    expect(rows).toHaveLength(2);
+    expect(rows.map((row) => row.matcherOrdinal).sort()).toEqual([0, 1]);
+    expect(
+      rows.every((row) => row.source === 'github' && row.event === 'pull_request_review'),
+    ).toBe(true);
+  });
+
+  it('persists listener filter snapshots verbatim in matcher config', async () => {
+    const filterSnapshot = {jobs: {build: {outputs: {pr_number: 42}}}};
+    const payload = buildActivatedPayload({
+      on: [
+        {
+          source: 'github',
+          event: 'pull_request_review',
+          filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
+          filter_snapshot: filterSnapshot,
+        },
+      ],
+      until: null,
+    });
+
+    await onJobActivated(payload);
+
+    const rows = await listJobSubscriptions(payload.jobId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.config).toEqual({
+      filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
+      filter_snapshot: filterSnapshot,
+    });
+  });
+
+  it('omits filter snapshots from matcher config when absent', async () => {
+    const payload = buildActivatedPayload({
+      on: [{source: 'github', event: 'pull_request_review', filter: 'event.action == "created"'}],
+      until: null,
+    });
+
+    await onJobActivated(payload);
+
+    const rows = await listJobSubscriptions(payload.jobId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.config).toEqual({filter: 'event.action == "created"'});
+  });
+
+  it('updates existing matcher ordinals with replacement filter snapshots', async () => {
+    const payload = buildActivatedPayload({
+      on: [
+        {
+          source: 'github',
+          event: 'pull_request_review',
+          filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
+          filter_snapshot: {jobs: {build: {outputs: {pr_number: 42}}}},
+        },
+      ],
+      until: null,
+    });
+
+    await onJobActivated(payload);
+    await onJobActivated({
+      ...payload,
+      on: [
+        {
+          source: 'github',
+          event: 'pull_request_review',
+          filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
+          filter_snapshot: {jobs: {build: {outputs: {pr_number: 43}}}},
+        },
+      ],
+    });
+
+    const rows = await listJobSubscriptions(payload.jobId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.config).toEqual({
+      filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
+      filter_snapshot: {jobs: {build: {outputs: {pr_number: 43}}}},
+    });
+  });
+
+  it('deletes all subscriptions for a terminated job', async () => {
+    const jobId = crypto.randomUUID();
+    await jobListenerSubscriptionFactory.create({jobId, kind: 'on', matcherOrdinal: 0});
+    await jobListenerSubscriptionFactory.create({jobId, kind: 'until', matcherOrdinal: 0});
+
+    await onJobTerminated({
+      jobId,
+      workflowRunId: crypto.randomUUID(),
+      workflowRunAttemptId: crypto.randomUUID(),
+      status: 'succeeded',
+      statusReason: null,
+    });
+
+    const rows = await listJobSubscriptions(jobId);
+    expect(rows).toHaveLength(0);
+  });
+
+  it('treats deleting subscriptions for an unknown job as a no-op', async () => {
+    const jobId = crypto.randomUUID();
+
+    await onJobTerminated({
+      jobId,
+      workflowRunId: crypto.randomUUID(),
+      workflowRunAttemptId: crypto.randomUUID(),
+      status: 'cancelled',
+      statusReason: null,
+    });
+
+    const rows = await listJobSubscriptions(jobId);
+    expect(rows).toHaveLength(0);
+  });
+
+  it('finds matching subscriptions by workspace, source, and event', async () => {
+    const workspaceId = crypto.randomUUID();
+    const matching = await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+    await jobListenerSubscriptionFactory.create({
+      workspaceId: crypto.randomUUID(),
+      source: 'github',
+      event: 'push',
+    });
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: 'pull_request',
+    });
+
+    const rows = await findMatchingJobListenerSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+
+    expect(rows.map((row) => row.id)).toEqual([matching.id]);
+  });
+
+  it('returns no subscriptions for a negative match', async () => {
+    const workspaceId = crypto.randomUUID();
+    await jobListenerSubscriptionFactory.create({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+
+    const rows = await findMatchingJobListenerSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'pull_request',
+    });
+
+    expect(rows).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,133 @@
+import {and, eq, notInArray} from 'drizzle-orm';
+import type {
+  JobListenerMatcherKind,
+  JobListenerSubscription,
+} from '#core/entities/job-listener-subscription.js';
+import {db} from './db.js';
+import {
+  jobListenerSubscriptions,
+  toJobListenerSubscription,
+} from './schema/job-listener-subscriptions.js';
+
+type Tx = Parameters<Parameters<ReturnType<typeof db>['transaction']>[0]>[0];
+
+export interface ListenerMatcher {
+  source: string;
+  event: string;
+  inputs?: Readonly<Record<string, unknown>> | undefined;
+  filter?: string | undefined;
+  filter_snapshot?: Readonly<Record<string, unknown>> | undefined;
+}
+
+export interface ProjectJobListenerSubscriptionsParams {
+  workspaceId: string;
+  workflowRunId: string;
+  jobId: string;
+  on: readonly ListenerMatcher[] | null;
+  until: readonly ListenerMatcher[] | null;
+}
+
+export async function projectJobListenerSubscriptions(
+  params: ProjectJobListenerSubscriptionsParams,
+): Promise<void> {
+  await db().transaction(async (tx) => {
+    await pruneStaleMatchers(tx, params.jobId, 'on', params.on ?? []);
+    await pruneStaleMatchers(tx, params.jobId, 'until', params.until ?? []);
+
+    for (const [kind, matchers] of [
+      ['on', params.on ?? []],
+      ['until', params.until ?? []],
+    ] as const) {
+      for (const [matcherOrdinal, matcher] of matchers.entries()) {
+        const config: Record<string, unknown> = {};
+        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;
+
+        await tx
+          .insert(jobListenerSubscriptions)
+          .values({
+            workspaceId: params.workspaceId,
+            workflowRunId: params.workflowRunId,
+            jobId: params.jobId,
+            kind,
+            matcherOrdinal,
+            source: matcher.source,
+            event: matcher.event,
+            config,
+          })
+          .onConflictDoUpdate({
+            target: [
+              jobListenerSubscriptions.jobId,
+              jobListenerSubscriptions.kind,
+              jobListenerSubscriptions.matcherOrdinal,
+            ],
+            set: {
+              workspaceId: params.workspaceId,
+              workflowRunId: params.workflowRunId,
+              source: matcher.source,
+              event: matcher.event,
+              config,
+            },
+          });
+      }
+    }
+  });
+}
+
+async function pruneStaleMatchers(
+  tx: Tx,
+  jobId: string,
+  kind: JobListenerMatcherKind,
+  matchers: readonly ListenerMatcher[],
+): Promise<void> {
+  const base = and(
+    eq(jobListenerSubscriptions.jobId, jobId),
+    eq(jobListenerSubscriptions.kind, kind),
+  );
+
+  if (matchers.length === 0) {
+    await tx.delete(jobListenerSubscriptions).where(base);
+    return;
+  }
+
+  await tx.delete(jobListenerSubscriptions).where(
+    and(
+      base,
+      notInArray(
+        jobListenerSubscriptions.matcherOrdinal,
+        matchers.map((_matcher, index) => index),
+      ),
+    ),
+  );
+}
+
+export async function removeJobListenerSubscriptionsForJob(jobId: string): Promise<number> {
+  const rows = await db()
+    .delete(jobListenerSubscriptions)
+    .where(eq(jobListenerSubscriptions.jobId, jobId))
+    .returning({id: jobListenerSubscriptions.id});
+  return rows.length;
+}
+
+export interface FindMatchingJobListenerSubscriptionsParams {
+  workspaceId: string;
+  source: string;
+  event: string;
+}
+
+export async function findMatchingJobListenerSubscriptions(
+  params: FindMatchingJobListenerSubscriptionsParams,
+): Promise<JobListenerSubscription[]> {
+  const rows = await db()
+    .select()
+    .from(jobListenerSubscriptions)
+    .where(
+      and(
+        eq(jobListenerSubscriptions.workspaceId, params.workspaceId),
+        eq(jobListenerSubscriptions.source, params.source),
+        eq(jobListenerSubscriptions.event, params.event),
+      ),
+    );
+  return rows.map(toJobListenerSubscription);
+}

package/src/db/received-events.ts

@@ -0,0 +1,16 @@
+import {lt} from 'drizzle-orm';
+import {db} from './db.js';
+import {triggersReceivedEvents} from './schema/received-events.js';
+
+export interface PruneTriggerEventsParams {
+  olderThan: Date;
+}
+
+export async function pruneTriggerEvents(
+  params: PruneTriggerEventsParams,
+): Promise<{deleted: number}> {
+  const result = await db()
+    .delete(triggersReceivedEvents)
+    .where(lt(triggersReceivedEvents.createdAt, params.olderThan));
+  return {deleted: result.rowCount ?? 0};
+}

package/src/db/schema/common.ts

@@ -0,0 +1,3 @@
+import {pgTableCreator} from 'drizzle-orm/pg-core';
+
+export const pgTable = pgTableCreator((name) => `triggers_${name}`);

package/src/db/schema/cron-schedules.ts

@@ -0,0 +1,37 @@
+import {index, text, timestamp, uuid} from 'drizzle-orm/pg-core';
+import type {CronSchedule} from '#core/entities/cron-schedule.js';
+import {pgTable} from './common.js';
+import {triggerSubscriptions} from './subscriptions.js';
+
+export const triggersCronSchedules = pgTable(
+  'cron_schedules',
+  {
+    subscriptionId: uuid('subscription_id')
+      .primaryKey()
+      .references(() => triggerSubscriptions.id, {onDelete: 'cascade'}),
+    workspaceId: uuid('workspace_id').notNull(),
+    cronExpression: text('cron_expression').notNull(),
+    timezone: text('timezone').notNull(),
+    nextFireAt: timestamp('next_fire_at', {withTimezone: true}).notNull(),
+    lastFiredAt: timestamp('last_fired_at', {withTimezone: true}),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [index('triggers_cron_schedules_next_fire_at_idx').on(table.nextFireAt)],
+);
+
+export type CronScheduleDb = typeof triggersCronSchedules.$inferSelect;
+export type CronScheduleInsertDb = typeof triggersCronSchedules.$inferInsert;
+
+export function toCronSchedule(row: CronScheduleDb): CronSchedule {
+  return {
+    subscriptionId: row.subscriptionId,
+    workspaceId: row.workspaceId,
+    cronExpression: row.cronExpression,
+    timezone: row.timezone,
+    nextFireAt: row.nextFireAt,
+    lastFiredAt: row.lastFiredAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}