@ddd-ts-kit/events 0.0.0-stage → 0.1.0

package/dist/relay/outbox-relay-failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-relay-failure.d.ts","sourceRoot":"","sources":["../../src/relay/outbox-relay-failure.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAC1B;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/relay/outbox-relay-failure.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=outbox-relay-failure.js.map

package/dist/relay/outbox-relay-failure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-relay-failure.js","sourceRoot":"","sources":["../../src/relay/outbox-relay-failure.ts"],"names":[],"mappings":""}

package/dist/relay/outbox-relay.d.ts

@@ -0,0 +1,85 @@
+import type { Clock, IntegrationEvent, IntegrationEventPublisher } from '@ddd-ts-kit/kernel';
+import type { OutboxStore } from '../outbox/outbox-store.js';
+import type { OutboxBackoff } from './outbox-backoff.js';
+import type { OutboxOrdering } from './outbox-ordering.js';
+import type { OutboxRelayFailure } from './outbox-relay-failure.js';
+import type { RelaySignal } from './relay-signal.js';
+export interface OutboxRelayOptions {
+    readonly store: OutboxStore;
+    /** The real provider: a broker adapter, or the in-memory bus in a single process. */
+    readonly publisher: IntegrationEventPublisher;
+    readonly clock: Clock;
+    /** Default 100. */
+    readonly batchSize?: number;
+    /** Attempts after which a record is dead. Default 8. */
+    readonly maxAttempts?: number;
+    readonly backoff?: OutboxBackoff;
+    /** Observability hook. It receives codes only, so it is safe to log as is. */
+    readonly onFailure?: (failure: OutboxRelayFailure) => void;
+    /**
+     * Makes a started relay tick as soon as the store says something was appended, so
+     * `intervalMs` can be long. Bursts are coalesced: one tick runs, at most one is queued.
+     * The interval stays the safety net: a missed notification delays, it never loses.
+     */
+    readonly wakeOn?: RelaySignal;
+    /** Default `none`. `per-key` needs `keyOf` and a single running relay. */
+    readonly ordering?: OutboxOrdering;
+    /** The ordering key of an event, typically its aggregate id. No key: no ordering. */
+    readonly keyOf?: (event: IntegrationEvent) => string | undefined;
+}
+export interface OutboxTickResult {
+    readonly published: number;
+    readonly failed: number;
+}
+/** Code stored on a record that waits for an earlier record of its key. It is not a failure. */
+export declare const HELD_FOR_ORDER = "OUTBOX_HELD_FOR_ORDER";
+/**
+ * Moves stored events to the provider, at least once.
+ *
+ * By default ordering is NOT guaranteed, not even per aggregate: a failed event is retried
+ * later while its successors go out, and several relays may run side by side. Consumers must
+ * not rely on the order of arrival; carry a sequence or a version in the payload when order
+ * matters.
+ *
+ * With `ordering: 'per-key'` the records of one key go out in the order this relay first saw
+ * them, and a failed one holds its successors back until it is published or dead. The memory
+ * of it lives in the relay: run a single relay, and expect a record in backoff to be
+ * overtaken once if the process restarts meanwhile. A dead record no longer blocks its key.
+ */
+export declare class OutboxRelay {
+    private readonly store;
+    private readonly publisher;
+    private readonly clock;
+    private readonly batchSize;
+    private readonly maxAttempts;
+    private readonly backoff;
+    private readonly onFailure;
+    private readonly wakeOn;
+    private readonly order;
+    private timer;
+    private running;
+    private wakeSubscription;
+    private wakeQueued;
+    private intervalMs;
+    private started;
+    constructor(options: OutboxRelayOptions);
+    tick(): Promise<OutboxTickResult>;
+    /** Runs a tick, waits `intervalMs` or a wake-up, runs the next: ticks never overlap. */
+    start(options: {
+        readonly intervalMs: number;
+    }): void;
+    /** Stops scheduling and resolves once the tick in progress, if any, has finished. */
+    stop(): Promise<void>;
+    private claim;
+    private relayGroup;
+    /** Publishes one record; when it fails and has a key, says until when its successors wait. */
+    private relayRecord;
+    private recordFailure;
+    private delayAfter;
+    /** Reschedules a record with the head of its key; the claim it cost is not an attempt. */
+    private holdBack;
+    private wake;
+    private loop;
+    private scheduleNext;
+}
+//# sourceMappingURL=outbox-relay.d.ts.map

