@shipfox/api-triggers 2.0.0

package/dist/db/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"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"}

package/dist/db/db.js

@@ -0,0 +1,28 @@
+import { drizzle } from '@shipfox/node-drizzle';
+import { pgClient } from '@shipfox/node-postgres';
+import { triggersCronSchedules } from './schema/cron-schedules.js';
+import { triggersDecisions } from './schema/decisions.js';
+import { jobListenerSubscriptions } from './schema/job-listener-subscriptions.js';
+import { triggersOutbox } from './schema/outbox.js';
+import { triggersReceivedEvents } from './schema/received-events.js';
+import { triggerSubscriptions } from './schema/subscriptions.js';
+export const schema = {
+    triggersCronSchedules,
+    jobListenerSubscriptions,
+    triggerSubscriptions,
+    triggersOutbox,
+    triggersReceivedEvents,
+    triggersDecisions
+};
+let _db;
+export function db() {
+    if (!_db) _db = drizzle(pgClient(), {
+        schema
+    });
+    return _db;
+}
+export function closeDb() {
+    _db = undefined;
+}
+
+//# sourceMappingURL=db.js.map

package/dist/db/db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/db.ts"],"sourcesContent":["import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';\nimport {pgClient} from '@shipfox/node-postgres';\nimport {triggersCronSchedules} from './schema/cron-schedules.js';\nimport {triggersDecisions} from './schema/decisions.js';\nimport {jobListenerSubscriptions} from './schema/job-listener-subscriptions.js';\nimport {triggersOutbox} from './schema/outbox.js';\nimport {triggersReceivedEvents} from './schema/received-events.js';\nimport {triggerSubscriptions} from './schema/subscriptions.js';\n\nexport const schema = {\n  triggersCronSchedules,\n  jobListenerSubscriptions,\n  triggerSubscriptions,\n  triggersOutbox,\n  triggersReceivedEvents,\n  triggersDecisions,\n};\n\nlet _db: NodePgDatabase<typeof schema> | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport type Tx = Parameters<Parameters<ReturnType<typeof db>['transaction']>[0]>[0];\nexport type Executor = ReturnType<typeof db> | Tx;\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n"],"names":["drizzle","pgClient","triggersCronSchedules","triggersDecisions","jobListenerSubscriptions","triggersOutbox","triggersReceivedEvents","triggerSubscriptions","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,qBAAqB,QAAO,6BAA6B;AACjE,SAAQC,iBAAiB,QAAO,wBAAwB;AACxD,SAAQC,wBAAwB,QAAO,yCAAyC;AAChF,SAAQC,cAAc,QAAO,qBAAqB;AAClD,SAAQC,sBAAsB,QAAO,8BAA8B;AACnE,SAAQC,oBAAoB,QAAO,4BAA4B;AAE/D,OAAO,MAAMC,SAAS;IACpBN;IACAE;IACAG;IACAF;IACAC;IACAH;AACF,EAAE;AAEF,IAAIM;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMT,QAAQC,YAAY;QAACO;IAAM;IAC3C,OAAOC;AACT;AAKA,OAAO,SAASE;IACdF,MAAMG;AACR"}

package/dist/db/event-history.d.ts

@@ -0,0 +1,50 @@
+import type { JobListenerSubscription } from '#core/entities/job-listener-subscription.js';
+import type { TriggerEventOrigin } from '#core/entities/received-event.js';
+import type { TriggerSubscription } from '#core/entities/subscription.js';
+export interface InsertReceivedEventParams {
+    eventRef: string;
+    origin: TriggerEventOrigin;
+    workspaceId: string;
+    provider: string | null;
+    source: string;
+    event: string;
+    deliveryId: string | null;
+    connectionId: string | null;
+    connectionName: string | null;
+    payload: Record<string, unknown> | null;
+    receivedAt: Date;
+}
+export declare function insertReceivedEvent(params: InsertReceivedEventParams): Promise<string>;
+export declare function markReceivedEventDiscarded(id: string): Promise<void>;
+export declare function markReceivedEventRouted(id: string, matchedCount: number): Promise<void>;
+export declare function markReceivedEventFailed(id: string, matchedCount: number): Promise<void>;
+export declare function markReceivedEventErrored(id: string, matchedCount: number): Promise<void>;
+export interface UpsertTriggeredDecisionParams {
+    receivedEventId: string;
+    subscription: TriggerSubscription;
+    run: {
+        id: string;
+        name: string;
+    };
+}
+export declare function upsertTriggeredDecision(params: UpsertTriggeredDecisionParams): Promise<void>;
+export interface UpsertFailedDecisionParams {
+    receivedEventId: string;
+    subscription: TriggerSubscription;
+    reason: string;
+}
+export declare function upsertFilterErrorDecision(params: UpsertFailedDecisionParams): Promise<void>;
+export declare function upsertDispatchErrorDecision(params: UpsertFailedDecisionParams): Promise<void>;
+export interface UpsertListenerTriggeredDecisionParams {
+    receivedEventId: string;
+    subscription: JobListenerSubscription;
+}
+export declare function upsertListenerTriggeredDecision(params: UpsertListenerTriggeredDecisionParams): Promise<void>;
+export interface UpsertListenerFailedDecisionParams {
+    receivedEventId: string;
+    subscription: JobListenerSubscription;
+    reason: string;
+}
+export declare function upsertListenerFilterErrorDecision(params: UpsertListenerFailedDecisionParams): Promise<void>;
+export declare function upsertListenerDispatchErrorDecision(params: UpsertListenerFailedDecisionParams): Promise<void>;
+//# sourceMappingURL=event-history.d.ts.map

