@apso/domain-events 0.1.0

package/dist/domain-event.entity.js

@@ -0,0 +1,62 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainEvent = void 0;
+const typeorm_1 = require("typeorm");
+/**
+ * DomainEvent is a durable, append-only log of domain state changes.
+ *
+ * Rows are written in the SAME database transaction as the state change that
+ * produced them (see {@link DomainEventSubscriber}), which is what makes
+ * delivery durable. This implements the standard "transactional outbox"
+ * pattern, but is surfaced with generic domain-event naming — no public
+ * artifact is named "outbox".
+ *
+ * A separate {@link DomainEventRelay} polls pending rows and delivers them.
+ * Because the stable `id` is preserved across delivery attempts, consumers can
+ * dedupe on it for at-least-once delivery semantics.
+ */
+let DomainEvent = class DomainEvent {
+};
+exports.DomainEvent = DomainEvent;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], DomainEvent.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar' }),
+    __metadata("design:type", String)
+], DomainEvent.prototype, "type", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb' }),
+    __metadata("design:type", Object)
+], DomainEvent.prototype, "payload", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', default: 'pending' }),
+    __metadata("design:type", String)
+], DomainEvent.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', default: 0 }),
+    __metadata("design:type", Number)
+], DomainEvent.prototype, "attempts", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], DomainEvent.prototype, "created_at", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Object)
+], DomainEvent.prototype, "publishedAt", void 0);
+exports.DomainEvent = DomainEvent = __decorate([
+    (0, typeorm_1.Index)(['status', 'created_at']),
+    (0, typeorm_1.Entity)('events')
+], DomainEvent);
+//# sourceMappingURL=domain-event.entity.js.map

package/dist/domain-event.entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event.entity.js","sourceRoot":"","sources":["../src/domain-event.entity.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,qCAMiB;AAEjB;;;;;;;;;;;;GAYG;AAGI,IAAM,WAAW,GAAjB,MAAM,WAAW;CA0BvB,CAAA;AA1BY,kCAAW;AAEtB;IADC,IAAA,gCAAsB,EAAC,MAAM,CAAC;;uCACnB;AAIZ;IADC,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;;yCACd;AAId;IADC,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;;4CACQ;AAIlC;IADC,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;;2CACJ;AAI5C;IADC,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;;6CAClB;AAGlB;IADC,IAAA,0BAAgB,EAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;8BAC7B,IAAI;+CAAC;AAIlB;IADC,IAAA,gBAAM,EAAC,EAAE,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;gDACtB;sBAzBf,WAAW;IAFvB,IAAA,eAAK,EAAC,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;IAC/B,IAAA,gBAAM,EAAC,QAAQ,CAAC;GACJ,WAAW,CA0BvB"}

package/dist/domain-event.mapper.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Action that produced a domain event.
+ */
+export type DomainEventAction = 'created' | 'updated' | 'removed';
+/**
+ * DI token for the {@link DomainEventMapper}.
+ *
+ * {@link DomainEventsModule} binds this token to {@link DefaultDomainEventMapper}.
+ * Your application can override it by providing its own implementation:
+ *
+ *   { provide: DOMAIN_EVENT_MAPPER, useClass: MyDomainEventMapper }
+ */
+export declare const DOMAIN_EVENT_MAPPER = "DOMAIN_EVENT_MAPPER";
+/**
+ * DomainEventMapper is the extension point that keeps application semantics
+ * (event-type taxonomy, payload shape) OUT of the library. Provide your own
+ * implementation under {@link DOMAIN_EVENT_MAPPER} to customize.
+ */
+export interface DomainEventMapper {
+    /**
+     * Maps an entity name + action to an event type string, e.g.
+     * ("Product", "created") -> "product.created".
+     */
+    eventType(entityName: string, action: DomainEventAction): string;
+    /**
+     * Builds the serializable payload for an event from the changed entity.
+     */
+    toPayload(entity: unknown, action: DomainEventAction): Record<string, unknown>;
+}
+/**
+ * Default mapper. Uses an `entity.action` type taxonomy (entity name
+ * lower-camel-cased) and returns the entity as-is (shallow) as the payload.
+ *
+ * Override by providing your own {@link DomainEventMapper} under
+ * {@link DOMAIN_EVENT_MAPPER}.
+ */
+export declare class DefaultDomainEventMapper implements DomainEventMapper {
+    eventType(entityName: string, action: DomainEventAction): string;
+    toPayload(entity: unknown, _action: DomainEventAction): Record<string, unknown>;
+}
+//# sourceMappingURL=domain-event.mapper.d.ts.map

