@archi-code/ddd 0.0.0-stage → 3.0.0-alpha.1

package/dist/cjs/exceptions/application/concurrency.exception.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConcurrencyException = void 0;
+const application_exception_1 = require("./application.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class ConcurrencyException extends application_exception_1.ApplicationException {
+    constructor(aggregateName, id, expectedVersion, options = {}) {
+        super(`${aggregateName} with ID ${id} was changed by someone else: expected version ${expectedVersion}.`, [exception_code_1.ExceptionCode.ConcurrencyConflict], options);
+    }
+}
+exports.ConcurrencyException = ConcurrencyException;
+_a = ConcurrencyException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.ConcurrencyConflict);
+})();

package/dist/cjs/exceptions/application/not-allowed.exception.d.ts

@@ -0,0 +1,5 @@
+import { ApplicationException } from './application.exception';
+import type { ExceptionOptions } from '../abstract.exception';
+export declare class NotAllowedException extends ApplicationException {
+    constructor(message: string, options?: ExceptionOptions);
+}

package/dist/cjs/exceptions/application/not-allowed.exception.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAllowedException = void 0;
+const application_exception_1 = require("./application.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class NotAllowedException extends application_exception_1.ApplicationException {
+    constructor(message, options = {}) {
+        super(message, [exception_code_1.ExceptionCode.NotAllowed], options);
+    }
+}
+exports.NotAllowedException = NotAllowedException;
+_a = NotAllowedException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.NotAllowed);
+})();

package/dist/cjs/exceptions/brand/exception-brand.d.ts

@@ -0,0 +1,6 @@
+export declare class ExceptionBrand {
+    static readonly anyCode = "*";
+    static brandClass(exceptionClass: object, code: string): void;
+    static brandInstance(exception: object, codes: readonly string[]): void;
+    static matches(exceptionClass: object, candidate: unknown): boolean;
+}

package/dist/cjs/exceptions/brand/exception-brand.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionBrand = void 0;
+const INSTANCE_CODES = Symbol.for('@archi-code/ddd/exception-codes.v1');
+const CLASS_CODE = Symbol.for('@archi-code/ddd/exception-class-code.v1');
+class ExceptionBrand {
+    static brandClass(exceptionClass, code) {
+        Object.defineProperty(exceptionClass, CLASS_CODE, { value: code });
+    }
+    static brandInstance(exception, codes) {
+        Object.defineProperty(exception, INSTANCE_CODES, { value: Object.freeze([...codes]) });
+    }
+    static matches(exceptionClass, candidate) {
+        if (!Object.prototype.hasOwnProperty.call(exceptionClass, CLASS_CODE)) {
+            return false;
+        }
+        if (typeof candidate !== 'object' || candidate === null) {
+            return false;
+        }
+        const codes = candidate[INSTANCE_CODES];
+        if (!Array.isArray(codes)) {
+            return false;
+        }
+        const code = exceptionClass[CLASS_CODE];
+        return code === ExceptionBrand.anyCode || codes.includes(code);
+    }
+}
+exports.ExceptionBrand = ExceptionBrand;
+ExceptionBrand.anyCode = '*';

package/dist/cjs/exceptions/domain/domain.exception.d.ts

@@ -0,0 +1,6 @@
+import { AbstractException } from '../abstract.exception';
+import type { ExceptionOptions } from '../abstract.exception';
+import { ExceptionCode } from '../exception-code';
+export declare class DomainException extends AbstractException {
+    constructor(message: string, exceptionCodes?: (ExceptionCode | string)[], options?: ExceptionOptions);
+}

package/dist/cjs/exceptions/domain/domain.exception.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainException = void 0;
+const abstract_exception_1 = require("../abstract.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class DomainException extends abstract_exception_1.AbstractException {
+    constructor(message, exceptionCodes = [], options = {}) {
+        super(message, [exception_code_1.ExceptionCode.DomainException, ...exceptionCodes], options);
+    }
+}
+exports.DomainException = DomainException;
+_a = DomainException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.DomainException);
+})();

package/dist/cjs/exceptions/domain/required-value.exception.d.ts

@@ -0,0 +1,4 @@
+import { DomainException } from './domain.exception';
+export declare class RequiredValueException extends DomainException {
+    constructor(typeName: string, receivedValue: unknown);
+}

package/dist/cjs/exceptions/domain/required-value.exception.js