package/dist/db/event-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-history.d.ts","sourceRoot":"","sources":["../../src/db/event-history.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,6CAA6C,CAAC;AACzF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAKxE,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,UAAU,EAAE,IAAI,CAAC;CAClB;AAID,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CA4B5F;AAED,wBAAsB,0BAA0B,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU1E;AAED,wBAAsB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAK7F;AAID,wBAAsB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU7F;AAOD,wBAAsB,wBAAwB,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmB9F;AAED,MAAM,WAAW,6BAA6B;IAC5C,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,mBAAmB,CAAC;IAClC,GAAG,EAAE;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;CACjC;AAED,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,6BAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED,MAAM,WAAW,0BAA0B;IACzC,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,mBAAmB,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjG;AAGD,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CAEf;AA6BD,MAAM,WAAW,qCAAqC;IACpD,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,uBAAuB,CAAC;CACvC;AAED,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,qCAAqC,GAC5C,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,MAAM,WAAW,kCAAkC;IACjD,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,uBAAuB,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,kCAAkC,GACzC,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAsB,mCAAmC,CACvD,MAAM,EAAE,kCAAkC,GACzC,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/dist/db/event-history.js

@@ -0,0 +1,207 @@
+import { and, eq, ne, notInArray, sql } from 'drizzle-orm';
+import { db } from './db.js';
+import { triggersDecisions } from './schema/decisions.js';
+import { triggersReceivedEvents } from './schema/received-events.js';
+// `event_ref` is unique and delivery is at-least-once, so the same event can
+// arrive twice; either path returns the row id used to attach decisions.
+export async function insertReceivedEvent(params) {
+    const [inserted] = await db().insert(triggersReceivedEvents).values({
+        eventRef: params.eventRef,
+        origin: params.origin,
+        workspaceId: params.workspaceId,
+        provider: params.provider,
+        source: params.source,
+        event: params.event,
+        deliveryId: params.deliveryId,
+        connectionId: params.connectionId,
+        connectionName: params.connectionName,
+        payload: params.payload,
+        receivedAt: params.receivedAt
+    }).onConflictDoNothing({
+        target: triggersReceivedEvents.eventRef
+    }).returning({
+        id: triggersReceivedEvents.id
+    });
+    if (inserted) return inserted.id;
+    const [existing] = await db().select({
+        id: triggersReceivedEvents.id
+    }).from(triggersReceivedEvents).where(eq(triggersReceivedEvents.eventRef, params.eventRef));
+    if (!existing) {
+        throw new Error(`received_events row missing after conflict for event_ref ${params.eventRef}`);
+    }
+    return existing.id;
+}
+export async function markReceivedEventDiscarded(id) {
+    await db().update(triggersReceivedEvents).set({
+        outcome: 'discarded',
+        matchedCount: 0,
+        processedAt: new Date()
+    }).where(and(eq(triggersReceivedEvents.id, id), notInArray(triggersReceivedEvents.outcome, [
+        'routed',
+        'errored'
+    ])));
+}
+export async function markReceivedEventRouted(id, matchedCount) {
+    await db().update(triggersReceivedEvents).set({
+        outcome: 'routed',
+        matchedCount,
+        processedAt: new Date()
+    }).where(eq(triggersReceivedEvents.id, id));
+}
+// No processedAt: `failed` is transient. Under at-least-once dispatch, a late
+// failure must not clobber a sibling invocation's terminal outcome.
+export async function markReceivedEventFailed(id, matchedCount) {
+    await db().update(triggersReceivedEvents).set({
+        outcome: 'failed',
+        matchedCount
+    }).where(and(eq(triggersReceivedEvents.id, id), notInArray(triggersReceivedEvents.outcome, [
+        'routed',
+        'discarded',
+        'errored'
+    ])));
+}
+// Terminal outcome for a fan-out that produced no new run this pass. The CASE is a
+// cross-attempt safety net: under at-least-once delivery a prior attempt may already have
+// created a run (its decision row is `triggered`, which is never downgraded), so promote the
+// event to `routed` rather than falsely record `errored`. Guarded so it never downgrades a
+// terminal success.
+export async function markReceivedEventErrored(id, matchedCount) {
+    await db().update(triggersReceivedEvents).set({
+        outcome: sql`CASE WHEN EXISTS (
+        SELECT 1
+        FROM ${triggersDecisions}
+        WHERE ${triggersDecisions.receivedEventId} = ${triggersReceivedEvents.id}
+          AND ${triggersDecisions.decision} = 'triggered'
+      ) THEN 'routed' ELSE 'errored' END`,
+        matchedCount,
+        processedAt: new Date()
+    }).where(and(eq(triggersReceivedEvents.id, id), notInArray(triggersReceivedEvents.outcome, [
+        'routed',
+        'discarded'
+    ])));
+}
+export async function upsertTriggeredDecision(params) {
+    await db().insert(triggersDecisions).values({
+        receivedEventId: params.receivedEventId,
+        subscriptionKind: 'trigger',
+        subscriptionId: params.subscription.id,
+        subscriptionName: params.subscription.name,
+        workflowDefinitionId: params.subscription.workflowDefinitionId,
+        projectId: params.subscription.projectId,
+        decision: 'triggered',
+        runId: params.run.id,
+        runName: params.run.name,
+        reason: null
+    }).onConflictDoUpdate({
+        target: [
+            triggersDecisions.receivedEventId,
+            triggersDecisions.subscriptionKind,
+            triggersDecisions.subscriptionId
+        ],
+        set: {
+            decision: 'triggered',
+            runId: params.run.id,
+            runName: params.run.name,
+            reason: null
+        }
+    });
+}
+export async function upsertFilterErrorDecision(params) {
+    await upsertFailedDecision(params, 'filter-error');
+}
+// A created run is ground truth. A later retry failure must not erase it.
+export async function upsertDispatchErrorDecision(params) {
+    await upsertFailedDecision(params, 'dispatch-error');
+}
+async function upsertFailedDecision(params, decision) {
+    await db().insert(triggersDecisions).values({
+        receivedEventId: params.receivedEventId,
+        subscriptionKind: 'trigger',
+        subscriptionId: params.subscription.id,
+        subscriptionName: params.subscription.name,
+        workflowDefinitionId: params.subscription.workflowDefinitionId,
+        projectId: params.subscription.projectId,
+        decision,
+        reason: params.reason
+    }).onConflictDoUpdate({
+        target: [
+            triggersDecisions.receivedEventId,
+            triggersDecisions.subscriptionKind,
+            triggersDecisions.subscriptionId
+        ],
+        set: {
+            decision,
+            reason: params.reason,
+            runId: null,
+            runName: null
+        },
+        setWhere: ne(triggersDecisions.decision, 'triggered')
+    });
+}
+export async function upsertListenerTriggeredDecision(params) {
+    await db().insert(triggersDecisions).values({
+        ...listenerDecisionIdentity(params),
+        decision: 'triggered',
+        runId: null,
+        runName: null,
+        reason: null
+    }).onConflictDoUpdate({
+        target: [
+            triggersDecisions.receivedEventId,
+            triggersDecisions.subscriptionKind,
+            triggersDecisions.subscriptionId
+        ],
+        set: {
+            decision: 'triggered',
+            runId: null,
+            runName: null,
+            reason: null
+        }
+    });
+}
+export async function upsertListenerFilterErrorDecision(params) {
+    await upsertListenerFailedDecision(params, 'filter-error');
+}
+export async function upsertListenerDispatchErrorDecision(params) {
+    await upsertListenerFailedDecision(params, 'dispatch-error');
+}
+async function upsertListenerFailedDecision(params, decision) {
+    await db().insert(triggersDecisions).values({
+        ...listenerDecisionIdentity(params),
+        decision,
+        reason: params.reason
+    }).onConflictDoUpdate({
+        target: [
+            triggersDecisions.receivedEventId,
+            triggersDecisions.subscriptionKind,
+            triggersDecisions.subscriptionId
+        ],
+        set: {
+            decision,
+            reason: params.reason,
+            runId: null,
+            runName: null
+        },
+        setWhere: ne(triggersDecisions.decision, 'triggered')
+    });
+}
+function listenerDecisionIdentity(params) {
+    const { subscription } = params;
+    return {
+        receivedEventId: params.receivedEventId,
+        subscriptionKind: 'listener',
+        subscriptionId: subscription.id,
+        subscriptionName: listenerSubscriptionName(subscription),
+        workflowDefinitionId: null,
+        projectId: null,
+        workflowRunId: subscription.workflowRunId,
+        jobId: subscription.jobId,
+        matcherKind: subscription.kind,
+        matcherOrdinal: subscription.matcherOrdinal
+    };
+}
+function listenerSubscriptionName(subscription) {
+    return `listener ${subscription.kind}[${subscription.matcherOrdinal}] ${subscription.source}/${subscription.event}`;
+}
+
+//# sourceMappingURL=event-history.js.map