package/dist/relay/outbox-relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-relay.d.ts","sourceRoot":"","sources":["../../src/relay/outbox-relay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAE7F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAM7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,qFAAqF;IACrF,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,mBAAmB;IACnB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;IACjC,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAC3D;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,MAAM,GAAG,SAAS,CAAC;CAClE;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,gGAAgG;AAChG,eAAO,MAAM,cAAc,0BAA0B,CAAC;AAStD;;;;;;;;;;;;GAYG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IAEpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA4B;IAEtD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAE9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAElD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;IAElE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IAEjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAE/C,OAAO,CAAC,KAAK,CAA4C;IAEzD,OAAO,CAAC,OAAO,CAA+B;IAE9C,OAAO,CAAC,gBAAgB,CAAsC;IAE9D,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,UAAU,CAAK;IAEvB,OAAO,CAAC,OAAO,CAAS;IAExB,YAAY,OAAO,EAAE,kBAAkB,EAUtC;IAEK,IAAI,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAmBtC;IAED,wFAAwF;IACxF,KAAK,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAapD;IAED,qFAAqF;IAC/E,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAQ1B;YAEa,KAAK;YAcL,UAAU;IAUxB,8FAA8F;YAChF,WAAW;YAkBX,aAAa;IAqB3B,OAAO,CAAC,UAAU;IAMlB,0FAA0F;YAC5E,QAAQ;IAUtB,OAAO,CAAC,IAAI;IAeZ,OAAO,CAAC,IAAI;IAWZ,OAAO,CAAC,YAAY;CAgBrB"}

package/dist/relay/outbox-relay.js

