@shipfox/api-triggers 2.0.0

package/src/presentation/subscribers/on-definition-resolved.test.ts

@@ -0,0 +1,67 @@
+import type {DefinitionResolvedEvent} from '@shipfox/api-definitions-dto';
+import {eq} from 'drizzle-orm';
+import {db} from '#db/db.js';
+import {triggerSubscriptions} from '#db/schema/subscriptions.js';
+import {triggerSubscriptionFactory} from '#test/index.js';
+import {onDefinitionResolved} from './on-definition-resolved.js';
+
+function buildPayload(overrides: Partial<DefinitionResolvedEvent> = {}): DefinitionResolvedEvent {
+  return {
+    definitionId: crypto.randomUUID(),
+    projectId: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    configPath: '.shipfox/workflow.yml',
+    triggers: {onPush: {source: 'github', event: 'push'}},
+    ...overrides,
+  };
+}
+
+function listSubscriptions(workflowDefinitionId: string) {
+  return db()
+    .select()
+    .from(triggerSubscriptions)
+    .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+}
+
+describe('onDefinitionResolved', () => {
+  it('persists a subscription for each declared trigger', async () => {
+    const payload = buildPayload({
+      triggers: {
+        onPush: {source: 'github', event: 'push', with: {env: 'staging'}},
+        onManual: {source: 'manual', event: 'fire'},
+      },
+    });
+
+    await onDefinitionResolved(payload);
+
+    const rows = await listSubscriptions(payload.definitionId);
+    expect(rows.map((r) => r.name).sort()).toEqual(['onManual', 'onPush']);
+    expect(rows.find((r) => r.name === 'onPush')?.config).toEqual({with: {env: 'staging'}});
+  });
+
+  it('removes subscriptions whose trigger is no longer declared', async () => {
+    const workflowDefinitionId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workflowDefinitionId, name: 'onPush'});
+    await triggerSubscriptionFactory.create({workflowDefinitionId, name: 'stale'});
+
+    await onDefinitionResolved(
+      buildPayload({
+        definitionId: workflowDefinitionId,
+        triggers: {onPush: {source: 'github', event: 'push'}},
+      }),
+    );
+
+    const rows = await listSubscriptions(workflowDefinitionId);
+    expect(rows.map((r) => r.name)).toEqual(['onPush']);
+  });
+
+  it('clears every subscription when the definition declares no triggers', async () => {
+    const workflowDefinitionId = crypto.randomUUID();
+    await triggerSubscriptionFactory.create({workflowDefinitionId, name: 'onPush'});
+
+    await onDefinitionResolved(buildPayload({definitionId: workflowDefinitionId, triggers: {}}));
+
+    const rows = await listSubscriptions(workflowDefinitionId);
+    expect(rows).toHaveLength(0);
+  });
+});

package/src/presentation/subscribers/on-definition-resolved.ts

@@ -0,0 +1,11 @@
+import type {DefinitionResolvedEvent} from '@shipfox/api-definitions-dto';
+import {projectDefinitionTriggers} from '#db/subscriptions.js';
+
+export async function onDefinitionResolved(payload: DefinitionResolvedEvent): Promise<void> {
+  await projectDefinitionTriggers({
+    workspaceId: payload.workspaceId,
+    projectId: payload.projectId,
+    workflowDefinitionId: payload.definitionId,
+    triggers: payload.triggers,
+  });
+}

package/src/presentation/subscribers/on-integration-event-received.test.ts