package/dist/db/event-history.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/event-history.ts"],"sourcesContent":["import {and, eq, ne, notInArray, sql} from 'drizzle-orm';\nimport type {JobListenerSubscription} from '#core/entities/job-listener-subscription.js';\nimport type {TriggerEventOrigin} from '#core/entities/received-event.js';\nimport type {TriggerSubscription} from '#core/entities/subscription.js';\nimport {db} from './db.js';\nimport {triggersDecisions} from './schema/decisions.js';\nimport {triggersReceivedEvents} from './schema/received-events.js';\n\nexport interface InsertReceivedEventParams {\n  eventRef: string;\n  origin: TriggerEventOrigin;\n  workspaceId: string;\n  provider: string | null;\n  source: string;\n  event: string;\n  deliveryId: string | null;\n  connectionId: string | null;\n  connectionName: string | null;\n  payload: Record<string, unknown> | null;\n  receivedAt: Date;\n}\n\n// `event_ref` is unique and delivery is at-least-once, so the same event can\n// arrive twice; either path returns the row id used to attach decisions.\nexport async function insertReceivedEvent(params: InsertReceivedEventParams): Promise<string> {\n  const [inserted] = await db()\n    .insert(triggersReceivedEvents)\n    .values({\n      eventRef: params.eventRef,\n      origin: params.origin,\n      workspaceId: params.workspaceId,\n      provider: params.provider,\n      source: params.source,\n      event: params.event,\n      deliveryId: params.deliveryId,\n      connectionId: params.connectionId,\n      connectionName: params.connectionName,\n      payload: params.payload,\n      receivedAt: params.receivedAt,\n    })\n    .onConflictDoNothing({target: triggersReceivedEvents.eventRef})\n    .returning({id: triggersReceivedEvents.id});\n  if (inserted) return inserted.id;\n\n  const [existing] = await db()\n    .select({id: triggersReceivedEvents.id})\n    .from(triggersReceivedEvents)\n    .where(eq(triggersReceivedEvents.eventRef, params.eventRef));\n  if (!existing) {\n    throw new Error(`received_events row missing after conflict for event_ref ${params.eventRef}`);\n  }\n  return existing.id;\n}\n\nexport async function markReceivedEventDiscarded(id: string): Promise<void> {\n  await db()\n    .update(triggersReceivedEvents)\n    .set({outcome: 'discarded', matchedCount: 0, processedAt: new Date()})\n    .where(\n      and(\n        eq(triggersReceivedEvents.id, id),\n        notInArray(triggersReceivedEvents.outcome, ['routed', 'errored']),\n      ),\n    );\n}\n\nexport async function markReceivedEventRouted(id: string, matchedCount: number): Promise<void> {\n  await db()\n    .update(triggersReceivedEvents)\n    .set({outcome: 'routed', matchedCount, processedAt: new Date()})\n    .where(eq(triggersReceivedEvents.id, id));\n}\n\n// No processedAt: `failed` is transient. Under at-least-once dispatch, a late\n// failure must not clobber a sibling invocation's terminal outcome.\nexport async function markReceivedEventFailed(id: string, matchedCount: number): Promise<void> {\n  await db()\n    .update(triggersReceivedEvents)\n    .set({outcome: 'failed', matchedCount})\n    .where(\n      and(\n        eq(triggersReceivedEvents.id, id),\n        notInArray(triggersReceivedEvents.outcome, ['routed', 'discarded', 'errored']),\n      ),\n    );\n}\n\n// Terminal outcome for a fan-out that produced no new run this pass. The CASE is a\n// cross-attempt safety net: under at-least-once delivery a prior attempt may already have\n// created a run (its decision row is `triggered`, which is never downgraded), so promote the\n// event to `routed` rather than falsely record `errored`. Guarded so it never downgrades a\n// terminal success.\nexport async function markReceivedEventErrored(id: string, matchedCount: number): Promise<void> {\n  await db()\n    .update(triggersReceivedEvents)\n    .set({\n      outcome: sql`CASE WHEN EXISTS (\n        SELECT 1\n        FROM ${triggersDecisions}\n        WHERE ${triggersDecisions.receivedEventId} = ${triggersReceivedEvents.id}\n          AND ${triggersDecisions.decision} = 'triggered'\n      ) THEN 'routed' ELSE 'errored' END`,\n      matchedCount,\n      processedAt: new Date(),\n    })\n    .where(\n      and(\n        eq(triggersReceivedEvents.id, id),\n        notInArray(triggersReceivedEvents.outcome, ['routed', 'discarded']),\n      ),\n    );\n}\n\nexport interface UpsertTriggeredDecisionParams {\n  receivedEventId: string;\n  subscription: TriggerSubscription;\n  run: {id: string; name: string};\n}\n\nexport async function upsertTriggeredDecision(\n  params: UpsertTriggeredDecisionParams,\n): Promise<void> {\n  await db()\n    .insert(triggersDecisions)\n    .values({\n      receivedEventId: params.receivedEventId,\n      subscriptionKind: 'trigger',\n      subscriptionId: params.subscription.id,\n      subscriptionName: params.subscription.name,\n      workflowDefinitionId: params.subscription.workflowDefinitionId,\n      projectId: params.subscription.projectId,\n      decision: 'triggered',\n      runId: params.run.id,\n      runName: params.run.name,\n      reason: null,\n    })\n    .onConflictDoUpdate({\n      target: [\n        triggersDecisions.receivedEventId,\n        triggersDecisions.subscriptionKind,\n        triggersDecisions.subscriptionId,\n      ],\n      set: {decision: 'triggered', runId: params.run.id, runName: params.run.name, reason: null},\n    });\n}\n\nexport interface UpsertFailedDecisionParams {\n  receivedEventId: string;\n  subscription: TriggerSubscription;\n  reason: string;\n}\n\nexport async function upsertFilterErrorDecision(params: UpsertFailedDecisionParams): Promise<void> {\n  await upsertFailedDecision(params, 'filter-error');\n}\n\n// A created run is ground truth. A later retry failure must not erase it.\nexport async function upsertDispatchErrorDecision(\n  params: UpsertFailedDecisionParams,\n): Promise<void> {\n  await upsertFailedDecision(params, 'dispatch-error');\n}\n\nasync function upsertFailedDecision(\n  params: UpsertFailedDecisionParams,\n  decision: 'filter-error' | 'dispatch-error',\n): Promise<void> {\n  await db()\n    .insert(triggersDecisions)\n    .values({\n      receivedEventId: params.receivedEventId,\n      subscriptionKind: 'trigger',\n      subscriptionId: params.subscription.id,\n      subscriptionName: params.subscription.name,\n      workflowDefinitionId: params.subscription.workflowDefinitionId,\n      projectId: params.subscription.projectId,\n      decision,\n      reason: params.reason,\n    })\n    .onConflictDoUpdate({\n      target: [\n        triggersDecisions.receivedEventId,\n        triggersDecisions.subscriptionKind,\n        triggersDecisions.subscriptionId,\n      ],\n      set: {decision, reason: params.reason, runId: null, runName: null},\n      setWhere: ne(triggersDecisions.decision, 'triggered'),\n    });\n}\n\nexport interface UpsertListenerTriggeredDecisionParams {\n  receivedEventId: string;\n  subscription: JobListenerSubscription;\n}\n\nexport async function upsertListenerTriggeredDecision(\n  params: UpsertListenerTriggeredDecisionParams,\n): Promise<void> {\n  await db()\n    .insert(triggersDecisions)\n    .values({\n      ...listenerDecisionIdentity(params),\n      decision: 'triggered',\n      runId: null,\n      runName: null,\n      reason: null,\n    })\n    .onConflictDoUpdate({\n      target: [\n        triggersDecisions.receivedEventId,\n        triggersDecisions.subscriptionKind,\n        triggersDecisions.subscriptionId,\n      ],\n      set: {decision: 'triggered', runId: null, runName: null, reason: null},\n    });\n}\n\nexport interface UpsertListenerFailedDecisionParams {\n  receivedEventId: string;\n  subscription: JobListenerSubscription;\n  reason: string;\n}\n\nexport async function upsertListenerFilterErrorDecision(\n  params: UpsertListenerFailedDecisionParams,\n): Promise<void> {\n  await upsertListenerFailedDecision(params, 'filter-error');\n}\n\nexport async function upsertListenerDispatchErrorDecision(\n  params: UpsertListenerFailedDecisionParams,\n): Promise<void> {\n  await upsertListenerFailedDecision(params, 'dispatch-error');\n}\n\nasync function upsertListenerFailedDecision(\n  params: UpsertListenerFailedDecisionParams,\n  decision: 'filter-error' | 'dispatch-error',\n): Promise<void> {\n  await db()\n    .insert(triggersDecisions)\n    .values({\n      ...listenerDecisionIdentity(params),\n      decision,\n      reason: params.reason,\n    })\n    .onConflictDoUpdate({\n      target: [\n        triggersDecisions.receivedEventId,\n        triggersDecisions.subscriptionKind,\n        triggersDecisions.subscriptionId,\n      ],\n      set: {decision, reason: params.reason, runId: null, runName: null},\n      setWhere: ne(triggersDecisions.decision, 'triggered'),\n    });\n}\n\nfunction listenerDecisionIdentity(params: {\n  receivedEventId: string;\n  subscription: JobListenerSubscription;\n}) {\n  const {subscription} = params;\n  return {\n    receivedEventId: params.receivedEventId,\n    subscriptionKind: 'listener' as const,\n    subscriptionId: subscription.id,\n    subscriptionName: listenerSubscriptionName(subscription),\n    workflowDefinitionId: null,\n    projectId: null,\n    workflowRunId: subscription.workflowRunId,\n    jobId: subscription.jobId,\n    matcherKind: subscription.kind,\n    matcherOrdinal: subscription.matcherOrdinal,\n  };\n}\n\nfunction listenerSubscriptionName(subscription: JobListenerSubscription): string {\n  return `listener ${subscription.kind}[${subscription.matcherOrdinal}] ${subscription.source}/${subscription.event}`;\n}\n"],"names":["and","eq","ne","notInArray","sql","db","triggersDecisions","triggersReceivedEvents","insertReceivedEvent","params","inserted","insert","values","eventRef","origin","workspaceId","provider","source","event","deliveryId","connectionId","connectionName","payload","receivedAt","onConflictDoNothing","target","returning","id","existing","select","from","where","Error","markReceivedEventDiscarded","update","set","outcome","matchedCount","processedAt","Date","markReceivedEventRouted","markReceivedEventFailed","markReceivedEventErrored","receivedEventId","decision","upsertTriggeredDecision","subscriptionKind","subscriptionId","subscription","subscriptionName","name","workflowDefinitionId","projectId","runId","run","runName","reason","onConflictDoUpdate","upsertFilterErrorDecision","upsertFailedDecision","upsertDispatchErrorDecision","setWhere","upsertListenerTriggeredDecision","listenerDecisionIdentity","upsertListenerFilterErrorDecision","upsertListenerFailedDecision","upsertListenerDispatchErrorDecision","listenerSubscriptionName","workflowRunId","jobId","matcherKind","kind","matcherOrdinal"],"mappings":"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"}

