@shipfox/api-triggers 2.0.0

package/src/db/schema/subscriptions.ts

@@ -0,0 +1,46 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {index, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import type {TriggerSubscription} from '#core/entities/subscription.js';
+import {pgTable} from './common.js';
+
+export const triggerSubscriptions = pgTable(
+  'subscriptions',
+  {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    projectId: uuid('project_id').notNull(),
+    workflowDefinitionId: uuid('workflow_definition_id').notNull(),
+    name: text('name').notNull(),
+    source: text('source').notNull(),
+    event: text('event').notNull(),
+    config: jsonb('config').notNull(),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('triggers_subscriptions_definition_name_unique').on(
+      table.workflowDefinitionId,
+      table.name,
+    ),
+    index('triggers_subscriptions_match_idx').on(table.workspaceId, table.source, table.event),
+    index('triggers_subscriptions_definition_idx').on(table.workflowDefinitionId),
+  ],
+);
+
+export type TriggerSubscriptionDb = typeof triggerSubscriptions.$inferSelect;
+export type TriggerSubscriptionInsertDb = typeof triggerSubscriptions.$inferInsert;
+
+export function toTriggerSubscription(row: TriggerSubscriptionDb): TriggerSubscription {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    projectId: row.projectId,
+    workflowDefinitionId: row.workflowDefinitionId,
+    name: row.name,
+    source: row.source,
+    event: row.event,
+    config: row.config as Record<string, unknown>,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}

package/src/db/subscriptions.test.ts

@@ -0,0 +1,340 @@
+import {eq} from 'drizzle-orm';
+import {db} from './db.js';
+import {triggerSubscriptions} from './schema/subscriptions.js';
+import {
+  deleteSubscriptionsForDefinition,
+  findMatchingSubscriptions,
+  getManualSubscriptionByDefinitionId,
+  getTriggerSubscriptionById,
+  projectDefinitionTriggers,
+} from './subscriptions.js';
+
+describe('projectDefinitionTriggers', () => {
+  let workspaceId: string;
+  let projectId: string;
+  let workflowDefinitionId: string;
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    projectId = crypto.randomUUID();
+    workflowDefinitionId = crypto.randomUUID();
+  });
+
+  test('inserts a row for each declared trigger', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_demand: {source: 'manual', event: 'fire'},
+        on_push: {
+          source: 'github',
+          event: 'push',
+          with: {branch: 'main'},
+          filter: 'event.ref == "refs/heads/main"',
+        },
+      },
+    });
+
+    const rows = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+
+    expect(rows).toHaveLength(2);
+    const manual = rows.find((r) => r.name === 'on_demand');
+    expect(manual?.source).toBe('manual');
+    expect(manual?.event).toBe('fire');
+    expect(manual?.config).toEqual({});
+    const push = rows.find((r) => r.name === 'on_push');
+    expect(push?.source).toBe('github');
+    expect(push?.event).toBe('push');
+    expect(push?.config).toEqual({
+      with: {branch: 'main'},
+      filter: 'event.ref == "refs/heads/main"',
+    });
+  });
+
+  test('removes rows whose trigger name is no longer in the map', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_demand: {source: 'manual', event: 'fire'},
+        on_push: {source: 'github', event: 'push'},
+      },
+    });
+
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_demand: {source: 'manual', event: 'fire'},
+      },
+    });
+
+    const rows = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+
+    expect(rows.map((r) => r.name)).toEqual(['on_demand']);
+  });
+
+  test('updates rows in place when a trigger name persists across reconciliations', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_push: {source: 'github', event: 'push', with: {branch: 'main'}},
+      },
+    });
+    const before = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+    const originalId = before[0]?.id;
+
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_push: {source: 'github', event: 'push', with: {branch: 'develop'}},
+      },
+    });
+
+    const after = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+    expect(after).toHaveLength(1);
+    expect(after[0]?.id).toBe(originalId);
+    expect(after[0]?.config).toEqual({with: {branch: 'develop'}});
+  });
+
+  test('empty triggers map removes all rows for the definition', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_demand: {source: 'manual', event: 'fire'},
+      },
+    });
+
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {},
+    });
+
+    const rows = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+    expect(rows).toHaveLength(0);
+  });
+});
+
+describe('deleteSubscriptionsForDefinition', () => {
+  test('deletes every row for the definition', async () => {
+    const workflowDefinitionId = crypto.randomUUID();
+    await projectDefinitionTriggers({
+      workspaceId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      workflowDefinitionId,
+      triggers: {
+        a: {source: 'manual', event: 'fire'},
+        b: {source: 'github', event: 'push'},
+      },
+    });
+
+    const deletedCount = await deleteSubscriptionsForDefinition({workflowDefinitionId});
+
+    expect(deletedCount).toBe(2);
+    const remaining = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+    expect(remaining).toHaveLength(0);
+  });
+});
+
+describe('findMatchingSubscriptions', () => {
+  let workspaceId: string;
+  let projectId: string;
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    projectId = crypto.randomUUID();
+  });
+
+  test('returns subscriptions matching workspace, source, event', async () => {
+    const workflowDefinitionId = crypto.randomUUID();
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {
+        on_push: {source: 'github', event: 'push'},
+        on_demand: {source: 'manual', event: 'fire'},
+      },
+    });
+
+    const matches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0]?.name).toBe('on_push');
+  });
+
+  test('matches connection-specific sources, not the provider id', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId: crypto.randomUUID(),
+      triggers: {
+        prod_error: {source: 'sentry_prod', event: 'issue.created'},
+        staging_error: {source: 'sentry_staging', event: 'issue.created'},
+      },
+    });
+
+    const prodMatches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'sentry_prod',
+      event: 'issue.created',
+    });
+    const stagingMatches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'sentry_staging',
+      event: 'issue.created',
+    });
+    const providerMatches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'sentry',
+      event: 'issue.created',
+    });
+
+    expect(prodMatches.map((match) => match.name)).toEqual(['prod_error']);
+    expect(stagingMatches.map((match) => match.name)).toEqual(['staging_error']);
+    expect(providerMatches).toHaveLength(0);
+  });
+
+  test('matches across projects within the workspace, without project scoping', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId: crypto.randomUUID(),
+      triggers: {on_push: {source: 'github', event: 'push'}},
+    });
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId: crypto.randomUUID(),
+      workflowDefinitionId: crypto.randomUUID(),
+      triggers: {on_push: {source: 'github', event: 'push'}},
+    });
+
+    const matches = await findMatchingSubscriptions({
+      workspaceId,
+      source: 'github',
+      event: 'push',
+    });
+
+    expect(matches).toHaveLength(2);
+  });
+
+  test('does not return rows from other workspaces', async () => {
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId: crypto.randomUUID(),
+      triggers: {on_push: {source: 'github', event: 'push'}},
+    });
+
+    const otherWorkspace = await findMatchingSubscriptions({
+      workspaceId: crypto.randomUUID(),
+      source: 'github',
+      event: 'push',
+    });
+
+    expect(otherWorkspace).toHaveLength(0);
+  });
+});
+
+describe('getTriggerSubscriptionById', () => {
+  test('returns the row when found', async () => {
+    const workspaceId = crypto.randomUUID();
+    const projectId = crypto.randomUUID();
+    const workflowDefinitionId = crypto.randomUUID();
+    await projectDefinitionTriggers({
+      workspaceId,
+      projectId,
+      workflowDefinitionId,
+      triggers: {on_demand: {source: 'manual', event: 'fire'}},
+    });
+    const [row] = await db()
+      .select()
+      .from(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId));
+
+    const found = await getTriggerSubscriptionById(row?.id ?? '');
+
+    expect(found?.id).toBe(row?.id);
+    expect(found?.source).toBe('manual');
+    expect(found?.event).toBe('fire');
+  });
+
+  test('returns undefined when not found', async () => {
+    const found = await getTriggerSubscriptionById(crypto.randomUUID());
+
+    expect(found).toBeUndefined();
+  });
+});
+
+describe('getManualSubscriptionByDefinitionId', () => {
+  test('returns the manual subscription declared by a definition', async () => {
+    const workflowDefinitionId = crypto.randomUUID();
+    await projectDefinitionTriggers({
+      workspaceId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      workflowDefinitionId,
+      triggers: {
+        on_demand: {source: 'manual', event: 'fire'},
+        on_push: {source: 'github', event: 'push'},
+      },
+    });
+
+    const found = await getManualSubscriptionByDefinitionId(workflowDefinitionId);
+
+    expect(found?.source).toBe('manual');
+    expect(found?.name).toBe('on_demand');
+  });
+
+  test('returns undefined when the definition has no manual trigger', async () => {
+    const workflowDefinitionId = crypto.randomUUID();
+    await projectDefinitionTriggers({
+      workspaceId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      workflowDefinitionId,
+      triggers: {on_push: {source: 'github', event: 'push'}},
+    });
+
+    const found = await getManualSubscriptionByDefinitionId(workflowDefinitionId);
+
+    expect(found).toBeUndefined();
+  });
+
+  test('returns undefined when no rows exist for the definition', async () => {
+    const found = await getManualSubscriptionByDefinitionId(crypto.randomUUID());
+
+    expect(found).toBeUndefined();
+  });
+});