@@ -0,0 +1,193 @@
+import { errorCode } from './error-code.js';
+import { KeyOrder } from './key-order.js';
+/** Code stored on a record that waits for an earlier record of its key. It is not a failure. */
+export const HELD_FOR_ORDER = 'OUTBOX_HELD_FOR_ORDER';
+/**
+ * Moves stored events to the provider, at least once.
+ *
+ * By default ordering is NOT guaranteed, not even per aggregate: a failed event is retried
+ * later while its successors go out, and several relays may run side by side. Consumers must
+ * not rely on the order of arrival; carry a sequence or a version in the payload when order
+ * matters.
+ *
+ * With `ordering: 'per-key'` the records of one key go out in the order this relay first saw
+ * them, and a failed one holds its successors back until it is published or dead. The memory
+ * of it lives in the relay: run a single relay, and expect a record in backoff to be
+ * overtaken once if the process restarts meanwhile. A dead record no longer blocks its key.
+ */
+export class OutboxRelay {
+    store;
+    publisher;
+    clock;
+    batchSize;
+    maxAttempts;
+    backoff;
+    onFailure;
+    wakeOn;
+    order;
+    timer;
+    running;
+    wakeSubscription;
+    wakeQueued = false;
+    intervalMs = 0;
+    started = false;
+    constructor(options) {
+        this.store = options.store;
+        this.publisher = options.publisher;
+        this.clock = options.clock;
+        this.batchSize = options.batchSize ?? 100;
+        this.maxAttempts = options.maxAttempts ?? 8;
+        this.backoff = backoffOf(options.backoff);
+        this.onFailure = options.onFailure ?? (() => undefined);
+        this.wakeOn = options.wakeOn;
+        this.order = new KeyOrder(orderingKeyOf(options));
+    }
+    async tick() {
+        const tick = await this.claim();
+        try {
+            for (const group of tick.groups) {
+                await this.relayGroup(group, tick);
+            }
+        }
+        catch (error) {
+            this.order.suspend(tick.groups, tick.settled);
+            throw error;
+        }
+        finally {
+            // Also when the store fails mid-batch: what did go out must not go out twice for that.
+            if (tick.published.length > 0) {
+                await this.store.markPublished(tick.published, this.clock.now());
+            }
+        }
+        return { published: tick.published.length, failed: tick.failed };
+    }
+    /** Runs a tick, waits `intervalMs` or a wake-up, runs the next: ticks never overlap. */
+    start(options) {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.intervalMs = options.intervalMs;
+        this.wakeSubscription = this.wakeOn?.subscribe(() => {
+            this.wake();
+        });
+        this.loop();
+    }
+    /** Stops scheduling and resolves once the tick in progress, if any, has finished. */
+    async stop() {
+        this.started = false;
+        this.wakeQueued = false;
+        this.wakeSubscription?.unsubscribe();
+        this.wakeSubscription = undefined;
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.running;
+    }
+    async claim() {
+        const now = this.clock.now();
+        const records = await this.store.claimBatch(this.batchSize, now);
+        return {
+            now,
+            complete: records.length < this.batchSize,
+            groups: this.order.groups(records),
+            published: [],
+            settled: new Set(),
+            failed: 0,
+        };
+    }
+    async relayGroup(group, tick) {
+        let hold = this.order.holdOf(group, tick);
+        for (const record of group.records) {
+            hold = hold === undefined ? await this.relayRecord(record, group.key, tick) : await this.holdBack(record, hold);
+            tick.settled.add(record.event.id);
+        }
+    }
+    /** Publishes one record; when it fails and has a key, says until when its successors wait. */
+    async relayRecord(record, key, tick) {
+        try {
+            // One by one: a batch publication would make one poisoned event fail its neighbours.
+            await this.publisher.publish([record.event]);
+        }
+        catch (error) {
+            tick.failed += 1;
+            const retryAt = await this.recordFailure(record, key, errorCode(error));
+            return key === undefined ? undefined : retryAt;
+        }
+        tick.published.push(record.event.id);
+        this.order.settle(key, record.event.id);
+        return undefined;
+    }
+    async recordFailure(record, key, code) {
+        const attempts = this.order.attemptsOf(record);
+        const dead = attempts >= this.maxAttempts;
+        const nextAttemptAt = dead ? null : new Date(this.clock.now().getTime() + this.delayAfter(attempts));
+        if (nextAttemptAt === null) {
+            this.order.settle(key, record.event.id);
+        }
+        else {
+            this.order.block(key, record.event.id, nextAttemptAt);
+        }
+        await this.store.markFailed(record.event.id, { code }, nextAttemptAt);
+        const { id: eventId, type: eventType } = record.event;
+        this.onFailure({ kind: 'publish', eventId, eventType, code, attempts, dead });
+        return nextAttemptAt ?? undefined;
+    }
+    delayAfter(attempts) {
+        const { baseMs, factor, maxMs } = this.backoff;
+        return Math.min(maxMs, baseMs * factor ** Math.max(0, attempts - 1));
+    }
+    /** Reschedules a record with the head of its key; the claim it cost is not an attempt. */
+    async holdBack(record, hold) {
+        this.order.countHold(record.event.id);
+        if (hold !== 'lease-expiry') {
+            await this.store.markFailed(record.event.id, { code: HELD_FOR_ORDER }, hold);
+        }
+        return hold;
+    }
+    wake() {
+        if (!this.started) {
+            return;
+        }
+        if (this.running !== undefined) {
+            this.wakeQueued = true;
+            return;
+        }
+        clearTimeout(this.timer);
+        this.loop();
+    }
+    loop() {
+        this.running = this.tick()
+            .catch((error) => {
+            this.onFailure({ kind: 'tick', code: errorCode(error) });
+        })
+            .finally(() => {
+            this.running = undefined;
+            this.scheduleNext();
+        });
+    }
+    scheduleNext() {
+        if (!this.started) {
+            return;
+        }
+        if (this.wakeQueued) {
+            this.wakeQueued = false;
+            this.loop();
+            return;
+        }
+        this.timer = setTimeout(() => {
+            this.loop();
+        }, this.intervalMs);
+    }
+}
+function backoffOf(backoff = {}) {
+    return {
+        baseMs: backoff.baseMs ?? 1_000,
+        factor: backoff.factor ?? 2,
+        maxMs: backoff.maxMs ?? 300_000,
+    };
+}
+function orderingKeyOf(options) {
+    const withoutKey = () => undefined;
+    return options.ordering === 'per-key' ? (options.keyOf ?? withoutKey) : withoutKey;
+}
+//# sourceMappingURL=outbox-relay.js.map

package/dist/relay/outbox-relay.js.map

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

package/dist/relay/record-group.d.ts