package/dist/db/event-queries.d.ts

@@ -0,0 +1,38 @@
+import type { TriggerDecision } from '#core/entities/decision.js';
+import type { TriggerEventOutcome, TriggerReceivedEvent, TriggerReceivedEventSummary } from '#core/entities/received-event.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;
+}
+export declare function listTriggerEvents(params: ListTriggerEventsParams): Promise<ListTriggerEventsResult>;
+export declare function getTriggerEventById(id: string): Promise<TriggerReceivedEvent | undefined>;
+export interface TriggerEventFacet {
+    value: string;
+    count: number;
+}
+export interface ListTriggerEventFacetsResult {
+    sources: TriggerEventFacet[];
+    events: TriggerEventFacet[];
+}
+export declare function listTriggerEventFacets(params: {
+    workspaceId: string;
+}): Promise<ListTriggerEventFacetsResult>;
+export declare function listDecisionsByReceivedEventId(receivedEventId: string): Promise<TriggerDecision[]>;
+//# sourceMappingURL=event-queries.d.ts.map

package/dist/db/event-queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-queries.d.ts","sourceRoot":"","sources":["../../src/db/event-queries.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,2BAA2B,EAC5B,MAAM,kCAAkC,CAAC;AAU1C,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,IAAI,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC7B,QAAQ,CAAC,EAAE,mBAAmB,EAAE,GAAG,SAAS,CAAC;IAC7C,IAAI,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;IACxB,EAAE,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACxC,OAAO,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,2BAA2B,EAAE,CAAC;IACtC,UAAU,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACvC;AAqBD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,uBAAuB,CAAC,CAgBlC;AAED,wBAAsB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAO/F;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,MAAM,EAAE,iBAAiB,EAAE,CAAC;CAC7B;AAmBD,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAMxC;AAID,wBAAsB,8BAA8B,CAClD,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,eAAe,EAAE,CAAC,CAO5B"}