package/src/db/subscriptions.ts

@@ -0,0 +1,179 @@
+import type {TriggerDto} from '@shipfox/api-definitions-dto';
+import {and, eq, inArray, notInArray} from 'drizzle-orm';
+import type {TriggerSubscription} from '#core/entities/subscription.js';
+import {deleteCronScheduleForSubscription, syncCronSchedule} from './cron-schedules.js';
+import {db, type Executor, type Tx} from './db.js';
+import {toTriggerSubscription, triggerSubscriptions} from './schema/subscriptions.js';
+
+export interface ProjectDefinitionTriggersParams {
+  tx?: Tx | undefined;
+  workspaceId: string;
+  projectId: string;
+  workflowDefinitionId: string;
+  triggers: Record<string, TriggerDto>;
+}
+
+export async function projectDefinitionTriggers(
+  params: ProjectDefinitionTriggersParams,
+): Promise<void> {
+  const work = async (tx: Tx): Promise<void> => {
+    const entries = Object.entries(params.triggers);
+    const keepNames = entries.map(([name]) => name);
+
+    if (keepNames.length === 0) {
+      await tx
+        .delete(triggerSubscriptions)
+        .where(eq(triggerSubscriptions.workflowDefinitionId, params.workflowDefinitionId));
+      return;
+    }
+
+    await tx
+      .delete(triggerSubscriptions)
+      .where(
+        and(
+          eq(triggerSubscriptions.workflowDefinitionId, params.workflowDefinitionId),
+          notInArray(triggerSubscriptions.name, keepNames),
+        ),
+      );
+
+    for (const [name, trigger] of entries) {
+      const config: Record<string, unknown> = {};
+      if (trigger.with !== undefined) config.with = trigger.with;
+      if (trigger.filter !== undefined) config.filter = trigger.filter;
+
+      const [upserted] = await tx
+        .insert(triggerSubscriptions)
+        .values({
+          workspaceId: params.workspaceId,
+          projectId: params.projectId,
+          workflowDefinitionId: params.workflowDefinitionId,
+          name,
+          source: trigger.source,
+          event: trigger.event,
+          config,
+        })
+        .onConflictDoUpdate({
+          target: [triggerSubscriptions.workflowDefinitionId, triggerSubscriptions.name],
+          set: {
+            workspaceId: params.workspaceId,
+            projectId: params.projectId,
+            source: trigger.source,
+            event: trigger.event,
+            config,
+            updatedAt: new Date(),
+          },
+        })
+        .returning({id: triggerSubscriptions.id});
+      if (!upserted) throw new Error('Trigger subscription upsert returned no rows');
+
+      if (trigger.source === 'cron') {
+        await syncCronSchedule({
+          tx,
+          subscriptionId: upserted.id,
+          workspaceId: params.workspaceId,
+          triggerConfig: trigger.config,
+        });
+      } else {
+        await deleteCronScheduleForSubscription({tx, subscriptionId: upserted.id});
+      }
+    }
+  };
+
+  if (params.tx) {
+    await work(params.tx);
+    return;
+  }
+  await db().transaction(work);
+}
+
+export interface DeleteSubscriptionsForDefinitionParams {
+  tx?: Tx | undefined;
+  workflowDefinitionId: string;
+}
+
+export async function deleteSubscriptionsForDefinition(
+  params: DeleteSubscriptionsForDefinitionParams,
+): Promise<number> {
+  const work = async (executor: Executor): Promise<number> => {
+    const rows = await executor
+      .delete(triggerSubscriptions)
+      .where(eq(triggerSubscriptions.workflowDefinitionId, params.workflowDefinitionId))
+      .returning({id: triggerSubscriptions.id});
+    return rows.length;
+  };
+  if (params.tx) return await work(params.tx);
+  return await db().transaction(work);
+}
+
+export async function getTriggerSubscriptionById(
+  id: string,
+): Promise<TriggerSubscription | undefined> {
+  const rows = await db()
+    .select()
+    .from(triggerSubscriptions)
+    .where(eq(triggerSubscriptions.id, id))
+    .limit(1);
+  const row = rows[0];
+  if (!row) return undefined;
+  return toTriggerSubscription(row);
+}
+
+export async function getManualSubscriptionByDefinitionId(
+  workflowDefinitionId: string,
+): Promise<TriggerSubscription | undefined> {
+  // limit(2) catches a broken parser invariant (>1 manual per definition) loudly instead of silently picking one.
+  const rows = await db()
+    .select()
+    .from(triggerSubscriptions)
+    .where(
+      and(
+        eq(triggerSubscriptions.workflowDefinitionId, workflowDefinitionId),
+        eq(triggerSubscriptions.source, 'manual'),
+      ),
+    )
+    .limit(2);
+  if (rows.length > 1) {
+    throw new Error(
+      `Workflow definition ${workflowDefinitionId} has ${rows.length} manual triggers; expected at most 1`,
+    );
+  }
+  const row = rows[0];
+  if (!row) return undefined;
+  return toTriggerSubscription(row);
+}
+
+export interface FindMatchingSubscriptionsParams {
+  workspaceId: string;
+  source: string;
+  event: string;
+}
+
+// Matches at workspace scope: an inbound integration event is a workspace-level
+// fact, not addressed to a project. Narrowing to a repo/project/branch is left to
+// user-defined per-workflow filters, not inferred here.
+export async function findMatchingSubscriptions(
+  params: FindMatchingSubscriptionsParams,
+): Promise<TriggerSubscription[]> {
+  const rows = await db()
+    .select()
+    .from(triggerSubscriptions)
+    .where(
+      and(
+        eq(triggerSubscriptions.workspaceId, params.workspaceId),
+        eq(triggerSubscriptions.source, params.source),
+        eq(triggerSubscriptions.event, params.event),
+      ),
+    );
+  return rows.map(toTriggerSubscription);
+}
+
+export async function listSubscriptionsByWorkflowDefinitionIds(
+  workflowDefinitionIds: string[],
+): Promise<TriggerSubscription[]> {
+  if (workflowDefinitionIds.length === 0) return [];
+  const rows = await db()
+    .select()
+    .from(triggerSubscriptions)
+    .where(inArray(triggerSubscriptions.workflowDefinitionId, workflowDefinitionIds));
+  return rows.map(toTriggerSubscription);
+}