@@ -0,0 +1,6 @@
+import type { KeyedRecord } from './keyed-record.js';
+export interface RecordGroup<R extends KeyedRecord> {
+    readonly key: string | undefined;
+    readonly records: readonly R[];
+}
+//# sourceMappingURL=record-group.d.ts.map

package/dist/relay/record-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-group.d.ts","sourceRoot":"","sources":["../../src/relay/record-group.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,WAAW;IAChD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;CAChC"}

package/dist/relay/record-group.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=record-group.js.map

package/dist/relay/record-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-group.js","sourceRoot":"","sources":["../../src/relay/record-group.ts"],"names":[],"mappings":""}

package/dist/relay/relay-signal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * How a store tells a relay that records were appended, so the relay can sleep on a long
+ * interval and still publish at once: PostgreSQL `LISTEN/NOTIFY`, a change stream, or
+ * `InMemoryRelaySignal` in a single process.
+ *
+ * A signal is a hint, never a delivery guarantee: a notification may be lost (connection
+ * dropped, process restarting), which must only delay the publication until the next poll.
+ */
+export declare abstract class RelaySignal {
+    static readonly tokenKey = "events.RelaySignal";
+    abstract subscribe(listener: () => void): {
+        unsubscribe(): void;
+    };
+}
+//# sourceMappingURL=relay-signal.d.ts.map

package/dist/relay/relay-signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-signal.d.ts","sourceRoot":"","sources":["../../src/relay/relay-signal.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,8BAAsB,WAAW;IAC/B,MAAM,CAAC,QAAQ,CAAC,QAAQ,wBAAwB;IAEhD,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG;QAAE,WAAW,IAAI,IAAI,CAAA;KAAE,CAAC;CACnE"}

package/dist/relay/relay-signal.js

@@ -0,0 +1,12 @@
+/**
+ * How a store tells a relay that records were appended, so the relay can sleep on a long
+ * interval and still publish at once: PostgreSQL `LISTEN/NOTIFY`, a change stream, or
+ * `InMemoryRelaySignal` in a single process.
+ *
+ * A signal is a hint, never a delivery guarantee: a notification may be lost (connection
+ * dropped, process restarting), which must only delay the publication until the next poll.
+ */
+export class RelaySignal {
+    static tokenKey = 'events.RelaySignal';
+}
+//# sourceMappingURL=relay-signal.js.map

package/dist/relay/relay-signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-signal.js","sourceRoot":"","sources":["../../src/relay/relay-signal.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,OAAgB,WAAW;IAC/B,MAAM,CAAU,QAAQ,GAAG,oBAAoB,CAAC;CAGjD"}

package/dist/subscription/consume.d.ts

@@ -0,0 +1,18 @@
+import type { IntegrationEvent, ProcessedEventStore, UnitOfWork } from '@ddd-ts-kit/kernel';
+import type { IntegrationEventDefinition } from '../definition/integration-event-definition.js';
+import type { EventScopeOptions } from './event-scope-options.js';
+import type { EventSubscription } from './event-subscription.js';
+export interface ConsumeOptions extends EventScopeOptions {
+    /** Name of the consuming context or handler: the idempotency scope. */
+    readonly consumer: string;
+    readonly processed: ProcessedEventStore;
+    /** The unit of work the mark and the state change of the handler commit in. */
+    readonly unitOfWork: UnitOfWork;
+}
+/**
+ * The consumer of `events/consumer-idempotent`: deduplication and the handler run in ONE
+ * unit of work, so "processed" and the state change it stands for commit or roll back
+ * together. An event whose handler threw is handled again when it is redelivered.
+ */
+export declare function consume<P>(definition: IntegrationEventDefinition<P>, options: ConsumeOptions, handler: (event: IntegrationEvent<P>) => Promise<void>): EventSubscription;
+//# sourceMappingURL=consume.d.ts.map

package/dist/subscription/consume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume.d.ts","sourceRoot":"","sources":["../../src/subscription/consume.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC5F,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+CAA+C,CAAC;AAChG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGjE,MAAM,WAAW,cAAe,SAAQ,iBAAiB;IACvD,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,UAAU,EAAE,0BAA0B,CAAC,CAAC,CAAC,EACzC,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GACrD,iBAAiB,CAEnB"}

package/dist/subscription/consume.js