package/dist/db/event-queries.js

@@ -0,0 +1,78 @@
+import { paginateTimestampIdRows, timestampIdCursorWhere } from '@shipfox/node-drizzle';
+import { and, asc, count, desc, eq, gte, inArray, lte } from 'drizzle-orm';
+import { db } from './db.js';
+import { toTriggerDecision, triggersDecisions } from './schema/decisions.js';
+import { toTriggerReceivedEvent, toTriggerReceivedEventSummary, triggerReceivedEventSummaryColumns, triggersReceivedEvents } from './schema/received-events.js';
+function listConditions(params) {
+    const { workspaceId, cursor, filters } = params;
+    const conditions = [
+        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) {
+    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) {
+    const [row] = await db().select().from(triggersReceivedEvents).where(eq(triggersReceivedEvents.id, id)).limit(1);
+    return row ? toTriggerReceivedEvent(row) : undefined;
+}
+// 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, column) {
+    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,
+            count: Number(row.count)
+        }));
+}
+export async function listTriggerEventFacets(params) {
+    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) {
+    const rows = await db().select().from(triggersDecisions).where(eq(triggersDecisions.receivedEventId, receivedEventId)).orderBy(asc(triggersDecisions.createdAt), asc(triggersDecisions.id));
+    return rows.map(toTriggerDecision);
+}
+
+//# sourceMappingURL=event-queries.js.map