package/dist/domain-event.mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event.mapper.d.ts","sourceRoot":"","sources":["../src/domain-event.mapper.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,wBAAwB,CAAC;AAEzD;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAAC;IAEjE;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChF;AAED;;;;;;GAMG;AACH,qBACa,wBAAyB,YAAW,iBAAiB;IAChE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,MAAM;IAOhE,SAAS,CACP,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,iBAAiB,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG3B"}

package/dist/domain-event.mapper.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultDomainEventMapper = exports.DOMAIN_EVENT_MAPPER = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * DI token for the {@link DomainEventMapper}.
+ *
+ * {@link DomainEventsModule} binds this token to {@link DefaultDomainEventMapper}.
+ * Your application can override it by providing its own implementation:
+ *
+ *   { provide: DOMAIN_EVENT_MAPPER, useClass: MyDomainEventMapper }
+ */
+exports.DOMAIN_EVENT_MAPPER = 'DOMAIN_EVENT_MAPPER';
+/**
+ * Default mapper. Uses an `entity.action` type taxonomy (entity name
+ * lower-camel-cased) and returns the entity as-is (shallow) as the payload.
+ *
+ * Override by providing your own {@link DomainEventMapper} under
+ * {@link DOMAIN_EVENT_MAPPER}.
+ */
+let DefaultDomainEventMapper = class DefaultDomainEventMapper {
+    eventType(entityName, action) {
+        const normalized = entityName
+            ? entityName.charAt(0).toLowerCase() + entityName.slice(1)
+            : entityName;
+        return `${normalized}.${action}`;
+    }
+    toPayload(entity, _action) {
+        return { ...entity };
+    }
+};
+exports.DefaultDomainEventMapper = DefaultDomainEventMapper;
+exports.DefaultDomainEventMapper = DefaultDomainEventMapper = __decorate([
+    (0, common_1.Injectable)()
+], DefaultDomainEventMapper);
+//# sourceMappingURL=domain-event.mapper.js.map

package/dist/domain-event.mapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event.mapper.js","sourceRoot":"","sources":["../src/domain-event.mapper.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAA4C;AAO5C;;;;;;;GAOG;AACU,QAAA,mBAAmB,GAAG,qBAAqB,CAAC;AAoBzD;;;;;;GAMG;AAEI,IAAM,wBAAwB,GAA9B,MAAM,wBAAwB;IACnC,SAAS,CAAC,UAAkB,EAAE,MAAyB;QACrD,MAAM,UAAU,GAAG,UAAU;YAC3B,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;YAC1D,CAAC,CAAC,UAAU,CAAC;QACf,OAAO,GAAG,UAAU,IAAI,MAAM,EAAE,CAAC;IACnC,CAAC;IAED,SAAS,CACP,MAAe,EACf,OAA0B;QAE1B,OAAO,EAAE,GAAI,MAAkC,EAAE,CAAC;IACpD,CAAC;CACF,CAAA;AAdY,4DAAwB;mCAAxB,wBAAwB;IADpC,IAAA,mBAAU,GAAE;GACA,wBAAwB,CAcpC"}

package/dist/domain-event.relay.d.ts