@@ -0,0 +1,21 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredValueException = void 0;
+const domain_exception_1 = require("./domain.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+const received_value_1 = require("../received/received-value");
+class RequiredValueException extends domain_exception_1.DomainException {
+    constructor(typeName, receivedValue) {
+        const received = received_value_1.ReceivedValue.describe(receivedValue);
+        super(`Validation Error: ${typeName} is required, but received ${received}.`, [
+            exception_code_1.ExceptionCode.RequiredValue,
+        ]);
+    }
+}
+exports.RequiredValueException = RequiredValueException;
+_a = RequiredValueException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.RequiredValue);
+})();

package/dist/cjs/exceptions/domain/type-primitive.exception.d.ts

@@ -0,0 +1,4 @@
+import { DomainException } from './domain.exception';
+export declare class TypePrimitiveException extends DomainException {
+    constructor(expectedType: string, receivedValue: unknown, template?: string);
+}

package/dist/cjs/exceptions/domain/type-primitive.exception.js

@@ -0,0 +1,21 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypePrimitiveException = void 0;
+const domain_exception_1 = require("./domain.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+const received_value_1 = require("../received/received-value");
+class TypePrimitiveException extends domain_exception_1.DomainException {
+    constructor(expectedType, receivedValue, template = 'Expected a valid ') {
+        const received = received_value_1.ReceivedValue.describe(receivedValue);
+        super(`Validation Error: ${template}${expectedType}, but received ${received}.`, [
+            exception_code_1.ExceptionCode.TypeFailed,
+        ]);
+    }
+}
+exports.TypePrimitiveException = TypePrimitiveException;
+_a = TypePrimitiveException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.TypeFailed);
+})();

package/dist/cjs/exceptions/domain/validation.exception.d.ts

@@ -0,0 +1,14 @@
+import { DomainException } from './domain.exception';
+export interface ValidationIssue {
+    readonly field: string | null;
+    readonly code: string;
+    readonly message: string;
+}
+export type ValidationIssueInput = Omit<ValidationIssue, 'code'> & {
+    readonly code?: string;
+};
+export declare class ValidationException extends DomainException {
+    readonly errors: readonly ValidationIssue[];
+    constructor(errors: readonly ValidationIssueInput[]);
+    private static describe;
+}

package/dist/cjs/exceptions/domain/validation.exception.js

@@ -0,0 +1,23 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationException = void 0;
+const domain_exception_1 = require("./domain.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class ValidationException extends domain_exception_1.DomainException {
+    constructor(errors) {
+        super(`Validation failed, ${errors.map(_a.describe).join(', ')}`, [
+            exception_code_1.ExceptionCode.ValidationFailed,
+        ]);
+        this.errors = Object.freeze(errors.map(({ field, code = exception_code_1.ExceptionCode.ValidationFailed, message }) => Object.freeze({ field, code, message })));
+    }
+    static describe(issue) {
+        return issue.field === null ? issue.message : `${issue.field}: ${issue.message}`;
+    }
+}
+exports.ValidationException = ValidationException;
+_a = ValidationException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.ValidationFailed);
+})();

package/dist/cjs/exceptions/exception-code.d.ts

@@ -0,0 +1,15 @@
+export declare enum ExceptionCode {
+    DomainException = "DOM000",
+    ValidationFailed = "DOM001",
+    TypeFailed = "DOM003",
+    RequiredValue = "DOM004",
+    ApplicationException = "APP000",
+    ConcurrencyConflict = "APP001",
+    AggregateNotFound = "APP002",
+    NotAllowed = "APP003",
+    InfrastructureException = "INF000",
+    InternalError = "INF001",
+    UnknownEvent = "INF002",
+    EventDelivery = "INF003",
+    ErrorException = "E000"
+}

package/dist/cjs/exceptions/exception-code.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionCode = void 0;
+var ExceptionCode;
+(function (ExceptionCode) {
+    ExceptionCode["DomainException"] = "DOM000";
+    ExceptionCode["ValidationFailed"] = "DOM001";
+    ExceptionCode["TypeFailed"] = "DOM003";
+    ExceptionCode["RequiredValue"] = "DOM004";
+    ExceptionCode["ApplicationException"] = "APP000";
+    ExceptionCode["ConcurrencyConflict"] = "APP001";
+    ExceptionCode["AggregateNotFound"] = "APP002";
+    ExceptionCode["NotAllowed"] = "APP003";
+    ExceptionCode["InfrastructureException"] = "INF000";
+    ExceptionCode["InternalError"] = "INF001";
+    ExceptionCode["UnknownEvent"] = "INF002";
+    ExceptionCode["EventDelivery"] = "INF003";
+    ExceptionCode["ErrorException"] = "E000";
+})(ExceptionCode || (exports.ExceptionCode = ExceptionCode = {}));