@@ -0,0 +1,10 @@
+import { on } from './on.js';
+/**
+ * The consumer of `events/consumer-idempotent`: deduplication and the handler run in ONE
+ * unit of work, so "processed" and the state change it stands for commit or roll back
+ * together. An event whose handler threw is handled again when it is redelivered.
+ */
+export function consume(definition, options, handler) {
+    return on(definition, handler, options);
+}
+//# sourceMappingURL=consume.js.map

package/dist/subscription/consume.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume.js","sourceRoot":"","sources":["../../src/subscription/consume.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAU7B;;;;GAIG;AACH,MAAM,UAAU,OAAO,CACrB,UAAyC,EACzC,OAAuB,EACvB,OAAsD;IAEtD,OAAO,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAC1C,CAAC"}

package/dist/subscription/event-scope-options.d.ts

@@ -0,0 +1,13 @@
+import type { Actor, ExecutionScope, IntegrationEvent } from '@ddd-ts-kit/kernel';
+/** How a consumed event becomes the execution context of its handler. */
+export interface EventScopeOptions {
+    /**
+     * When given, the handler, its idempotency mark and its unit of work run inside
+     * `scope.run(...)`: origin `event`, the correlation of the event (its id when it names
+     * none), the event as cause, and the consumer as system actor.
+     */
+    readonly scope?: ExecutionScope;
+    /** The actor an event names, for a project whose envelopes carry a reference to one. */
+    readonly actorOf?: (event: IntegrationEvent) => Actor | undefined;
+}
+//# sourceMappingURL=event-scope-options.d.ts.map

package/dist/subscription/event-scope-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-scope-options.d.ts","sourceRoot":"","sources":["../../src/subscription/event-scope-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAElF,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAChC,wFAAwF;IACxF,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,KAAK,GAAG,SAAS,CAAC;CACnE"}

package/dist/subscription/event-scope-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-scope-options.js.map

package/dist/subscription/event-scope-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-scope-options.js","sourceRoot":"","sources":["../../src/subscription/event-scope-options.ts"],"names":[],"mappings":""}

package/dist/subscription/event-subscription.d.ts

@@ -0,0 +1,6 @@
+import type { IntegrationEventCallback } from '@ddd-ts-kit/kernel';
+export interface EventSubscription {
+    readonly type: string;
+    readonly handler: IntegrationEventCallback;
+}
+//# sourceMappingURL=event-subscription.d.ts.map

package/dist/subscription/event-subscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-subscription.d.ts","sourceRoot":"","sources":["../../src/subscription/event-subscription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAEnE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;CAC5C"}

package/dist/subscription/event-subscription.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-subscription.js.map

package/dist/subscription/event-subscription.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-subscription.js","sourceRoot":"","sources":["../../src/subscription/event-subscription.ts"],"names":[],"mappings":""}

package/dist/subscription/on.d.ts

@@ -0,0 +1,26 @@
+import { type IntegrationEvent, type ProcessedEventStore, type UnitOfWork } from '@ddd-ts-kit/kernel';
+import type { IntegrationEventDefinition } from '../definition/integration-event-definition.js';
+import type { EventScopeOptions } from './event-scope-options.js';
+import type { EventSubscription } from './event-subscription.js';
+export interface OnOptions extends EventScopeOptions {
+    /** Name of the consuming context or handler: the idempotency scope. */
+    readonly consumer: string;
+    /** When given, a redelivered event is handled once per consumer. */
+    readonly processed?: ProcessedEventStore;
+    /**
+     * When given with `processed`, the mark and the handler run in this one unit of work, so
+     * they commit together and a failed handler takes its mark back with it.
+     */
+    readonly unitOfWork?: UnitOfWork;
+}
+/**
+ * Typed subscription to one version of one event. Another version of the same type is
+ * skipped (subscribe to it with its own definition); an invalid payload throws so that the
+ * provider retries or dead-letters instead of silently losing the event.
+ *
+ * With `processed` alone, the mark is taken before the handler runs and survives its failure
+ * unless the store is transactional and already inside a unit of work, or is a
+ * `ReleasableProcessedEventStore`. Prefer `consume`, or pass `unitOfWork`.
+ */
+export declare function on<P>(definition: IntegrationEventDefinition<P>, handler: (event: IntegrationEvent<P>) => Promise<void>, options?: OnOptions): EventSubscription;
+//# sourceMappingURL=on.d.ts.map

