@shipfox/api-triggers 2.0.0

package/src/db/schema/decisions.test.ts

@@ -0,0 +1,279 @@
+import {eq} from 'drizzle-orm';
+import {getTableConfig} from 'drizzle-orm/pg-core';
+import {db} from '../db.js';
+import {
+  type TriggerDecisionDb,
+  type TriggerDecisionInsertDb,
+  toTriggerDecision,
+  triggersDecisions,
+} from './decisions.js';
+import {triggersReceivedEvents} from './received-events.js';
+
+describe('toTriggerDecision', () => {
+  test('maps a fully populated row to the domain entity', () => {
+    const row: TriggerDecisionDb = {
+      id: '019e98ab-6656-7ca1-b9ad-1ca4442c479d',
+      receivedEventId: '019e98ab-b90f-7265-b13c-8b441c991381',
+      subscriptionKind: 'trigger',
+      subscriptionId: '019e98ab-b90f-7265-b13c-8b441c991382',
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: '019e98ab-b90f-7265-b13c-8b441c991383',
+      projectId: '019e98ab-b90f-7265-b13c-8b441c991384',
+      workflowRunId: null,
+      jobId: null,
+      matcherKind: null,
+      matcherOrdinal: null,
+      decision: 'triggered',
+      runId: '019e98ab-b90f-7265-b13c-8b441c991385',
+      runName: 'Build and test',
+      reason: null,
+      createdAt: new Date('2026-06-09T10:00:02.000Z'),
+    };
+
+    const result = toTriggerDecision(row);
+
+    expect(result).toEqual({
+      id: row.id,
+      receivedEventId: row.receivedEventId,
+      subscriptionKind: 'trigger',
+      subscriptionId: row.subscriptionId,
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: row.workflowDefinitionId,
+      projectId: row.projectId,
+      workflowRunId: null,
+      jobId: null,
+      matcherKind: null,
+      matcherOrdinal: null,
+      decision: 'triggered',
+      runId: row.runId,
+      runName: 'Build and test',
+      reason: null,
+      createdAt: row.createdAt,
+    });
+  });
+
+  test('passes through null run_id, run_name, and a populated reason', () => {
+    const row: TriggerDecisionDb = {
+      id: '019e98ab-6656-7ca1-b9ad-1ca4442c479d',
+      receivedEventId: '019e98ab-b90f-7265-b13c-8b441c991381',
+      subscriptionKind: 'trigger',
+      subscriptionId: '019e98ab-b90f-7265-b13c-8b441c991382',
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: '019e98ab-b90f-7265-b13c-8b441c991383',
+      projectId: '019e98ab-b90f-7265-b13c-8b441c991384',
+      workflowRunId: null,
+      jobId: null,
+      matcherKind: null,
+      matcherOrdinal: null,
+      decision: 'dispatch-error',
+      runId: null,
+      runName: null,
+      reason: 'runWorkflow threw',
+      createdAt: new Date('2026-06-09T10:00:02.000Z'),
+    };
+
+    const result = toTriggerDecision(row);
+
+    expect(result.decision).toBe('dispatch-error');
+    expect(result.runId).toBeNull();
+    expect(result.runName).toBeNull();
+    expect(result.reason).toBe('runWorkflow threw');
+  });
+
+  test('maps legacy errored rows to dispatch-error', () => {
+    const row = {
+      id: '019e98ab-6656-7ca1-b9ad-1ca4442c479d',
+      receivedEventId: '019e98ab-b90f-7265-b13c-8b441c991381',
+      subscriptionKind: 'trigger',
+      subscriptionId: '019e98ab-b90f-7265-b13c-8b441c991382',
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: '019e98ab-b90f-7265-b13c-8b441c991383',
+      projectId: '019e98ab-b90f-7265-b13c-8b441c991384',
+      workflowRunId: null,
+      jobId: null,
+      matcherKind: null,
+      matcherOrdinal: null,
+      decision: 'errored',
+      runId: null,
+      runName: null,
+      reason: 'runWorkflow threw',
+      createdAt: new Date('2026-06-09T10:00:02.000Z'),
+    } as unknown as TriggerDecisionDb;
+
+    const result = toTriggerDecision(row);
+
+    expect(result.decision).toBe('dispatch-error');
+  });
+});
+
+describe('triggers_decisions schema', () => {
+  async function insertEvent(): Promise<string> {
+    const [event] = await db()
+      .insert(triggersReceivedEvents)
+      .values({
+        eventRef: crypto.randomUUID(),
+        origin: 'integration',
+        workspaceId: crypto.randomUUID(),
+        source: 'github',
+        event: 'push',
+        receivedAt: new Date(),
+      })
+      .returning();
+    if (!event) throw new Error('insert returned no rows');
+    return event.id;
+  }
+
+  test('applies defaults and maps an inserted row', async () => {
+    const receivedEventId = await insertEvent();
+    const values: TriggerDecisionInsertDb = {
+      receivedEventId,
+      subscriptionKind: 'trigger',
+      subscriptionId: crypto.randomUUID(),
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      decision: 'triggered',
+    };
+
+    const [inserted] = await db()
+      .insert(triggersDecisions)
+      .values(values)
+      .returning({id: triggersDecisions.id});
+    if (!inserted) throw new Error('insert returned no rows');
+    const [row] = await db()
+      .select()
+      .from(triggersDecisions)
+      .where(eq(triggersDecisions.id, inserted.id));
+    if (!row) throw new Error('select returned no rows');
+    const result = toTriggerDecision(row);
+
+    expect(row.createdAt).toBeInstanceOf(Date);
+    expect(row.runId).toBeNull();
+    expect(row.runName).toBeNull();
+    expect(row.reason).toBeNull();
+    expect(result).toMatchObject({
+      receivedEventId,
+      subscriptionKind: 'trigger',
+      subscriptionId: values.subscriptionId,
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: values.workflowDefinitionId,
+      projectId: values.projectId,
+      decision: 'triggered',
+    });
+  });
+
+  test('cascades decision deletes when the parent event is removed', async () => {
+    const receivedEventId = await insertEvent();
+    await db().insert(triggersDecisions).values({
+      receivedEventId,
+      subscriptionKind: 'trigger',
+      subscriptionId: crypto.randomUUID(),
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      decision: 'triggered',
+    });
+
+    await db().delete(triggersReceivedEvents).where(eq(triggersReceivedEvents.id, receivedEventId));
+
+    const rows = await db()
+      .select()
+      .from(triggersDecisions)
+      .where(eq(triggersDecisions.receivedEventId, receivedEventId));
+    expect(rows).toHaveLength(0);
+  });
+
+  test('rejects a duplicate (received_event_id, subscription_kind, subscription_id)', async () => {
+    const receivedEventId = await insertEvent();
+    const values: TriggerDecisionInsertDb = {
+      receivedEventId,
+      subscriptionKind: 'trigger',
+      subscriptionId: crypto.randomUUID(),
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      decision: 'triggered',
+    };
+    await db().insert(triggersDecisions).values(values);
+
+    const duplicate = db().insert(triggersDecisions).values(values);
+
+    await expect(duplicate).rejects.toThrow();
+  });
+
+  test('allows trigger and listener decisions with the same subscription id', async () => {
+    const receivedEventId = await insertEvent();
+    const subscriptionId = crypto.randomUUID();
+    await db().insert(triggersDecisions).values({
+      receivedEventId,
+      subscriptionKind: 'trigger',
+      subscriptionId,
+      subscriptionName: 'Deploy production',
+      workflowDefinitionId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      decision: 'triggered',
+    });
+
+    await db().insert(triggersDecisions).values({
+      receivedEventId,
+      subscriptionKind: 'listener',
+      subscriptionId,
+      subscriptionName: 'listener on[0] github/push',
+      workflowRunId: crypto.randomUUID(),
+      jobId: crypto.randomUUID(),
+      matcherKind: 'on',
+      matcherOrdinal: 0,
+      decision: 'triggered',
+    });
+
+    const rows = await db()
+      .select()
+      .from(triggersDecisions)
+      .where(eq(triggersDecisions.receivedEventId, receivedEventId));
+    expect(rows).toHaveLength(2);
+  });
+
+  test('declares a database check for valid subscription kinds', () => {
+    const subscriptionKindCheck = getTableConfig(triggersDecisions).checks.find(
+      (check) => check.name === 'triggers_decisions_subscription_kind_ck',
+    );
+
+    expect(subscriptionKindCheck).toBeDefined();
+  });
+
+  test('maps listener identity fields', async () => {
+    const receivedEventId = await insertEvent();
+    const workflowRunId = crypto.randomUUID();
+    const jobId = crypto.randomUUID();
+    const [row] = await db()
+      .insert(triggersDecisions)
+      .values({
+        receivedEventId,
+        subscriptionKind: 'listener',
+        subscriptionId: crypto.randomUUID(),
+        subscriptionName: 'listener until[1] github/pull_request.closed',
+        workflowRunId,
+        jobId,
+        matcherKind: 'until',
+        matcherOrdinal: 1,
+        decision: 'dispatch-error',
+        reason: 'workflow db down',
+      })
+      .returning();
+    if (!row) throw new Error('insert returned no rows');
+
+    const result = toTriggerDecision(row);
+
+    expect(result).toMatchObject({
+      subscriptionKind: 'listener',
+      workflowDefinitionId: null,
+      projectId: null,
+      workflowRunId,
+      jobId,
+      matcherKind: 'until',
+      matcherOrdinal: 1,
+      decision: 'dispatch-error',
+      reason: 'workflow db down',
+    });
+  });
+});