package/src/index.ts

@@ -0,0 +1,108 @@
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {
+  DEFINITION_DELETED,
+  DEFINITION_RESOLVED,
+  type DefinitionsEventMap,
+} from '@shipfox/api-definitions-dto';
+import {
+  INTEGRATION_EVENT_RECEIVED,
+  type IntegrationsEventMap,
+} from '@shipfox/api-integration-core-dto';
+import {
+  WORKFLOWS_JOB_ACTIVATED,
+  WORKFLOWS_JOB_TERMINATED,
+  type WorkflowsEventMapDto,
+} from '@shipfox/api-workflows-dto';
+import {type ShipfoxModule, subscriberFactory} from '@shipfox/node-module';
+import {db, migrationsPath, triggersOutbox} from '#db/index.js';
+import {registerTriggersServiceMetrics} from '#metrics/index.js';
+import {routes} from '#presentation/index.js';
+import {
+  onDefinitionDeleted,
+  onDefinitionResolved,
+  onIntegrationEventReceived,
+  onJobActivated,
+  onJobTerminated,
+} from '#presentation/subscribers/index.js';
+import {
+  createTriggersCronActivities,
+  createTriggersMaintenanceActivities,
+} from '#temporal/activities/index.js';
+import {TRIGGERS_CRON_TASK_QUEUE, TRIGGERS_MAINTENANCE_TASK_QUEUE} from '#temporal/constants.js';
+
+export type {
+  JobListenerMatcherKind,
+  JobListenerSubscription,
+} from '#core/entities/job-listener-subscription.js';
+export type {TriggerSubscription} from '#core/entities/subscription.js';
+export {
+  fireCronSubscription,
+  fireManualSubscription,
+  ManualTriggerNotFoundError,
+  TriggerSubscriptionNotCronError,
+  TriggerSubscriptionNotFoundError,
+  TriggerSubscriptionNotManualError,
+  TriggerWorkspaceMismatchError,
+} from '#core/index.js';
+export {
+  db,
+  findMatchingJobListenerSubscriptions,
+  findMatchingSubscriptions,
+  getManualSubscriptionByDefinitionId,
+  getTriggerSubscriptionById,
+  jobListenerSubscriptions,
+  listSubscriptionsByWorkflowDefinitionIds,
+  migrationsPath,
+  projectJobListenerSubscriptions,
+  removeJobListenerSubscriptionsForJob,
+  triggersOutbox,
+} from '#db/index.js';
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const temporalWorkflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');
+
+const subscriber = subscriberFactory<
+  DefinitionsEventMap & IntegrationsEventMap & WorkflowsEventMapDto
+>();
+
+export const triggersModule: ShipfoxModule = {
+  name: 'triggers',
+  database: {db, migrationsPath},
+  routes,
+  metrics: registerTriggersServiceMetrics,
+  publishers: [{name: 'triggers', table: triggersOutbox, db}],
+  subscribers: [
+    subscriber(DEFINITION_RESOLVED, onDefinitionResolved),
+    subscriber(DEFINITION_DELETED, onDefinitionDeleted),
+    subscriber(INTEGRATION_EVENT_RECEIVED, onIntegrationEventReceived),
+    subscriber(WORKFLOWS_JOB_ACTIVATED, onJobActivated),
+    subscriber(WORKFLOWS_JOB_TERMINATED, onJobTerminated),
+  ],
+  workers: [
+    {
+      taskQueue: TRIGGERS_MAINTENANCE_TASK_QUEUE,
+      workflowsPath: temporalWorkflowsPath,
+      activities: createTriggersMaintenanceActivities,
+      workflows: [
+        {
+          name: 'pruneTriggerEventsCron',
+          id: 'triggers-prune-trigger-events',
+          cronSchedule: '0 * * * *',
+        },
+      ],
+    },
+    {
+      taskQueue: TRIGGERS_CRON_TASK_QUEUE,
+      workflowsPath: temporalWorkflowsPath,
+      activities: createTriggersCronActivities,
+      workflows: [
+        {
+          name: 'cronTickCron',
+          id: 'triggers-cron-tick',
+          cronSchedule: '* * * * *',
+        },
+      ],
+    },
+  ],
+};

package/src/metrics/index.ts

@@ -0,0 +1,8 @@
+export {
+  cronFiredCount,
+  cronFireLag,
+  eventOutcomeCount,
+  eventReceivedCount,
+  subscriptionTriggeredCount,
+} from './instance.js';
+export {registerTriggersServiceMetrics} from './service.js';