@@ -0,0 +1,80 @@
+import { OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common';
+import { Repository } from 'typeorm';
+import { DomainEvent } from './domain-event.entity';
+import { DeliveryDestination } from './destinations';
+/**
+ * Maximum number of delivery attempts before an event is marked 'failed'.
+ */
+export declare const MAX_ATTEMPTS = 5;
+/**
+ * Default poll interval (ms) for the self-contained drain loop.
+ */
+export declare const DEFAULT_POLL_INTERVAL_MS = 5000;
+/**
+ * DI token carrying the poll interval (ms) for the relay's self-contained
+ * poller. Provided by {@link DomainEventsModule.forRoot}.
+ */
+export declare const DOMAIN_EVENT_POLL_INTERVAL = "DOMAIN_EVENT_POLL_INTERVAL";
+/**
+ * DomainEventRelay drains the durable `events` table and delivers pending
+ * events. It is the consumer side of the transactional-outbox pattern: the
+ * subscriber writes events transactionally, the relay publishes them
+ * asynchronously with at-least-once semantics.
+ *
+ * SELF-CONTAINED POLLER: on application bootstrap the relay starts its own
+ * `setInterval` drain loop and clears it on shutdown. It depends on NO external
+ * scheduler package (no `@nestjs/schedule`). The interval defaults to
+ * {@link DEFAULT_POLL_INTERVAL_MS} and is configurable via `forRoot`.
+ *
+ * DELIVERY: `publish()` fans each event out to every ACTIVE
+ * {@link DeliveryDestination} (chosen at runtime via the `EVENTS_DESTINATION`
+ * env var). Any thrown error bubbles so the relay retries.
+ *
+ * DUPLICATES — IMPORTANT: delivery is tracked at the event grain (a single
+ * `events.status`), NOT per (event × destination). With MORE THAN ONE active
+ * destination, a failure in any one destination retries the WHOLE event, so the
+ * healthy destinations receive the event AGAIN on every retry. Consumer-side
+ * dedupe on `event.id` is therefore MANDATORY, not optional, whenever you run
+ * multiple destinations. (A single destination — the common case — never
+ * duplicates beyond ordinary at-least-once.) You can override `publish()` to
+ * change this behavior.
+ */
+export declare class DomainEventRelay implements OnApplicationBootstrap, OnModuleDestroy {
+    private readonly events;
+    private readonly destinations;
+    private readonly pollIntervalMs;
+    private readonly logger;
+    private timer?;
+    private draining;
+    constructor(events: Repository<DomainEvent>, destinations?: DeliveryDestination[], pollIntervalMs?: number);
+    /**
+     * Starts the self-contained periodic drain. Called by Nest on app bootstrap.
+     */
+    onApplicationBootstrap(): void;
+    /**
+     * Stops the periodic drain. Called by Nest on shutdown.
+     */
+    onModuleDestroy(): void;
+    /**
+     * One non-overlapping drain pass. Errors are swallowed (logged) so a single
+     * bad tick never kills the interval.
+     */
+    private tick;
+    /**
+     * Load pending events oldest-first and deliver each. On success the event is
+     * marked `published` with `publishedAt`; on failure `attempts` increments and
+     * the event is marked `failed` once `attempts >= MAX_ATTEMPTS`.
+     */
+    processPending(limit?: number): Promise<void>;
+    /**
+     * Deliver a single domain event.
+     *
+     * Fans the event out to every ACTIVE {@link DeliveryDestination}. Any rejection
+     * bubbles so the relay retries (and, with multiple destinations, re-sends to
+     * ALL of them — see the class doc on mandatory consumer-side dedupe). Override
+     * to change delivery behavior. When no destination is active (empty
+     * EVENTS_DESTINATION), this throws so the misconfiguration surfaces.
+     */
+    publish(event: DomainEvent): Promise<void>;
+}
+//# sourceMappingURL=domain-event.relay.d.ts.map

package/dist/domain-event.relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event.relay.d.ts","sourceRoot":"","sources":["../src/domain-event.relay.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,sBAAsB,EACtB,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,mBAAmB,EAEpB,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B;;GAEG;AACH,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBACa,gBACX,YAAW,sBAAsB,EAAE,eAAe;IAQhD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAGvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAG7B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAZjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAC5D,OAAO,CAAC,KAAK,CAAC,CAAiC;IAC/C,OAAO,CAAC,QAAQ,CAAS;gBAIN,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,EAG/B,YAAY,GAAE,mBAAmB,EAAO,EAGxC,cAAc,GAAE,MAAiC;IAGpE;;OAEG;IACH,sBAAsB,IAAI,IAAI;IAW9B;;OAEG;IACH,eAAe,IAAI,IAAI;IAOvB;;;OAGG;YACW,IAAI;IAelB;;;;OAIG;IACG,cAAc,CAAC,KAAK,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B/C;;;;;;;;OAQG;IACG,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAUjD"}

package/dist/domain-event.relay.js

@@ -0,0 +1,167 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var DomainEventRelay_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainEventRelay = exports.DOMAIN_EVENT_POLL_INTERVAL = exports.DEFAULT_POLL_INTERVAL_MS = exports.MAX_ATTEMPTS = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const domain_event_entity_1 = require("./domain-event.entity");
+const destinations_1 = require("./destinations");
+/**
+ * Maximum number of delivery attempts before an event is marked 'failed'.
+ */
+exports.MAX_ATTEMPTS = 5;
+/**
+ * Default poll interval (ms) for the self-contained drain loop.
+ */
+exports.DEFAULT_POLL_INTERVAL_MS = 5000;
+/**
+ * DI token carrying the poll interval (ms) for the relay's self-contained
+ * poller. Provided by {@link DomainEventsModule.forRoot}.
+ */
+exports.DOMAIN_EVENT_POLL_INTERVAL = 'DOMAIN_EVENT_POLL_INTERVAL';
+/**
+ * DomainEventRelay drains the durable `events` table and delivers pending
+ * events. It is the consumer side of the transactional-outbox pattern: the
+ * subscriber writes events transactionally, the relay publishes them
+ * asynchronously with at-least-once semantics.
+ *
+ * SELF-CONTAINED POLLER: on application bootstrap the relay starts its own
+ * `setInterval` drain loop and clears it on shutdown. It depends on NO external
+ * scheduler package (no `@nestjs/schedule`). The interval defaults to
+ * {@link DEFAULT_POLL_INTERVAL_MS} and is configurable via `forRoot`.
+ *
+ * DELIVERY: `publish()` fans each event out to every ACTIVE
+ * {@link DeliveryDestination} (chosen at runtime via the `EVENTS_DESTINATION`
+ * env var). Any thrown error bubbles so the relay retries.
+ *
+ * DUPLICATES — IMPORTANT: delivery is tracked at the event grain (a single
+ * `events.status`), NOT per (event × destination). With MORE THAN ONE active
+ * destination, a failure in any one destination retries the WHOLE event, so the
+ * healthy destinations receive the event AGAIN on every retry. Consumer-side
+ * dedupe on `event.id` is therefore MANDATORY, not optional, whenever you run
+ * multiple destinations. (A single destination — the common case — never
+ * duplicates beyond ordinary at-least-once.) You can override `publish()` to
+ * change this behavior.
+ */
+let DomainEventRelay = DomainEventRelay_1 = class DomainEventRelay {
+    constructor(events, destinations = [], pollIntervalMs = exports.DEFAULT_POLL_INTERVAL_MS) {
+        this.events = events;
+        this.destinations = destinations;
+        this.pollIntervalMs = pollIntervalMs;
+        this.logger = new common_1.Logger(DomainEventRelay_1.name);
+        this.draining = false;
+    }
+    /**
+     * Starts the self-contained periodic drain. Called by Nest on app bootstrap.
+     */
+    onApplicationBootstrap() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, this.pollIntervalMs);
+        // Don't keep the event loop alive solely for the poller.
+        if (typeof this.timer.unref === 'function') {
+            this.timer.unref();
+        }
+    }
+    /**
+     * Stops the periodic drain. Called by Nest on shutdown.
+     */
+    onModuleDestroy() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    /**
+     * One non-overlapping drain pass. Errors are swallowed (logged) so a single
+     * bad tick never kills the interval.
+     */
+    async tick() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        try {
+            await this.processPending();
+        }
+        catch (error) {
+            this.logger.error('DomainEventRelay drain tick failed', error instanceof Error ? error.stack : undefined);
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+    /**
+     * Load pending events oldest-first and deliver each. On success the event is
+     * marked `published` with `publishedAt`; on failure `attempts` increments and
+     * the event is marked `failed` once `attempts >= MAX_ATTEMPTS`.
+     */
+    async processPending(limit = 50) {
+        const pending = await this.events.find({
+            where: { status: 'pending' },
+            order: { created_at: 'ASC' },
+            take: limit,
+        });
+        for (const event of pending) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                await this.publish(event);
+                event.status = 'published';
+                event.publishedAt = new Date();
+                // eslint-disable-next-line no-await-in-loop
+                await this.events.save(event);
+            }
+            catch (error) {
+                event.attempts += 1;
+                if (event.attempts >= exports.MAX_ATTEMPTS) {
+                    event.status = 'failed';
+                    this.logger.error(`DomainEvent ${event.id} (${event.type}) failed after ${event.attempts} attempts`, error instanceof Error ? error.stack : undefined);
+                }
+                // eslint-disable-next-line no-await-in-loop
+                await this.events.save(event);
+            }
+        }
+    }
+    /**
+     * Deliver a single domain event.
+     *
+     * Fans the event out to every ACTIVE {@link DeliveryDestination}. Any rejection
+     * bubbles so the relay retries (and, with multiple destinations, re-sends to
+     * ALL of them — see the class doc on mandatory consumer-side dedupe). Override
+     * to change delivery behavior. When no destination is active (empty
+     * EVENTS_DESTINATION), this throws so the misconfiguration surfaces.
+     */
+    async publish(event) {
+        if (this.destinations?.length) {
+            await Promise.all(this.destinations.map((d) => d.send(event)));
+            return;
+        }
+        throw new Error('DomainEventRelay.publish() has no active destinations — set ' +
+            'EVENTS_DESTINATION (comma-separated) or override publish()');
+    }
+};
+exports.DomainEventRelay = DomainEventRelay;
+exports.DomainEventRelay = DomainEventRelay = DomainEventRelay_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(domain_event_entity_1.DomainEvent)),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)(destinations_1.DOMAIN_EVENT_DESTINATIONS)),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)(exports.DOMAIN_EVENT_POLL_INTERVAL)),
+    __metadata("design:paramtypes", [typeorm_2.Repository, Array, Number])
+], DomainEventRelay);
+//# sourceMappingURL=domain-event.relay.js.map