package/dist/db/event-queries.js.map

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

package/dist/db/index.d.ts

@@ -0,0 +1,11 @@
+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 declare const migrationsPath: string;
+//# sourceMappingURL=index.d.ts.map

package/dist/db/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,iCAAiC,EACjC,+BAA+B,EAC/B,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAC,OAAO,EAAE,EAAE,EAAE,KAAK,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,EAAC,MAAM,SAAS,CAAC;AACpE,OAAO,EACL,mBAAmB,EACnB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,8BAA8B,EAC9B,sBAAsB,EACtB,iBAAiB,EACjB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,KAAK,0CAA0C,EAC/C,oCAAoC,EACpC,KAAK,eAAe,EACpB,KAAK,qCAAqC,EAC1C,+BAA+B,EAC/B,oCAAoC,GACrC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,cAAc,EACd,qBAAqB,GACtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAC,wBAAwB,EAAC,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAC,oBAAoB,EAAC,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EACL,gCAAgC,EAChC,yBAAyB,EACzB,mCAAmC,EACnC,0BAA0B,EAC1B,wCAAwC,EACxC,yBAAyB,GAC1B,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,cAAc,QAAoE,CAAC"}

package/dist/db/index.js

@@ -0,0 +1,14 @@
+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, schema } from './db.js';
+export { getTriggerEventById, listDecisionsByReceivedEventId, listTriggerEventFacets, listTriggerEvents } from './event-queries.js';
+export { findMatchingJobListenerSubscriptions, projectJobListenerSubscriptions, removeJobListenerSubscriptionsForJob } from './job-listener-subscriptions.js';
+export { 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');
+
+//# sourceMappingURL=index.js.map

package/dist/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport {\n  advanceCronSchedule,\n  claimDueCronSchedules,\n  countDueCronSchedules,\n  deleteCronScheduleForSubscription,\n  getCronScheduleBySubscriptionId,\n  syncCronSchedule,\n} from './cron-schedules.js';\nexport {closeDb, db, type Executor, schema, type Tx} from './db.js';\nexport {\n  getTriggerEventById,\n  type ListTriggerEventFacetsResult,\n  type ListTriggerEventsParams,\n  type ListTriggerEventsResult,\n  listDecisionsByReceivedEventId,\n  listTriggerEventFacets,\n  listTriggerEvents,\n  type TriggerEventCursor,\n  type TriggerEventFacet,\n  type TriggerEventListFilters,\n} from './event-queries.js';\nexport {\n  type FindMatchingJobListenerSubscriptionsParams,\n  findMatchingJobListenerSubscriptions,\n  type ListenerMatcher,\n  type ProjectJobListenerSubscriptionsParams,\n  projectJobListenerSubscriptions,\n  removeJobListenerSubscriptionsForJob,\n} from './job-listener-subscriptions.js';\nexport {\n  type CronScheduleDb,\n  type CronScheduleInsertDb,\n  toCronSchedule,\n  triggersCronSchedules,\n} from './schema/cron-schedules.js';\nexport {jobListenerSubscriptions} from './schema/job-listener-subscriptions.js';\nexport {triggersOutbox} from './schema/outbox.js';\nexport {triggerSubscriptions} from './schema/subscriptions.js';\nexport {\n  deleteSubscriptionsForDefinition,\n  findMatchingSubscriptions,\n  getManualSubscriptionByDefinitionId,\n  getTriggerSubscriptionById,\n  listSubscriptionsByWorkflowDefinitionIds,\n  projectDefinitionTriggers,\n} from './subscriptions.js';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","advanceCronSchedule","claimDueCronSchedules","countDueCronSchedules","deleteCronScheduleForSubscription","getCronScheduleBySubscriptionId","syncCronSchedule","closeDb","db","schema","getTriggerEventById","listDecisionsByReceivedEventId","listTriggerEventFacets","listTriggerEvents","findMatchingJobListenerSubscriptions","projectJobListenerSubscriptions","removeJobListenerSubscriptionsForJob","toCronSchedule","triggersCronSchedules","jobListenerSubscriptions","triggersOutbox","triggerSubscriptions","deleteSubscriptionsForDefinition","findMatchingSubscriptions","getManualSubscriptionByDefinitionId","getTriggerSubscriptionById","listSubscriptionsByWorkflowDefinitionIds","projectDefinitionTriggers","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,SACEC,mBAAmB,EACnBC,qBAAqB,EACrBC,qBAAqB,EACrBC,iCAAiC,EACjCC,+BAA+B,EAC/BC,gBAAgB,QACX,sBAAsB;AAC7B,SAAQC,OAAO,EAAEC,EAAE,EAAiBC,MAAM,QAAgB,UAAU;AACpE,SACEC,mBAAmB,EAInBC,8BAA8B,EAC9BC,sBAAsB,EACtBC,iBAAiB,QAIZ,qBAAqB;AAC5B,SAEEC,oCAAoC,EAGpCC,+BAA+B,EAC/BC,oCAAoC,QAC/B,kCAAkC;AACzC,SAGEC,cAAc,EACdC,qBAAqB,QAChB,6BAA6B;AACpC,SAAQC,wBAAwB,QAAO,yCAAyC;AAChF,SAAQC,cAAc,QAAO,qBAAqB;AAClD,SAAQC,oBAAoB,QAAO,4BAA4B;AAC/D,SACEC,gCAAgC,EAChCC,yBAAyB,EACzBC,mCAAmC,EACnCC,0BAA0B,EAC1BC,wCAAwC,EACxCC,yBAAyB,QACpB,qBAAqB;AAE5B,OAAO,MAAMC,iBAAiB7B,QAAQD,QAAQE,cAAc,YAAY6B,GAAG,IAAI,iBAAiB"}

package/dist/db/job-listener-subscriptions.d.ts

@@ -0,0 +1,24 @@
+import type { JobListenerSubscription } from '#core/entities/job-listener-subscription.js';
+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 declare function projectJobListenerSubscriptions(params: ProjectJobListenerSubscriptionsParams): Promise<void>;
+export declare function removeJobListenerSubscriptionsForJob(jobId: string): Promise<number>;
+export interface FindMatchingJobListenerSubscriptionsParams {
+    workspaceId: string;
+    source: string;
+    event: string;
+}
+export declare function findMatchingJobListenerSubscriptions(params: FindMatchingJobListenerSubscriptionsParams): Promise<JobListenerSubscription[]>;
+//# sourceMappingURL=job-listener-subscriptions.d.ts.map

package/dist/db/job-listener-subscriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-listener-subscriptions.d.ts","sourceRoot":"","sources":["../../src/db/job-listener-subscriptions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,uBAAuB,EACxB,MAAM,6CAA6C,CAAC;AASrD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IACvD,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CACjE;AAED,MAAM,WAAW,qCAAqC;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI,CAAC;IACtC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI,CAAC;CAC1C;AAED,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,qCAAqC,GAC5C,OAAO,CAAC,IAAI,CAAC,CA4Cf;AA6BD,wBAAsB,oCAAoC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMzF;AAED,MAAM,WAAW,0CAA0C;IACzD,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,oCAAoC,CACxD,MAAM,EAAE,0CAA0C,GACjD,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAYpC"}

package/dist/db/job-listener-subscriptions.js

@@ -0,0 +1,69 @@
+import { and, eq, notInArray } from 'drizzle-orm';
+import { db } from './db.js';
+import { jobListenerSubscriptions, toJobListenerSubscription } from './schema/job-listener-subscriptions.js';
+export async function projectJobListenerSubscriptions(params) {
+    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 ?? []
+            ]
+        ]){
+            for (const [matcherOrdinal, matcher] of matchers.entries()){
+                const config = {};
+                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, jobId, kind, matchers) {
+    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) {
+    const rows = await db().delete(jobListenerSubscriptions).where(eq(jobListenerSubscriptions.jobId, jobId)).returning({
+        id: jobListenerSubscriptions.id
+    });
+    return rows.length;
+}
+export async function findMatchingJobListenerSubscriptions(params) {
+    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);
+}
+
+//# sourceMappingURL=job-listener-subscriptions.js.map