@@ -0,0 +1,53 @@
+import type {IntegrationEventReceivedEvent} from '@shipfox/api-integration-core-dto';
+import type {DomainEvent} from '@shipfox/node-outbox';
+
+const dispatchIntegrationEvent = vi.fn();
+
+vi.mock('#core/dispatch-integration-event.js', () => ({
+  dispatchIntegrationEvent: (...args: unknown[]) => dispatchIntegrationEvent(...args),
+}));
+
+// Import after mocks so the subscriber sees the spy.
+const {onIntegrationEventReceived} = await import('./on-integration-event-received.js');
+
+describe('onIntegrationEventReceived', () => {
+  beforeEach(() => {
+    dispatchIntegrationEvent.mockReset();
+  });
+
+  test('passes the integration envelope to the core dispatcher', async () => {
+    const receivedAt = '2026-06-21T03:20:00.000Z';
+    const envelope: IntegrationEventReceivedEvent = {
+      provider: 'github',
+      source: 'github',
+      event: 'push',
+      workspaceId: crypto.randomUUID(),
+      connectionId: crypto.randomUUID(),
+      connectionName: 'Acme Production',
+      deliveryId: crypto.randomUUID(),
+      receivedAt,
+      payload: {ref: 'main', headCommitSha: 'abc123'},
+    };
+    const event: DomainEvent<IntegrationEventReceivedEvent> = {
+      id: crypto.randomUUID(),
+      type: 'integrations.event.received',
+      createdAt: new Date(),
+      payload: envelope,
+    };
+
+    await onIntegrationEventReceived(envelope, event);
+
+    expect(dispatchIntegrationEvent).toHaveBeenCalledWith({
+      eventRef: event.id,
+      workspaceId: envelope.workspaceId,
+      provider: envelope.provider,
+      source: envelope.source,
+      event: envelope.event,
+      deliveryId: envelope.deliveryId,
+      connectionId: envelope.connectionId,
+      connectionName: envelope.connectionName,
+      payload: envelope.payload,
+      receivedAt: new Date(receivedAt),
+    });
+  });
+});

package/src/presentation/subscribers/on-integration-event-received.ts

@@ -0,0 +1,21 @@
+import type {IntegrationEventReceivedEvent} from '@shipfox/api-integration-core-dto';
+import type {DomainEvent} from '@shipfox/node-outbox';
+import {dispatchIntegrationEvent} from '#core/dispatch-integration-event.js';
+
+export async function onIntegrationEventReceived(
+  envelope: IntegrationEventReceivedEvent,
+  event: DomainEvent<IntegrationEventReceivedEvent>,
+): Promise<void> {
+  await dispatchIntegrationEvent({
+    eventRef: event.id,
+    workspaceId: envelope.workspaceId,
+    provider: envelope.provider,
+    source: envelope.source,
+    event: envelope.event,
+    deliveryId: envelope.deliveryId,
+    connectionId: envelope.connectionId,
+    connectionName: envelope.connectionName ?? null,
+    payload: envelope.payload,
+    receivedAt: new Date(envelope.receivedAt),
+  });
+}

package/src/presentation/subscribers/on-job-activated.ts

@@ -0,0 +1,14 @@
+import type {WorkflowsJobActivatedEventDto} from '@shipfox/api-workflows-dto';
+import {projectJobListenerSubscriptions} from '#db/job-listener-subscriptions.js';
+
+export async function onJobActivated(payload: WorkflowsJobActivatedEventDto): Promise<void> {
+  if (payload.mode !== 'listening') return;
+
+  await projectJobListenerSubscriptions({
+    workspaceId: payload.workspaceId,
+    workflowRunId: payload.workflowRunId,
+    jobId: payload.jobId,
+    on: payload.on,
+    until: payload.until,
+  });
+}

package/src/presentation/subscribers/on-job-terminated.ts

@@ -0,0 +1,6 @@
+import type {WorkflowsJobTerminatedEventDto} from '@shipfox/api-workflows-dto';
+import {removeJobListenerSubscriptionsForJob} from '#db/job-listener-subscriptions.js';
+
+export async function onJobTerminated(payload: WorkflowsJobTerminatedEventDto): Promise<void> {
+  await removeJobListenerSubscriptionsForJob(payload.jobId);
+}

package/src/temporal/activities/drain-cron-batch.ts