package/dist/domain-event.relay.js.map

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

package/dist/domain-event.subscriber.d.ts

@@ -0,0 +1,33 @@
+import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
+import { DomainEventMapper } from './domain-event.mapper';
+/**
+ * DI token carrying the set of entity classes that have opted in to
+ * domain-event emission. Provided by {@link DomainEventsModule.forRoot} from the
+ * `entities` it is given. The library NEVER hardcodes this set — it is the
+ * CLI-emitted manifest of opted-in entities.
+ */
+export declare const DOMAIN_EVENT_ENTITIES = "DOMAIN_EVENT_ENTITIES";
+/**
+ * DomainEventSubscriber writes a {@link DomainEvent} row for every
+ * insert/update/remove of an opted-in entity.
+ *
+ * DURABILITY: each row is written via `event.manager` (the EntityManager of the
+ * in-flight transaction), so the event is committed atomically WITH the state
+ * change. This is the durability lever behind the transactional-outbox pattern.
+ *
+ * RECURSION GUARD: we never emit events for {@link DomainEvent} itself, otherwise
+ * each emitted row would itself trigger another emission. Only entities in the
+ * opted-in set (passed to {@link DomainEventsModule.forRoot}) emit; everything
+ * else is skipped.
+ */
+export declare class DomainEventSubscriber implements EntitySubscriberInterface {
+    private readonly mapper;
+    private readonly emittingEntities;
+    constructor(mapper: DomainEventMapper, emittingEntities: Function[], dataSource?: DataSource);
+    private isEmitting;
+    private emit;
+    afterInsert(event: InsertEvent<unknown>): Promise<void>;
+    afterUpdate(event: UpdateEvent<unknown>): Promise<void>;
+    afterRemove(event: RemoveEvent<unknown>): Promise<void>;
+}
+//# sourceMappingURL=domain-event.subscriber.d.ts.map