package/dist/subscription/on.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on.d.ts","sourceRoot":"","sources":["../../src/subscription/on.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+CAA+C,CAAC;AAEhG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGjE,MAAM,WAAW,SAAU,SAAQ,iBAAiB;IAClD,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,SAAS,CAAC,EAAE,mBAAmB,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;CAClC;AAED;;;;;;;;GAQG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAClB,UAAU,EAAE,0BAA0B,CAAC,CAAC,CAAC,EACzC,OAAO,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,EACtD,OAAO,CAAC,EAAE,SAAS,GAClB,iBAAiB,CAmBnB"}

package/dist/subscription/on.js

@@ -0,0 +1,62 @@
+import { executionContextOfEvent, } from '@ddd-ts-kit/kernel';
+import { InvalidEventPayloadError } from '../definition/invalid-event-payload-error.js';
+/**
+ * Typed subscription to one version of one event. Another version of the same type is
+ * skipped (subscribe to it with its own definition); an invalid payload throws so that the
+ * provider retries or dead-letters instead of silently losing the event.
+ *
+ * With `processed` alone, the mark is taken before the handler runs and survives its failure
+ * unless the store is transactional and already inside a unit of work, or is a
+ * `ReleasableProcessedEventStore`. Prefer `consume`, or pass `unitOfWork`.
+ */
+export function on(definition, handler, options) {
+    return {
+        type: definition.type,
+        handler: async (event) => {
+            const parsed = definition.parse(event);
+            if (!parsed.ok) {
+                if (parsed.error.reason === 'invalid-payload') {
+                    throw new InvalidEventPayloadError(event.type, event.version, parsed.error.issues);
+                }
+                return;
+            }
+            // Deduplicated only once the event is known to be ours and valid, so a skipped or
+            // rejected delivery never consumes the idempotency key.
+            await inScope(event, options, () => handleOnce(event.id, options, () => handler(parsed.value)));
+        },
+    };
+}
+function inScope(event, options, work) {
+    if (options?.scope === undefined) {
+        return work();
+    }
+    return options.scope.run(executionContextOfEvent(event, options), work);
+}
+async function handleOnce(eventId, options, handle) {
+    const processed = options?.processed;
+    if (options === undefined || processed === undefined) {
+        await handle();
+        return;
+    }
+    const mark = { taken: false };
+    try {
+        await (options.unitOfWork ?? WITHOUT_TRANSACTION).run(async () => {
+            mark.taken = await processed.markProcessed(options.consumer, eventId);
+            if (mark.taken) {
+                await handle();
+            }
+        });
+    }
+    catch (error) {
+        // Only a mark taken by this delivery: one left by an earlier success must stay.
+        if (mark.taken && isReleasable(processed)) {
+            await processed.release(options.consumer, eventId);
+        }
+        throw error;
+    }
+}
+const WITHOUT_TRANSACTION = { run: (work) => work() };
+function isReleasable(store) {
+    return typeof store.release === 'function';
+}
+//# sourceMappingURL=on.js.map

package/dist/subscription/on.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"on.js","sourceRoot":"","sources":["../../src/subscription/on.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,GAIxB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AAiBxF;;;;;;;;GAQG;AACH,MAAM,UAAU,EAAE,CAChB,UAAyC,EACzC,OAAsD,EACtD,OAAmB;IAEnB,OAAO;QACL,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;YACvB,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAEvC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;gBACf,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,KAAK,iBAAiB,EAAE,CAAC;oBAC9C,MAAM,IAAI,wBAAwB,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBACrF,CAAC;gBAED,OAAO;YACT,CAAC;YAED,kFAAkF;YAClF,wDAAwD;YACxD,MAAM,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAClG,CAAC;KACF,CAAC;AACJ,CAAC;AAED,SAAS,OAAO,CAAC,KAAuB,EAAE,OAA8B,EAAE,IAAyB;IACjG,IAAI,OAAO,EAAE,KAAK,KAAK,SAAS,EAAE,CAAC;QACjC,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC;IAED,OAAO,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,uBAAuB,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;AAC1E,CAAC;AAED,KAAK,UAAU,UAAU,CAAC,OAAe,EAAE,OAA8B,EAAE,MAA2B;IACpG,MAAM,SAAS,GAAG,OAAO,EAAE,SAAS,CAAC;IAErC,IAAI,OAAO,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QACrD,MAAM,MAAM,EAAE,CAAC;QAEf,OAAO;IACT,CAAC;IAED,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IAE9B,IAAI,CAAC;QACH,MAAM,CAAC,OAAO,CAAC,UAAU,IAAI,mBAAmB,CAAC,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;YAC/D,IAAI,CAAC,KAAK,GAAG,MAAM,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAEtE,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,MAAM,MAAM,EAAE,CAAC;YACjB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,gFAAgF;QAChF,IAAI,IAAI,CAAC,KAAK,IAAI,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1C,MAAM,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACrD,CAAC;QAED,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,MAAM,mBAAmB,GAAe,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC;AAElE,SAAS,YAAY,CAAC,KAA0B;IAC9C,OAAO,OAAO,KAAK,CAAC,OAAO,KAAK,UAAU,CAAC;AAC7C,CAAC"}