@@ -0,0 +1,20 @@
+import {Context} from '@temporalio/activity';
+import {config} from '#config.js';
+import {type CronDrainSummary, drainDueCronSchedules} from '#core/drain-cron-schedules.js';
+
+export async function drainCronBatchActivity(): Promise<CronDrainSummary> {
+  const ctx = Context.current();
+  return await drainDueCronSchedules({
+    batchSize: config.TRIGGER_CRON_CLAIM_BATCH,
+    jitterWindowSeconds: config.TRIGGER_CRON_JITTER_WINDOW_SECONDS,
+    onScheduleProcessed: () => ctx.heartbeat(),
+  });
+}
+
+// Read at runtime rather than baked into the cron workflow's start args: a start arg
+// would freeze fanout at first launch (a restart re-skips the already-running workflow),
+// so an activity read lets a config change take effect on the next tick after a worker
+// restart, consistent with how TRIGGER_CRON_CLAIM_BATCH is read in the drain activity.
+export function readCronFanoutActivity(): Promise<number> {
+  return Promise.resolve(config.TRIGGER_CRON_FANOUT);
+}

package/src/temporal/activities/index.ts

@@ -0,0 +1,15 @@
+import {drainCronBatchActivity, readCronFanoutActivity} from './drain-cron-batch.js';
+import {pruneTriggerEventsActivity} from './prune-trigger-events.js';
+
+export function createTriggersMaintenanceActivities() {
+  return {
+    pruneTriggerEventsActivity,
+  };
+}
+
+export function createTriggersCronActivities() {
+  return {
+    drainCronBatchActivity,
+    readCronFanoutActivity,
+  };
+}

package/src/temporal/activities/prune-trigger-events.test.ts

@@ -0,0 +1,78 @@
+import {randomUUID} from 'node:crypto';
+import {eq} from 'drizzle-orm';
+import {db} from '#db/db.js';
+import {triggersDecisions} from '#db/schema/decisions.js';
+import {triggersReceivedEvents} from '#db/schema/received-events.js';
+import {pruneTriggerEventsActivity} from './prune-trigger-events.js';
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+// The prune is global in a shared test DB, so assert by id instead of truncating.
+async function insertEvent(createdAt: Date): Promise<string> {
+  const id = randomUUID();
+  await db().insert(triggersReceivedEvents).values({
+    id,
+    eventRef: randomUUID(),
+    origin: 'integration',
+    workspaceId: randomUUID(),
+    source: 'github',
+    event: 'push',
+    receivedAt: createdAt,
+    createdAt,
+  });
+  return id;
+}
+
+async function insertDecision(receivedEventId: string): Promise<string> {
+  const id = randomUUID();
+  await db().insert(triggersDecisions).values({
+    id,
+    receivedEventId,
+    subscriptionKind: 'trigger',
+    subscriptionId: randomUUID(),
+    subscriptionName: 'Deploy production',
+    workflowDefinitionId: randomUUID(),
+    projectId: randomUUID(),
+    decision: 'triggered',
+  });
+  return id;
+}
+
+async function eventExists(id: string): Promise<boolean> {
+  const rows = await db()
+    .select({id: triggersReceivedEvents.id})
+    .from(triggersReceivedEvents)
+    .where(eq(triggersReceivedEvents.id, id));
+  return rows.length > 0;
+}
+
+async function decisionExists(id: string): Promise<boolean> {
+  const rows = await db()
+    .select({id: triggersDecisions.id})
+    .from(triggersDecisions)
+    .where(eq(triggersDecisions.id, id));
+  return rows.length > 0;
+}
+
+describe('pruneTriggerEventsActivity', () => {
+  it('deletes events older than the retention window and cascades their decisions', async () => {
+    const oldId = await insertEvent(new Date(Date.now() - 60 * DAY_MS));
+    const decisionId = await insertDecision(oldId);
+    const recentId = await insertEvent(new Date());
+
+    const result = await pruneTriggerEventsActivity();
+
+    expect(result.deleted).toBeGreaterThanOrEqual(1);
+    expect(await eventExists(oldId)).toBe(false);
+    expect(await decisionExists(decisionId)).toBe(false);
+    expect(await eventExists(recentId)).toBe(true);
+  });
+
+  it('keeps events within the retention window', async () => {
+    const recentId = await insertEvent(new Date());
+
+    await pruneTriggerEventsActivity();
+
+    expect(await eventExists(recentId)).toBe(true);
+  });
+});