package/dist/domain-event.subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event.subscriber.d.ts","sourceRoot":"","sources":["../src/domain-event.subscriber.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EAEV,yBAAyB,EAEzB,WAAW,EACX,WAAW,EACX,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAGL,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,qBAEa,qBAAsB,YAAW,yBAAyB;IAEtC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAErB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBAFlB,MAAM,EAAE,iBAAiB,EAEvB,gBAAgB,EAAE,QAAQ,EAAE,EAKhE,UAAU,CAAC,EAAE,UAAU;IAMrC,OAAO,CAAC,UAAU;YAUJ,IAAI;IAoBZ,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvD,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvD,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAU9D"}

package/dist/domain-event.subscriber.js

@@ -0,0 +1,98 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainEventSubscriber = exports.DOMAIN_EVENT_ENTITIES = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const domain_event_entity_1 = require("./domain-event.entity");
+const domain_event_mapper_1 = require("./domain-event.mapper");
+/**
+ * DI token carrying the set of entity classes that have opted in to
+ * domain-event emission. Provided by {@link DomainEventsModule.forRoot} from the
+ * `entities` it is given. The library NEVER hardcodes this set — it is the
+ * CLI-emitted manifest of opted-in entities.
+ */
+exports.DOMAIN_EVENT_ENTITIES = 'DOMAIN_EVENT_ENTITIES';
+/**
+ * DomainEventSubscriber writes a {@link DomainEvent} row for every
+ * insert/update/remove of an opted-in entity.
+ *
+ * DURABILITY: each row is written via `event.manager` (the EntityManager of the
+ * in-flight transaction), so the event is committed atomically WITH the state
+ * change. This is the durability lever behind the transactional-outbox pattern.
+ *
+ * RECURSION GUARD: we never emit events for {@link DomainEvent} itself, otherwise
+ * each emitted row would itself trigger another emission. Only entities in the
+ * opted-in set (passed to {@link DomainEventsModule.forRoot}) emit; everything
+ * else is skipped.
+ */
+let DomainEventSubscriber = class DomainEventSubscriber {
+    constructor(mapper, emittingEntities, dataSource) {
+        this.mapper = mapper;
+        this.emittingEntities = emittingEntities;
+        dataSource?.subscribers?.push(this);
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    isEmitting(target) {
+        // RECURSION GUARD: never emit for DomainEvent itself.
+        if (target === domain_event_entity_1.DomainEvent || target === 'DomainEvent') {
+            return false;
+        }
+        return this.emittingEntities.some((cls) => target === cls || target === cls.name);
+    }
+    async emit(manager, 
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    entityClass, entity, action) {
+        const entityName = entityClass.name;
+        const repo = manager.getRepository(domain_event_entity_1.DomainEvent);
+        // manager keeps us inside the active transaction.
+        await repo.save(repo.create({
+            type: this.mapper.eventType(entityName, action),
+            payload: this.mapper.toPayload(entity, action),
+            status: 'pending',
+            attempts: 0,
+        }));
+    }
+    async afterInsert(event) {
+        if (!this.isEmitting(event.metadata.target))
+            return;
+        await this.emit(event.manager, 
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        event.metadata.target, event.entity, 'created');
+    }
+    async afterUpdate(event) {
+        if (!this.isEmitting(event.metadata.target))
+            return;
+        await this.emit(event.manager, 
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        event.metadata.target, event.entity ?? event.databaseEntity, 'updated');
+    }
+    async afterRemove(event) {
+        if (!this.isEmitting(event.metadata.target))
+            return;
+        await this.emit(event.manager, 
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        event.metadata.target, event.entity ?? event.databaseEntity, 'removed');
+    }
+};
+exports.DomainEventSubscriber = DomainEventSubscriber;
+exports.DomainEventSubscriber = DomainEventSubscriber = __decorate([
+    (0, common_1.Injectable)(),
+    (0, typeorm_1.EventSubscriber)(),
+    __param(0, (0, common_1.Inject)(domain_event_mapper_1.DOMAIN_EVENT_MAPPER)),
+    __param(1, (0, common_1.Inject)(exports.DOMAIN_EVENT_ENTITIES)),
+    __param(2, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [Object, Array, typeorm_1.DataSource])
+], DomainEventSubscriber);
+//# sourceMappingURL=domain-event.subscriber.js.map

package/dist/domain-event.subscriber.js.map

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

package/dist/domain-events.module.d.ts

@@ -0,0 +1,43 @@
+import { DynamicModule, Type } from '@nestjs/common';
+import { DomainEventMapper } from './domain-event.mapper';
+/**
+ * Options for {@link DomainEventsModule.forRoot}.
+ */
+export interface DomainEventsModuleOptions {
+    /**
+     * Entity classes opted in to domain-event emission (the CLI-emitted
+     * manifest). Only state changes to these emit events; the library never
+     * hardcodes this set.
+     */
+    entities: Function[];
+    /**
+     * Optional custom mapper class to bind under {@link DOMAIN_EVENT_MAPPER}.
+     * Defaults to {@link DefaultDomainEventMapper}.
+     */
+    mapper?: Type<DomainEventMapper>;
+    /**
+     * Poll interval (ms) for the relay's self-contained drain loop. Defaults to
+     * {@link DEFAULT_POLL_INTERVAL_MS} (5000).
+     */
+    pollIntervalMs?: number;
+}
+/**
+ * DomainEventsModule wires the durable domain-event spine (transactional-outbox
+ * pattern, surfaced as generic domain events).
+ *
+ * - {@link DomainEventSubscriber} writes events in-transaction with state changes.
+ * - {@link DomainEventRelay} drains and delivers pending events, with its own
+ *   self-contained poller (no external scheduler dependency).
+ * - {@link DOMAIN_EVENT_MAPPER} controls event-type/payload semantics; pass a
+ *   `mapper` to override.
+ * - {@link DOMAIN_EVENT_DESTINATIONS} is the set of ACTIVE delivery adapters,
+ *   built from the `EVENTS_DESTINATION` env var at runtime.
+ *
+ * MULTI-DATASOURCE: `@EventSubscriber()` auto-registers on the default
+ * DataSource; for additional named DataSources, register this module (or the
+ * subscriber) per DataSource.
+ */
+export declare class DomainEventsModule {
+    static forRoot(options: DomainEventsModuleOptions): DynamicModule;
+}
+//# sourceMappingURL=domain-events.module.d.ts.map

package/dist/domain-events.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-events.module.d.ts","sourceRoot":"","sources":["../src/domain-events.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA4B,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAY/E,OAAO,EAGL,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAG/B;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IAEH,QAAQ,EAAE,QAAQ,EAAE,CAAC;IAErB;;;OAGG;IACH,MAAM,CAAC,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAEjC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAEa,kBAAkB;IAC7B,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,yBAAyB,GAAG,aAAa;CAmClE"}