package/dist/subscription/releasable-processed-event-store.d.ts

@@ -0,0 +1,14 @@
+import type { ProcessedEventStore } from '@ddd-ts-kit/kernel';
+/**
+ * A processed-event store that can take a mark back. A store that is not transactional needs
+ * it: with no rollback to erase the mark of a handler that failed, the redelivery would be
+ * skipped and the event lost.
+ *
+ * It narrows the `ProcessedEventStore` port, whose `release` is optional, and is not a port
+ * itself: a composition root binds its store under `ProcessedEventStore`.
+ */
+export interface ReleasableProcessedEventStore extends ProcessedEventStore {
+    /** Forgets `(consumer, eventId)`: the next delivery is handled again. */
+    release(consumer: string, eventId: string): Promise<void>;
+}
+//# sourceMappingURL=releasable-processed-event-store.d.ts.map

package/dist/subscription/releasable-processed-event-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"releasable-processed-event-store.d.ts","sourceRoot":"","sources":["../../src/subscription/releasable-processed-event-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,WAAW,6BAA8B,SAAQ,mBAAmB;IACxE,yEAAyE;IACzE,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D"}

package/dist/subscription/releasable-processed-event-store.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=releasable-processed-event-store.js.map

package/dist/subscription/releasable-processed-event-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"releasable-processed-event-store.js","sourceRoot":"","sources":["../../src/subscription/releasable-processed-event-store.ts"],"names":[],"mappings":""}

package/dist/subscription/subscribe-all.d.ts

@@ -0,0 +1,5 @@
+import type { IntegrationEventSubscriber, Subscription } from '@ddd-ts-kit/kernel';
+import type { EventSubscription } from './event-subscription.js';
+/** Registers every subscription and returns one handle that removes them all. */
+export declare function subscribeAll(subscriber: IntegrationEventSubscriber, subscriptions: readonly EventSubscription[]): Subscription;
+//# sourceMappingURL=subscribe-all.d.ts.map

package/dist/subscription/subscribe-all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe-all.d.ts","sourceRoot":"","sources":["../../src/subscription/subscribe-all.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,iFAAiF;AACjF,wBAAgB,YAAY,CAC1B,UAAU,EAAE,0BAA0B,EACtC,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,YAAY,CAUd"}

package/dist/subscription/subscribe-all.js

@@ -0,0 +1,12 @@
+/** Registers every subscription and returns one handle that removes them all. */
+export function subscribeAll(subscriber, subscriptions) {
+    const handles = subscriptions.map(({ type, handler }) => subscriber.subscribe(type, handler));
+    return {
+        unsubscribe: () => {
+            for (const handle of handles) {
+                handle.unsubscribe();
+            }
+        },
+    };
+}
+//# sourceMappingURL=subscribe-all.js.map

package/dist/subscription/subscribe-all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe-all.js","sourceRoot":"","sources":["../../src/subscription/subscribe-all.ts"],"names":[],"mappings":"AAGA,iFAAiF;AACjF,MAAM,UAAU,YAAY,CAC1B,UAAsC,EACtC,aAA2C;IAE3C,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAE9F,OAAO;QACL,WAAW,EAAE,GAAG,EAAE;YAChB,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;gBAC7B,MAAM,CAAC,WAAW,EAAE,CAAC;YACvB,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}