package/src/temporal/activities/prune-trigger-events.ts

@@ -0,0 +1,9 @@
+import {config} from '#config.js';
+import {pruneTriggerEvents} from '#db/received-events.js';
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+export async function pruneTriggerEventsActivity(): Promise<{deleted: number}> {
+  const olderThan = new Date(Date.now() - config.TRIGGER_EVENT_RETENTION_DAYS * MS_PER_DAY);
+  return await pruneTriggerEvents({olderThan});
+}

package/src/temporal/constants.ts

@@ -0,0 +1,7 @@
+export const TRIGGERS_MAINTENANCE_TASK_QUEUE = 'triggers-maintenance';
+
+/**
+ * Dedicated queue for the minute cron tick, so bursty cron-fire load and hourly
+ * maintenance load scale independently.
+ */
+export const TRIGGERS_CRON_TASK_QUEUE = 'triggers-cron';

package/src/temporal/workflows/cron-tick-cron.ts

@@ -0,0 +1,56 @@
+import {log, proxyActivities} from '@temporalio/workflow';
+import type {createTriggersCronActivities} from '../activities/index.js';
+
+// Upper bound on per-tick parallelism. A misconfigured TRIGGER_CRON_FANOUT (e.g. a
+// pasted large number) is clamped to this rather than spawning an unbounded fan-out
+// that could stall the tick, so one config mistake cannot stop cron firing.
+const MAX_CRON_FANOUT = 32;
+
+const {drainCronBatchActivity, readCronFanoutActivity} = proxyActivities<
+  ReturnType<typeof createTriggersCronActivities>
+>({
+  // Throughput is governed by fanout and claim batch, not a per-tick time budget, so
+  // give the batch drain plenty of room.
+  startToCloseTimeout: '5 minutes',
+  // The drain heartbeats once per processed schedule, so a hung run stops heartbeating
+  // well before the start-to-close timeout. Fail it within a minute (rather than after
+  // five) so its FOR UPDATE SKIP LOCKED locks release and the next tick re-claims those
+  // rows.
+  heartbeatTimeout: '1 minute',
+  // No activity retry: the drain is not batch-idempotent across retries. A retry after a
+  // committed advance would claim a fresh due batch and fire beyond the
+  // fanout * TRIGGER_CRON_CLAIM_BATCH per-tick ceiling. Whole-activity failures roll the
+  // batch back (rows stay due) and the once-per-minute cron schedule is the retry.
+  retry: {maximumAttempts: 1},
+});
+
+/**
+ * Fires once a minute (Temporal never overlaps a cron workflow with itself, so a slow
+ * tick delays the next rather than doubling it). Reads the current fanout and runs that
+ * many drain activities; Temporal spreads them across the worker fleet, and `SKIP LOCKED`
+ * keeps their claims disjoint. The per-tick fire ceiling is
+ * `fanout * TRIGGER_CRON_CLAIM_BATCH`.
+ */
+export async function cronTickCron(): Promise<void> {
+  const fanout = await readCronFanoutActivity();
+  const requested = Number.isInteger(fanout) && fanout > 0 ? fanout : 1;
+  const parallelism = Math.min(requested, MAX_CRON_FANOUT);
+  if (parallelism < requested) {
+    log.warn('Cron tick fanout exceeds the maximum; clamping', {
+      requested,
+      max: MAX_CRON_FANOUT,
+    });
+  }
+
+  const summaries = await Promise.all(
+    Array.from({length: parallelism}, () => drainCronBatchActivity()),
+  );
+
+  const fired = summaries.reduce((total, summary) => total + summary.fired, 0);
+  const errored = summaries.reduce((total, summary) => total + summary.errored, 0);
+  const retried = summaries.reduce((total, summary) => total + summary.retried, 0);
+
+  if (fired > 0 || errored > 0 || retried > 0) {
+    log.info('Cron tick drained schedules', {fired, errored, retried});
+  }
+}