package/dist/cjs/exceptions/index.d.ts

@@ -0,0 +1,14 @@
+export * from './abstract.exception';
+export * from './exception-code';
+export * from './application/application.exception';
+export * from './application/concurrency.exception';
+export * from './application/aggregate-not-found.exception';
+export * from './application/not-allowed.exception';
+export * from './infrastructure/infrastructure.exception';
+export * from './infrastructure/internal-error.exception';
+export * from './infrastructure/unknown-event.exception';
+export * from './infrastructure/event-delivery.exception';
+export * from './domain/validation.exception';
+export * from './domain/domain.exception';
+export * from './domain/required-value.exception';
+export * from './domain/type-primitive.exception';

package/dist/cjs/exceptions/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract.exception"), exports);
+__exportStar(require("./exception-code"), exports);
+__exportStar(require("./application/application.exception"), exports);
+__exportStar(require("./application/concurrency.exception"), exports);
+__exportStar(require("./application/aggregate-not-found.exception"), exports);
+__exportStar(require("./application/not-allowed.exception"), exports);
+__exportStar(require("./infrastructure/infrastructure.exception"), exports);
+__exportStar(require("./infrastructure/internal-error.exception"), exports);
+__exportStar(require("./infrastructure/unknown-event.exception"), exports);
+__exportStar(require("./infrastructure/event-delivery.exception"), exports);
+__exportStar(require("./domain/validation.exception"), exports);
+__exportStar(require("./domain/domain.exception"), exports);
+__exportStar(require("./domain/required-value.exception"), exports);
+__exportStar(require("./domain/type-primitive.exception"), exports);

package/dist/cjs/exceptions/infrastructure/event-delivery.exception.d.ts

@@ -0,0 +1,5 @@
+import { InfrastructureException } from './infrastructure.exception';
+export declare class EventDeliveryException extends InfrastructureException {
+    readonly errors: readonly unknown[];
+    constructor(eventName: string, errors: readonly unknown[], consumers: number);
+}

package/dist/cjs/exceptions/infrastructure/event-delivery.exception.js

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDeliveryException = void 0;
+const infrastructure_exception_1 = require("./infrastructure.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class EventDeliveryException extends infrastructure_exception_1.InfrastructureException {
+    constructor(eventName, errors, consumers) {
+        super(`${errors.length} of ${consumers} consumers of "${eventName}" failed.`, [
+            exception_code_1.ExceptionCode.EventDelivery,
+        ]);
+        this.errors = Object.freeze([...errors]);
+    }
+}
+exports.EventDeliveryException = EventDeliveryException;
+_a = EventDeliveryException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.EventDelivery);
+})();

package/dist/cjs/exceptions/infrastructure/infrastructure.exception.d.ts

@@ -0,0 +1,6 @@
+import { AbstractException } from '../abstract.exception';
+import type { ExceptionOptions } from '../abstract.exception';
+import { ExceptionCode } from '../exception-code';
+export declare class InfrastructureException extends AbstractException {
+    constructor(message: string, exceptionCodes?: (ExceptionCode | string)[], options?: ExceptionOptions);
+}

package/dist/cjs/exceptions/infrastructure/infrastructure.exception.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfrastructureException = void 0;
+const abstract_exception_1 = require("../abstract.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class InfrastructureException extends abstract_exception_1.AbstractException {
+    constructor(message, exceptionCodes = [], options = {}) {
+        super(message, [exception_code_1.ExceptionCode.InfrastructureException, ...exceptionCodes], options);
+    }
+}
+exports.InfrastructureException = InfrastructureException;
+_a = InfrastructureException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.InfrastructureException);
+})();

package/dist/cjs/exceptions/infrastructure/internal-error.exception.d.ts

@@ -0,0 +1,5 @@
+import { InfrastructureException } from './infrastructure.exception';
+import type { ExceptionOptions } from '../abstract.exception';
+export declare class InternalErrorException extends InfrastructureException {
+    constructor(message: string, options?: ExceptionOptions);
+}

package/dist/cjs/exceptions/infrastructure/internal-error.exception.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalErrorException = void 0;
+const infrastructure_exception_1 = require("./infrastructure.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class InternalErrorException extends infrastructure_exception_1.InfrastructureException {
+    constructor(message, options = {}) {
+        super(`Failed, internal error: ${message}`, [exception_code_1.ExceptionCode.InternalError], options);
+    }
+}
+exports.InternalErrorException = InternalErrorException;
+_a = InternalErrorException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.InternalError);
+})();

package/dist/cjs/exceptions/infrastructure/unknown-event.exception.d.ts