package/src/db/schema/decisions.ts

@@ -0,0 +1,77 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {sql} from 'drizzle-orm';
+import {check, index, integer, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import {type TriggerDecision, triggerDecisionOutcomes} from '#core/entities/decision.js';
+import {pgTable} from './common.js';
+import {jobListenerMatcherKindEnum} from './job-listener-subscriptions.js';
+import {triggersReceivedEvents} from './received-events.js';
+
+const triggerDecisionSubscriptionKinds = ['trigger', 'listener'] as const;
+
+export const triggersDecisions = pgTable(
+  'decisions',
+  {
+    id: uuidv7PrimaryKey(),
+    receivedEventId: uuid('received_event_id')
+      .notNull()
+      .references(() => triggersReceivedEvents.id, {onDelete: 'cascade'}),
+    subscriptionKind: text('subscription_kind', {enum: triggerDecisionSubscriptionKinds}).notNull(),
+    subscriptionId: uuid('subscription_id').notNull(),
+    subscriptionName: text('subscription_name').notNull(),
+    workflowDefinitionId: uuid('workflow_definition_id'),
+    projectId: uuid('project_id'),
+    workflowRunId: uuid('workflow_run_id'),
+    jobId: uuid('job_id'),
+    matcherKind: jobListenerMatcherKindEnum('matcher_kind'),
+    matcherOrdinal: integer('matcher_ordinal'),
+    decision: text('decision', {enum: triggerDecisionOutcomes}).notNull(),
+    runId: uuid('run_id'),
+    runName: text('run_name'),
+    reason: text('reason'),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('triggers_decisions_event_subscription_unique').on(
+      table.receivedEventId,
+      table.subscriptionKind,
+      table.subscriptionId,
+    ),
+    index('triggers_decisions_run_idx').on(table.runId),
+    check(
+      'triggers_decisions_subscription_kind_ck',
+      sql`${table.subscriptionKind} IN ('trigger', 'listener')`,
+    ),
+  ],
+);
+
+export type TriggerDecisionDb = typeof triggersDecisions.$inferSelect;
+export type TriggerDecisionInsertDb = typeof triggersDecisions.$inferInsert;
+
+export function toTriggerDecision(row: TriggerDecisionDb): TriggerDecision {
+  return {
+    id: row.id,
+    receivedEventId: row.receivedEventId,
+    subscriptionKind: row.subscriptionKind,
+    subscriptionId: row.subscriptionId,
+    subscriptionName: row.subscriptionName,
+    workflowDefinitionId: row.workflowDefinitionId,
+    projectId: row.projectId,
+    workflowRunId: row.workflowRunId,
+    jobId: row.jobId,
+    matcherKind: row.matcherKind,
+    matcherOrdinal: row.matcherOrdinal,
+    decision: toTriggerDecisionOutcome(row.decision),
+    runId: row.runId,
+    runName: row.runName,
+    reason: row.reason,
+    createdAt: row.createdAt,
+  };
+}
+
+function toTriggerDecisionOutcome(decision: string): TriggerDecision['decision'] {
+  if (decision === 'errored') return 'dispatch-error';
+  if (decision === 'triggered' || decision === 'filter-error' || decision === 'dispatch-error') {
+    return decision;
+  }
+  return 'dispatch-error';
+}

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

@@ -0,0 +1,65 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {
+  index,
+  integer,
+  jsonb,
+  pgEnum,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from 'drizzle-orm/pg-core';
+import type {JobListenerSubscription} from '#core/entities/job-listener-subscription.js';
+import {pgTable} from './common.js';
+
+export const jobListenerMatcherKindEnum = pgEnum('triggers_job_listener_matcher_kind', [
+  'on',
+  'until',
+]);
+
+export const jobListenerSubscriptions = pgTable(
+  'job_listener_subscriptions',
+  {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    workflowRunId: uuid('workflow_run_id').notNull(),
+    jobId: uuid('job_id').notNull(),
+    kind: jobListenerMatcherKindEnum('kind').notNull(),
+    matcherOrdinal: integer('matcher_ordinal').notNull(),
+    source: text('source').notNull(),
+    event: text('event').notNull(),
+    config: jsonb('config').notNull().$type<Record<string, unknown>>(),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('triggers_job_listener_subscriptions_job_kind_ordinal_unique').on(
+      table.jobId,
+      table.kind,
+      table.matcherOrdinal,
+    ),
+    index('triggers_job_listener_subscriptions_match_idx').on(
+      table.workspaceId,
+      table.source,
+      table.event,
+    ),
+    index('triggers_job_listener_subscriptions_job_idx').on(table.jobId),
+  ],
+);
+
+export type JobListenerSubscriptionDb = typeof jobListenerSubscriptions.$inferSelect;
+export type JobListenerSubscriptionInsertDb = typeof jobListenerSubscriptions.$inferInsert;
+
+export function toJobListenerSubscription(row: JobListenerSubscriptionDb): JobListenerSubscription {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    workflowRunId: row.workflowRunId,
+    jobId: row.jobId,
+    kind: row.kind,
+    matcherOrdinal: row.matcherOrdinal,
+    source: row.source,
+    event: row.event,
+    config: row.config,
+    createdAt: row.createdAt,
+  };
+}

package/src/db/schema/outbox.ts

@@ -0,0 +1,4 @@
+import {createOutboxTable} from '@shipfox/node-outbox';
+import {pgTable} from './common.js';
+
+export const triggersOutbox = createOutboxTable(pgTable);

package/src/db/schema/received-events.test.ts

@@ -0,0 +1,135 @@
+import {eq} from 'drizzle-orm';
+import {db} from '../db.js';
+import {
+  type TriggerReceivedEventDb,
+  type TriggerReceivedEventInsertDb,
+  toTriggerReceivedEvent,
+  triggersReceivedEvents,
+} from './received-events.js';
+
+describe('toTriggerReceivedEvent', () => {
+  test('maps a fully populated row to the domain entity', () => {
+    const row: TriggerReceivedEventDb = {
+      id: '019e98ab-6656-7ca1-b9ad-1ca4442c479d',
+      eventRef: 'evt-1',
+      origin: 'integration',
+      workspaceId: '019e98ab-b90f-7265-b13c-8b441c991381',
+      provider: 'github',
+      source: 'github',
+      event: 'push',
+      deliveryId: 'delivery-1',
+      connectionId: '019e98ab-b90f-7265-b13c-8b441c991382',
+      connectionName: 'Acme Production',
+      outcome: 'routed',
+      matchedCount: 3,
+      payload: {ref: 'refs/heads/main'},
+      receivedAt: new Date('2026-06-09T10:00:00.000Z'),
+      processedAt: new Date('2026-06-09T10:00:01.000Z'),
+      createdAt: new Date('2026-06-09T10:00:02.000Z'),
+    };
+
+    const result = toTriggerReceivedEvent(row);
+
+    expect(result).toEqual({
+      id: row.id,
+      eventRef: 'evt-1',
+      origin: 'integration',
+      workspaceId: row.workspaceId,
+      provider: 'github',
+      source: 'github',
+      event: 'push',
+      deliveryId: 'delivery-1',
+      connectionId: row.connectionId,
+      connectionName: 'Acme Production',
+      outcome: 'routed',
+      matchedCount: 3,
+      payload: {ref: 'refs/heads/main'},
+      receivedAt: row.receivedAt,
+      processedAt: row.processedAt,
+      createdAt: row.createdAt,
+    });
+  });
+
+  test('passes through null delivery, connection, payload, and processed_at', () => {
+    const row: TriggerReceivedEventDb = {
+      id: '019e98ab-6656-7ca1-b9ad-1ca4442c479d',
+      eventRef: 'evt-2',
+      origin: 'manual',
+      workspaceId: '019e98ab-b90f-7265-b13c-8b441c991381',
+      provider: null,
+      source: 'manual',
+      event: 'fire',
+      deliveryId: null,
+      connectionId: null,
+      connectionName: null,
+      outcome: 'received',
+      matchedCount: 0,
+      payload: null,
+      receivedAt: new Date('2026-06-09T10:00:00.000Z'),
+      processedAt: null,
+      createdAt: new Date('2026-06-09T10:00:02.000Z'),
+    };
+
+    const result = toTriggerReceivedEvent(row);
+
+    expect(result.deliveryId).toBeNull();
+    expect(result.connectionId).toBeNull();
+    expect(result.connectionName).toBeNull();
+    expect(result.payload).toBeNull();
+    expect(result.processedAt).toBeNull();
+  });
+});
+
+describe('triggers_received_events schema', () => {
+  test('applies defaults and maps an inserted row', async () => {
+    const values: TriggerReceivedEventInsertDb = {
+      eventRef: crypto.randomUUID(),
+      origin: 'integration',
+      workspaceId: crypto.randomUUID(),
+      source: 'github',
+      event: 'push',
+      receivedAt: new Date(),
+    };
+
+    const [inserted] = await db()
+      .insert(triggersReceivedEvents)
+      .values(values)
+      .returning({id: triggersReceivedEvents.id});
+    if (!inserted) throw new Error('insert returned no rows');
+    const [row] = await db()
+      .select()
+      .from(triggersReceivedEvents)
+      .where(eq(triggersReceivedEvents.id, inserted.id));
+    if (!row) throw new Error('select returned no rows');
+    const result = toTriggerReceivedEvent(row);
+
+    expect(row.outcome).toBe('received');
+    expect(row.matchedCount).toBe(0);
+    expect(row.createdAt).toBeInstanceOf(Date);
+    expect(result).toMatchObject({
+      eventRef: values.eventRef,
+      origin: 'integration',
+      workspaceId: values.workspaceId,
+      source: 'github',
+      event: 'push',
+      outcome: 'received',
+      matchedCount: 0,
+    });
+  });
+
+  test('rejects a duplicate event_ref', async () => {
+    const values: TriggerReceivedEventInsertDb = {
+      eventRef: crypto.randomUUID(),
+      origin: 'integration',
+      workspaceId: crypto.randomUUID(),
+      source: 'github',
+      event: 'push',
+      receivedAt: new Date(),
+    };
+    await db().insert(triggersReceivedEvents).values(values);
+
+    const duplicate = db().insert(triggersReceivedEvents).values(values);
+
+    await expect(duplicate).rejects.toThrow();
+  });
+});

package/src/db/schema/received-events.ts

@@ -0,0 +1,93 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {index, integer, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import {
+  type TriggerReceivedEvent,
+  type TriggerReceivedEventSummary,
+  triggerEventOrigins,
+  triggerEventOutcomes,
+} from '#core/entities/received-event.js';
+import {pgTable} from './common.js';
+
+export const triggersReceivedEvents = pgTable(
+  'received_events',
+  {
+    id: uuidv7PrimaryKey(),
+    // Globally-unique idempotency key (the outbox event id), not the provider
+    // delivery id: delivery ids are only unique per provider and would collide
+    // across workspaces under the global event_ref unique index below.
+    eventRef: text('event_ref').notNull(),
+    origin: text('origin', {enum: triggerEventOrigins}).notNull(),
+    workspaceId: uuid('workspace_id').notNull(),
+    provider: text('provider'),
+    source: text('source').notNull(),
+    event: text('event').notNull(),
+    deliveryId: text('delivery_id'),
+    connectionId: uuid('connection_id'),
+    connectionName: text('connection_name'),
+    outcome: text('outcome', {enum: triggerEventOutcomes}).notNull().default('received'),
+    matchedCount: integer('matched_count').notNull().default(0),
+    payload: jsonb('payload').$type<Record<string, unknown>>(),
+    receivedAt: timestamp('received_at', {withTimezone: true}).notNull(),
+    processedAt: timestamp('processed_at', {withTimezone: true}),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('triggers_received_events_event_ref_unique').on(table.eventRef),
+    index('triggers_received_events_workspace_received_idx').on(
+      table.workspaceId,
+      table.receivedAt.desc(),
+    ),
+    index('triggers_received_events_prune_idx').on(table.createdAt),
+    // Back the workspace-scoped facet group-by (distinct source / event values).
+    index('triggers_received_events_workspace_source_idx').on(table.workspaceId, table.source),
+    index('triggers_received_events_workspace_event_idx').on(table.workspaceId, table.event),
+  ],
+);
+
+export type TriggerReceivedEventDb = typeof triggersReceivedEvents.$inferSelect;
+export type TriggerReceivedEventInsertDb = typeof triggersReceivedEvents.$inferInsert;
+
+export function toTriggerReceivedEvent(row: TriggerReceivedEventDb): TriggerReceivedEvent {
+  return {
+    id: row.id,
+    eventRef: row.eventRef,
+    origin: row.origin,
+    workspaceId: row.workspaceId,
+    provider: row.provider,
+    source: row.source,
+    event: row.event,
+    deliveryId: row.deliveryId,
+    connectionId: row.connectionId,
+    connectionName: row.connectionName,
+    outcome: row.outcome,
+    matchedCount: row.matchedCount,
+    payload: row.payload,
+    receivedAt: row.receivedAt,
+    processedAt: row.processedAt,
+    createdAt: row.createdAt,
+  };
+}
+
+export const triggerReceivedEventSummaryColumns = {
+  id: triggersReceivedEvents.id,
+  eventRef: triggersReceivedEvents.eventRef,
+  origin: triggersReceivedEvents.origin,
+  workspaceId: triggersReceivedEvents.workspaceId,
+  provider: triggersReceivedEvents.provider,
+  source: triggersReceivedEvents.source,
+  event: triggersReceivedEvents.event,
+  deliveryId: triggersReceivedEvents.deliveryId,
+  connectionId: triggersReceivedEvents.connectionId,
+  connectionName: triggersReceivedEvents.connectionName,
+  outcome: triggersReceivedEvents.outcome,
+  matchedCount: triggersReceivedEvents.matchedCount,
+  receivedAt: triggersReceivedEvents.receivedAt,
+  processedAt: triggersReceivedEvents.processedAt,
+  createdAt: triggersReceivedEvents.createdAt,
+} as const satisfies Record<keyof TriggerReceivedEventSummary, unknown>;
+
+export function toTriggerReceivedEventSummary(
+  row: Omit<TriggerReceivedEventDb, 'payload'>,
+): TriggerReceivedEventSummary {
+  return {...row};
+}