package/src/temporal/workflows/index.ts

@@ -0,0 +1,2 @@
+export {cronTickCron} from './cron-tick-cron.js';
+export {pruneTriggerEventsCron} from './prune-trigger-events-cron.js';

package/src/temporal/workflows/prune-trigger-events-cron.ts

@@ -0,0 +1,17 @@
+import {log, proxyActivities} from '@temporalio/workflow';
+import type {createTriggersMaintenanceActivities} from '../activities/index.js';
+
+const {pruneTriggerEventsActivity} = proxyActivities<
+  ReturnType<typeof createTriggersMaintenanceActivities>
+>({
+  startToCloseTimeout: '5 minutes',
+  // Let persistent failures fall through so the next hourly run retries with a fresh cutoff.
+  retry: {maximumAttempts: 5},
+});
+
+export async function pruneTriggerEventsCron(): Promise<void> {
+  const {deleted} = await pruneTriggerEventsActivity();
+  if (deleted > 0) {
+    log.info('Pruned trigger received events', {deleted});
+  }
+}

package/test/env.ts

@@ -0,0 +1,8 @@
+process.env.POSTGRES_HOST ??= 'localhost';
+process.env.POSTGRES_PORT ??= '5432';
+process.env.POSTGRES_USERNAME ??= 'shipfox';
+process.env.POSTGRES_PASSWORD ??= 'password';
+process.env.POSTGRES_DATABASE = 'api_test';
+process.env.POSTGRES_MAX_CONNECTIONS ??= '5';
+process.env.SECRETS_ENCRYPTION_KEK = 'ZmVkY2JhOTg3NjU0MzIxMGZlZGNiYTk4NzY1NDMyMTA=';
+process.env.TZ = 'UTC';

package/test/factories/cron-schedule.ts