@@ -0,0 +1,4 @@
+import { InfrastructureException } from './infrastructure.exception';
+export declare class UnknownEventException extends InfrastructureException {
+    constructor(eventName: string);
+}

package/dist/cjs/exceptions/infrastructure/unknown-event.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownEventException = void 0;
+const infrastructure_exception_1 = require("./infrastructure.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class UnknownEventException extends infrastructure_exception_1.InfrastructureException {
+    constructor(eventName) {
+        super(`Unknown event "${eventName}": register it before reading it.`, [
+            exception_code_1.ExceptionCode.UnknownEvent,
+        ]);
+    }
+}
+exports.UnknownEventException = UnknownEventException;
+_a = UnknownEventException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.UnknownEvent);
+})();

package/dist/cjs/exceptions/received/received-value.d.ts

@@ -0,0 +1,4 @@
+export declare class ReceivedValue {
+    static readonly maxLength = 64;
+    static describe(value: unknown): string;
+}

package/dist/cjs/exceptions/received/received-value.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceivedValue = void 0;
+const validation_1 = require("@archi-code/validation");
+class ReceivedValue {
+    static describe(value) {
+        const text = typeof value === 'string' ? value : (0, validation_1.anyToString)(value);
+        const shown = text.length > ReceivedValue.maxLength ? `${text.slice(0, ReceivedValue.maxLength)}…` : text;
+        return typeof value === 'string' ? `"${shown}"` : shown;
+    }
+}
+exports.ReceivedValue = ReceivedValue;
+ReceivedValue.maxLength = 64;

package/dist/cjs/infrastructure/clock/fixed-clock.d.ts

@@ -0,0 +1,8 @@
+import type { Clock } from '../../application/index';
+export declare class FixedClock implements Clock {
+    private current;
+    constructor(at: Date | string);
+    now(): Date;
+    set(at: Date | string): void;
+    advance(milliseconds: number): void;
+}

package/dist/cjs/infrastructure/clock/fixed-clock.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixedClock = void 0;
+const index_1 = require("../../domain/index");
+class FixedClock {
+    constructor(at) {
+        this.current = new index_1.CreatedAt(at).value;
+    }
+    now() {
+        return new Date(this.current.getTime());
+    }
+    set(at) {
+        this.current = new index_1.CreatedAt(at).value;
+    }
+    advance(milliseconds) {
+        this.current = new index_1.CreatedAt(new Date(this.current.getTime() + milliseconds)).value;
+    }
+}
+exports.FixedClock = FixedClock;

package/dist/cjs/infrastructure/clock/system-clock.d.ts

@@ -0,0 +1,4 @@
+import type { Clock } from '../../application/index';
+export declare class SystemClock implements Clock {
+    now(): Date;
+}

package/dist/cjs/infrastructure/clock/system-clock.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemClock = void 0;
+class SystemClock {
+    now() {
+        return new Date();
+    }
+}
+exports.SystemClock = SystemClock;

package/dist/cjs/infrastructure/event/domain-event-bus.d.ts

@@ -0,0 +1,16 @@
+import type { EventBase } from '../../domain/index';
+import type { EventBus, EventListener, Logger } from '../../application/index';
+import type { EventChannel } from './event-channel';
+import type { EventRegistry } from './event-registry';
+export interface Subscription {
+    unsubscribe(): Promise<void>;
+}
+export declare class DomainEventBus<Event extends EventBase = EventBase> implements EventBus<Event> {
+    private readonly channel;
+    private readonly registry;
+    private readonly logger;
+    constructor(channel: EventChannel, registry: EventRegistry<Event>, logger?: Logger);
+    publish(events: readonly Event[]): Promise<void>;
+    subscribe(listener: EventListener<Event>): Promise<Subscription>;
+    private deliver;
+}