@@ -0,0 +1,34 @@
+import {Factory} from 'fishery';
+import type {CronSchedule} from '#core/entities/cron-schedule.js';
+import {db} from '#db/db.js';
+import {toCronSchedule, triggersCronSchedules} from '#db/schema/cron-schedules.js';
+
+export const cronScheduleFactory = Factory.define<CronSchedule>(({onCreate}) => {
+  onCreate(async (schedule) => {
+    const [row] = await db()
+      .insert(triggersCronSchedules)
+      .values({
+        subscriptionId: schedule.subscriptionId,
+        workspaceId: schedule.workspaceId,
+        cronExpression: schedule.cronExpression,
+        timezone: schedule.timezone,
+        nextFireAt: schedule.nextFireAt,
+        lastFiredAt: schedule.lastFiredAt,
+      })
+      .returning();
+    if (!row) throw new Error('Insert returned no rows');
+    return toCronSchedule(row);
+  });
+
+  return {
+    subscriptionId: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    cronExpression: '0 2 * * *',
+    timezone: 'UTC',
+    // Default well into the future so a schedule is only "due" when a test says so.
+    nextFireAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
+    lastFiredAt: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+});

package/test/factories/decision.ts

@@ -0,0 +1,49 @@
+import {Factory} from 'fishery';
+import type {TriggerDecision} from '#core/entities/decision.js';
+import {db} from '#db/db.js';
+import {toTriggerDecision, triggersDecisions} from '#db/schema/decisions.js';
+
+export const decisionFactory = Factory.define<TriggerDecision>(({onCreate}) => {
+  onCreate(async (decision) => {
+    const [row] = await db()
+      .insert(triggersDecisions)
+      .values({
+        receivedEventId: decision.receivedEventId,
+        subscriptionKind: decision.subscriptionKind,
+        subscriptionId: decision.subscriptionId,
+        subscriptionName: decision.subscriptionName,
+        workflowDefinitionId: decision.workflowDefinitionId,
+        projectId: decision.projectId,
+        workflowRunId: decision.workflowRunId,
+        jobId: decision.jobId,
+        matcherKind: decision.matcherKind,
+        matcherOrdinal: decision.matcherOrdinal,
+        decision: decision.decision,
+        runId: decision.runId,
+        runName: decision.runName,
+        reason: decision.reason,
+      })
+      .returning();
+    if (!row) throw new Error('Insert returned no rows');
+    return toTriggerDecision(row);
+  });
+
+  return {
+    id: crypto.randomUUID(),
+    receivedEventId: crypto.randomUUID(),
+    subscriptionKind: 'trigger',
+    subscriptionId: crypto.randomUUID(),
+    subscriptionName: 'Deploy production',
+    workflowDefinitionId: crypto.randomUUID(),
+    projectId: crypto.randomUUID(),
+    workflowRunId: null,
+    jobId: null,
+    matcherKind: null,
+    matcherOrdinal: null,
+    decision: 'triggered',
+    runId: crypto.randomUUID(),
+    runName: 'deploy',
+    reason: null,
+    createdAt: new Date(),
+  };
+});

package/test/factories/job-listener-subscription.ts

@@ -0,0 +1,42 @@
+import {Factory} from 'fishery';
+import type {JobListenerSubscription} from '#core/entities/job-listener-subscription.js';
+import {db} from '#db/db.js';
+import {
+  jobListenerSubscriptions,
+  toJobListenerSubscription,
+} from '#db/schema/job-listener-subscriptions.js';
+
+export const jobListenerSubscriptionFactory = Factory.define<JobListenerSubscription>(
+  ({sequence, onCreate}) => {
+    onCreate(async (subscription) => {
+      const [row] = await db()
+        .insert(jobListenerSubscriptions)
+        .values({
+          workspaceId: subscription.workspaceId,
+          workflowRunId: subscription.workflowRunId,
+          jobId: subscription.jobId,
+          kind: subscription.kind,
+          matcherOrdinal: subscription.matcherOrdinal,
+          source: subscription.source,
+          event: subscription.event,
+          config: subscription.config,
+        })
+        .returning();
+      if (!row) throw new Error('Insert returned no rows');
+      return toJobListenerSubscription(row);
+    });
+
+    return {
+      id: crypto.randomUUID(),
+      workspaceId: crypto.randomUUID(),
+      workflowRunId: crypto.randomUUID(),
+      jobId: crypto.randomUUID(),
+      kind: 'on',
+      matcherOrdinal: sequence,
+      source: 'github',
+      event: 'push',
+      config: {},
+      createdAt: new Date(),
+    };
+  },
+);

package/test/factories/received-event.ts

@@ -0,0 +1,49 @@
+import {Factory} from 'fishery';
+import type {TriggerReceivedEvent} from '#core/entities/received-event.js';
+import {db} from '#db/db.js';
+import {toTriggerReceivedEvent, triggersReceivedEvents} from '#db/schema/received-events.js';
+
+export const receivedEventFactory = Factory.define<TriggerReceivedEvent>(({sequence, onCreate}) => {
+  onCreate(async (event) => {
+    const [row] = await db()
+      .insert(triggersReceivedEvents)
+      .values({
+        eventRef: event.eventRef,
+        origin: event.origin,
+        workspaceId: event.workspaceId,
+        provider: event.provider,
+        source: event.source,
+        event: event.event,
+        deliveryId: event.deliveryId,
+        connectionId: event.connectionId,
+        connectionName: event.connectionName,
+        outcome: event.outcome,
+        matchedCount: event.matchedCount,
+        payload: event.payload,
+        receivedAt: event.receivedAt,
+        processedAt: event.processedAt,
+      })
+      .returning();
+    if (!row) throw new Error('Insert returned no rows');
+    return toTriggerReceivedEvent(row);
+  });
+
+  return {
+    id: crypto.randomUUID(),
+    eventRef: crypto.randomUUID(),
+    origin: 'integration',
+    workspaceId: crypto.randomUUID(),
+    provider: 'github',
+    source: 'github',
+    event: 'push',
+    deliveryId: crypto.randomUUID(),
+    connectionId: crypto.randomUUID(),
+    connectionName: 'Acme Production',
+    outcome: 'routed',
+    matchedCount: 1,
+    payload: {ref: `refs/heads/main-${sequence}`},
+    receivedAt: new Date(),
+    processedAt: new Date(),
+    createdAt: new Date(),
+  };
+});

package/test/factories/subscription.ts

@@ -0,0 +1,38 @@
+import {Factory} from 'fishery';
+import type {TriggerSubscription} from '#core/entities/subscription.js';
+import {db} from '#db/db.js';
+import {toTriggerSubscription, triggerSubscriptions} from '#db/schema/subscriptions.js';
+
+export const triggerSubscriptionFactory = Factory.define<TriggerSubscription>(
+  ({sequence, onCreate}) => {
+    onCreate(async (subscription) => {
+      const [row] = await db()
+        .insert(triggerSubscriptions)
+        .values({
+          workspaceId: subscription.workspaceId,
+          projectId: subscription.projectId,
+          workflowDefinitionId: subscription.workflowDefinitionId,
+          name: subscription.name,
+          source: subscription.source,
+          event: subscription.event,
+          config: subscription.config,
+        })
+        .returning();
+      if (!row) throw new Error('Insert returned no rows');
+      return toTriggerSubscription(row);
+    });
+
+    return {
+      id: crypto.randomUUID(),
+      workspaceId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      workflowDefinitionId: crypto.randomUUID(),
+      name: `trigger_${sequence}`,
+      source: 'manual',
+      event: 'fire',
+      config: {},
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+  },
+);

package/test/globalSetup.ts

@@ -0,0 +1,20 @@
+import './env.js';
+import {runMigrations} from '@shipfox/node-drizzle';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+import {sql} from 'drizzle-orm';
+import {closeDb, db, migrationsPath} from '#db/index.js';
+
+export async function setup() {
+  createPostgresClient();
+
+  await runMigrations(db(), migrationsPath, '__drizzle_migrations_triggers');
+  await db().execute(sql`TRUNCATE triggers_job_listener_subscriptions CASCADE`);
+  await db().execute(sql`TRUNCATE triggers_cron_schedules CASCADE`);
+  await db().execute(sql`TRUNCATE triggers_subscriptions CASCADE`);
+  await db().execute(sql`TRUNCATE triggers_outbox CASCADE`);
+  await db().execute(sql`TRUNCATE triggers_received_events CASCADE`);
+  await db().execute(sql`TRUNCATE triggers_decisions CASCADE`);
+
+  closeDb();
+  await closePostgresClient();
+}

package/test/index.ts

@@ -0,0 +1,5 @@
+export {cronScheduleFactory} from './factories/cron-schedule.js';
+export {decisionFactory} from './factories/decision.js';
+export {jobListenerSubscriptionFactory} from './factories/job-listener-subscription.js';
+export {receivedEventFactory} from './factories/received-event.js';
+export {triggerSubscriptionFactory} from './factories/subscription.js';

package/test/setup.ts

@@ -0,0 +1,17 @@
+import './env.js';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+import {afterAll, afterEach, beforeAll, vi} from '@shipfox/vitest/vi';
+import {closeDb} from '#db/index.js';
+
+beforeAll(() => {
+  createPostgresClient();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+afterAll(async () => {
+  closeDb();
+  await closePostgresClient();
+});