package/dist/cjs/infrastructure/event/domain-event-bus.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainEventBus = void 0;
+const index_1 = require("../../exceptions/index");
+const index_2 = require("../../application/index");
+const silent_logger_1 = require("../logging/silent-logger");
+class DomainEventBus {
+    constructor(channel, registry, logger = new silent_logger_1.SilentLogger()) {
+        this.channel = channel;
+        this.registry = registry;
+        this.logger = logger;
+    }
+    async publish(events) {
+        await this.channel.send(events.map((event) => event.toJSON()));
+        this.logger.debug('domain_events_published', {
+            events: events.map((event) => ({
+                eventName: event.eventName(),
+                eventId: event.eventId,
+                aggregateId: event.aggregateId,
+            })),
+        });
+    }
+    async subscribe(listener) {
+        const subscription = index_2.ListensTo.subscriptionOf(listener);
+        const { eventName, consumer } = subscription;
+        if (!this.registry.has(eventName)) {
+            throw new index_1.UnknownEventException(eventName);
+        }
+        const channelSubscription = await this.channel.receive(eventName, consumer, (serialized) => this.deliver(listener, subscription, serialized));
+        this.logger.info('event_listener_subscribed', { eventName, consumer });
+        return {
+            unsubscribe: async () => {
+                await channelSubscription.close();
+                this.logger.info('event_listener_unsubscribed', { eventName, consumer });
+            },
+        };
+    }
+    async deliver(listener, { eventName, consumer }, serialized) {
+        try {
+            await listener.handle(this.registry.fromJSON(serialized));
+        }
+        catch (error) {
+            const context = {
+                eventName,
+                consumer,
+                eventId: serialized.eventId,
+                aggregateId: serialized.aggregateId,
+                error,
+            };
+            if (error instanceof index_1.DomainException || error instanceof index_1.ApplicationException) {
+                this.logger.warn('event_listener_rejected', context);
+            }
+            else {
+                this.logger.error('event_listener_failed', context);
+            }
+            throw error;
+        }
+    }
+}
+exports.DomainEventBus = DomainEventBus;

package/dist/cjs/infrastructure/event/event-channel.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedEvent } from '../../domain/index';
+export type ChannelHandler = (event: SerializedEvent) => Promise<void>;
+export interface ChannelSubscription {
+    close(): Promise<void>;
+}
+export interface EventChannel {
+    send(events: readonly SerializedEvent[]): Promise<void>;
+    receive(eventName: string, consumer: string, handler: ChannelHandler): Promise<ChannelSubscription>;
+}

package/dist/cjs/infrastructure/event/event-channel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/infrastructure/event/event-registry.d.ts

@@ -0,0 +1,9 @@
+import type { EventBase, EventClass, SerializedEvent } from '../../domain/index';
+export type EventFactory<Event extends EventBase> = (serialized: SerializedEvent) => Event;
+export declare class EventRegistry<Event extends EventBase = EventBase> {
+    private readonly factories;
+    register<Registered extends Event>(event: EventClass<Registered>, factory: EventFactory<Registered>): this;
+    has(eventName: string): boolean;
+    fromJSON(event: SerializedEvent): Event;
+    private static assertSameIdentity;
+}

package/dist/cjs/infrastructure/event/event-registry.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRegistry = void 0;
+const index_1 = require("../../exceptions/index");
+const index_2 = require("../../domain/index");
+class EventRegistry {
+    constructor() {
+        this.factories = new Map();
+    }
+    register(event, factory) {
+        const { eventName } = event;
+        if (this.factories.has(eventName)) {
+            throw new index_1.InternalErrorException(`event "${eventName}" is already registered`);
+        }
+        this.factories.set(eventName, factory);
+        return this;
+    }
+    has(eventName) {
+        return this.factories.has(eventName);
+    }
+    fromJSON(event) {
+        if (typeof event !== 'object' || event === null) {
+            throw new index_1.InternalErrorException('a serialized event must be a JSON object');
+        }
+        if (typeof event.eventName !== 'string') {
+            throw new index_1.InternalErrorException('a serialized event needs its eventName');
+        }
+        const factory = this.factories.get(event.eventName);
+        if (factory === undefined) {
+            throw new index_1.UnknownEventException(event.eventName);
+        }
+        const rebuilt = factory(event);
+        EventRegistry.assertSameIdentity(event, rebuilt);
+        return index_2.Immutable.freeze(rebuilt);
+    }
+    static assertSameIdentity(serialized, rebuilt) {
+        if (rebuilt.eventId !== String(serialized.eventId).toLowerCase() ||
+            rebuilt.occurredOn.getTime() !== new Date(serialized.occurredOn).getTime()) {
+            throw new index_1.InternalErrorException(`the factory of "${serialized.eventName}" must pass the serialized event as metadata, so it keeps its eventId and occurredOn`);
+        }
+    }
+}
+exports.EventRegistry = EventRegistry;

package/dist/cjs/infrastructure/event/in-memory/emitter.d.ts

@@ -0,0 +1,11 @@
+type EmitterListener<Data> = (data: Data) => Promise<void> | void;
+export declare class Emitter<Data> {
+    private static readonly resolved;
+    private readonly events;
+    on(eventName: string, listener: EmitterListener<Data>): () => void;
+    private off;
+    emit(eventName: string, data: Data): Promise<void>;
+    emitSerial(eventName: string, data: Data): Promise<void>;
+    private listenersOf;
+}
+export {};