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

package/dist/cjs/domain/type/required/required-mark.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredMark = void 0;
+class RequiredMark {
+    static isMarked(instance) {
+        return instance[RequiredMark.symbol] === true;
+    }
+    static mark(prototype) {
+        Object.defineProperty(prototype, RequiredMark.symbol, { value: true });
+    }
+}
+exports.RequiredMark = RequiredMark;
+RequiredMark.symbol = Symbol.for('@archi-code/ddd/required.v1');

package/dist/cjs/domain/type/required/required-type.d.ts

@@ -0,0 +1,7 @@
+import type { AbstractType } from '../abstract-type';
+import type { RequiredMarked } from './required-mark';
+type TypeClass = abstract new (value?: any) => AbstractType<any>;
+type RequiredValueOf<C extends TypeClass> = Exclude<ConstructorParameters<C>[0], null | undefined>;
+export type RequiredType<C extends TypeClass> = Omit<C, 'prototype'> & (abstract new (value: RequiredValueOf<C>) => InstanceType<C> & RequiredMarked);
+export declare function Required<C extends TypeClass>(Base: C): RequiredType<C>;
+export {};

package/dist/cjs/domain/type/required/required-type.js

@@ -0,0 +1,21 @@
+"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.Required = Required;
+const validation_1 = require("@archi-code/validation");
+const required_mark_1 = require("./required-mark");
+function Required(Base) {
+    let RequiredValue = class RequiredValue extends Base {
+    };
+    RequiredValue = __decorate([
+        (0, validation_1.Validations)([{ validator: 'isRequired' }])
+    ], RequiredValue);
+    Object.defineProperty(RequiredValue, 'name', { value: `Required(${Base.name})` });
+    required_mark_1.RequiredMark.mark(RequiredValue.prototype);
+    return RequiredValue;
+}

package/dist/cjs/domain/type/string-type.d.ts

@@ -0,0 +1,4 @@
+import { AbstractType } from './abstract-type';
+export declare class StringType extends AbstractType<string> {
+    protected filter(value: unknown): string;
+}

package/dist/cjs/domain/type/string-type.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringType = void 0;
+const validation_1 = require("@archi-code/validation");
+const abstract_type_1 = require("./abstract-type");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
+class StringType extends abstract_type_1.AbstractType {
+    filter(value) {
+        const converted = (0, validation_1.toString)(value);
+        if (!converted.ok) {
+            throw new type_primitive_exception_1.TypePrimitiveException('String', value);
+        }
+        return converted.value;
+    }
+}
+exports.StringType = StringType;

package/dist/cjs/domain/type/uuid-type.d.ts

@@ -0,0 +1,7 @@
+import { AbstractType } from './abstract-type';
+export declare class UuidType extends AbstractType<string> {
+    static random(): string;
+    static generate<T extends AbstractType<string>>(this: new (value: string) => T): T;
+    static fromValue(value: string, namespace?: string): string;
+    protected filter(value: unknown): string;
+}

package/dist/cjs/domain/type/uuid-type.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidType = void 0;
+const uuid_1 = require("uuid");
+const validation_1 = require("@archi-code/validation");
+const abstract_type_1 = require("./abstract-type");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
+const DNS_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+class UuidType extends abstract_type_1.AbstractType {
+    static random() {
+        return (0, uuid_1.v4)();
+    }
+    static generate() {
+        return new this((0, uuid_1.v4)());
+    }
+    static fromValue(value, namespace = DNS_NAMESPACE) {
+        return (0, uuid_1.v5)(value, namespace);
+    }
+    filter(value) {
+        const converted = (0, validation_1.toString)(value);
+        if (!converted.ok || !(0, validation_1.isUUID)(converted.value)) {
+            throw new type_primitive_exception_1.TypePrimitiveException('UUID', value);
+        }
+        return converted.value.toLowerCase();
+    }
+}
+exports.UuidType = UuidType;

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("../../application/index");
+const index_2 = require("../../domain/index");
+const unknown_event_exception_1 = require("../exceptions/unknown-event.exception");
+const index_3 = 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 })));
+        this.logger.debug('domain_events_published', {
+            events: events.map((event) => ({
+                eventName: event.eventName,
+                eventId: event.eventId,
+            })),
+        });
+    }
+    async subscribe(listener) {
+        const subscription = index_3.ListensTo.subscriptionOf(listener);
+        const { eventName, consumer } = subscription;
+        if (!this.registry.has(eventName)) {
+            throw new unknown_event_exception_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,
+                error,
+            };
+            if (error instanceof index_2.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 internal_error_exception_1 = require("../exceptions/internal-error.exception");
+const unknown_event_exception_1 = require("../exceptions/unknown-event.exception");
+class EventRegistry {
+    constructor() {
+        this.factories = new Map();
+    }
+    register(event, factory) {
+        const { eventName } = event;
+        if (this.factories.has(eventName)) {
+            throw new internal_error_exception_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 internal_error_exception_1.InternalErrorException('a serialized event must be a JSON object');
+        }
+        if (typeof event.eventName !== 'string') {
+            throw new internal_error_exception_1.InternalErrorException('a serialized event needs its eventName');
+        }
+        const factory = this.factories.get(event.eventName);
+        if (factory === undefined) {
+            throw new unknown_event_exception_1.UnknownEventException(event.eventName);
+        }
+        const rebuilt = factory(event);
+        EventRegistry.assertSameIdentity(event, rebuilt);
+        return rebuilt;
+    }
+    static assertSameIdentity(serialized, rebuilt) {
+        if (rebuilt.eventId !== String(serialized.eventId).toLowerCase() ||
+            Date.parse(rebuilt.occurredOn) !== Date.parse(serialized.occurredOn)) {
+            throw new internal_error_exception_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 {};

package/dist/cjs/infrastructure/event/in-memory/emitter.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = void 0;
+const event_delivery_exception_1 = require("../../exceptions/event-delivery.exception");
+class Emitter {
+    constructor() {
+        this.events = new Map();
+    }
+    on(eventName, listener) {
+        const listeners = this.events.get(eventName) ?? new Set();
+        listeners.add(listener);
+        this.events.set(eventName, listeners);
+        return () => this.off(eventName, listener);
+    }
+    off(eventName, listener) {
+        const listeners = this.events.get(eventName);
+        if (listeners === undefined) {
+            return;
+        }
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+            this.events.delete(eventName);
+        }
+    }
+    async emit(eventName, data) {
+        const listeners = this.listenersOf(eventName);
+        const snapshot = Array.from(listeners);
+        await Emitter.resolved;
+        const results = await Promise.allSettled(snapshot.map(async (listener) => {
+            if (listeners.has(listener)) {
+                await listener(data);
+            }
+        }));
+        const errors = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
+        if (errors.length > 0) {
+            throw new event_delivery_exception_1.EventDeliveryException(eventName, errors, snapshot.length);
+        }
+    }
+    async emitSerial(eventName, data) {
+        const listeners = this.listenersOf(eventName);
+        const snapshot = Array.from(listeners);
+        await Emitter.resolved;
+        for (const listener of snapshot) {
+            if (listeners.has(listener)) {
+                await listener(data);
+            }
+        }
+    }
+    listenersOf(eventName) {
+        return this.events.get(eventName) ?? new Set();
+    }
+}
+exports.Emitter = Emitter;
+Emitter.resolved = Promise.resolve();

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

@@ -0,0 +1,16 @@
+import type { ChannelHandler, ChannelSubscription, EventChannel } from '../event-channel';
+import type { SerializedEvent } from '../../../domain/index';
+export interface InMemoryEventChannelOptions {
+    readonly delivery?: 'serial' | 'parallel';
+}
+export declare class InMemoryEventChannel implements EventChannel {
+    private readonly emitter;
+    private readonly receivers;
+    private readonly sentEvents;
+    private readonly delivery;
+    constructor({ delivery }?: InMemoryEventChannelOptions);
+    get sent(): readonly SerializedEvent[];
+    send(events: readonly SerializedEvent[]): Promise<void>;
+    receive(eventName: string, consumer: string, handler: ChannelHandler): Promise<ChannelSubscription>;
+    private static copy;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryEventChannel = void 0;
+const infrastructure_exception_1 = require("../../exceptions/infrastructure.exception");
+const emitter_1 = require("./emitter");
+class InMemoryEventChannel {
+    constructor({ delivery = 'serial' } = {}) {
+        this.emitter = new emitter_1.Emitter();
+        this.receivers = new Set();
+        this.sentEvents = [];
+        this.delivery = delivery;
+    }
+    get sent() {
+        return [...this.sentEvents];
+    }
+    async send(events) {
+        for (const event of events) {
+            const copy = InMemoryEventChannel.copy(event);
+            this.sentEvents.push(copy);
+            if (this.delivery === 'parallel') {
+                await this.emitter.emit(copy.eventName, copy);
+            }
+            else {
+                await this.emitter.emitSerial(copy.eventName, copy);
+            }
+        }
+    }
+    async receive(eventName, consumer, handler) {
+        const receiver = JSON.stringify([eventName, consumer]);
+        if (this.receivers.has(receiver)) {
+            throw new infrastructure_exception_1.InfrastructureException(`${consumer} already receives "${eventName}": close its subscription first.`);
+        }
+        this.receivers.add(receiver);
+        const off = this.emitter.on(eventName, (event) => handler(InMemoryEventChannel.copy(event)));
+        let open = true;
+        return {
+            close: async () => {
+                if (open) {
+                    open = false;
+                    off();
+                    this.receivers.delete(receiver);
+                }
+            },
+        };
+    }
+    static copy(event) {
+        return JSON.parse(JSON.stringify(event));
+    }
+}
+exports.InMemoryEventChannel = InMemoryEventChannel;

package/dist/cjs/infrastructure/exceptions/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/infrastructure/exceptions/event-delivery.exception.js

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

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

@@ -0,0 +1,6 @@
+export declare enum InfrastructureExceptionCode {
+    InfrastructureException = "INF000",
+    InternalError = "INF001",
+    UnknownEvent = "INF002",
+    EventDelivery = "INF003"
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfrastructureExceptionCode = void 0;
+var InfrastructureExceptionCode;
+(function (InfrastructureExceptionCode) {
+    InfrastructureExceptionCode["InfrastructureException"] = "INF000";
+    InfrastructureExceptionCode["InternalError"] = "INF001";
+    InfrastructureExceptionCode["UnknownEvent"] = "INF002";
+    InfrastructureExceptionCode["EventDelivery"] = "INF003";
+})(InfrastructureExceptionCode || (exports.InfrastructureExceptionCode = InfrastructureExceptionCode = {}));

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfrastructureException = void 0;
+const index_1 = require("../../shared/index");
+const infrastructure_exception_code_1 = require("./infrastructure-exception-code");
+class InfrastructureException extends index_1.AbstractException {
+    constructor(message, exceptionCodes = [], options = {}) {
+        super(message, [infrastructure_exception_code_1.InfrastructureExceptionCode.InfrastructureException, ...exceptionCodes], options, infrastructure_exception_code_1.InfrastructureExceptionCode);
+    }
+}
+exports.InfrastructureException = InfrastructureException;
+_a = InfrastructureException;
+(() => {
+    index_1.ExceptionBrand.brandClass(_a, infrastructure_exception_code_1.InfrastructureExceptionCode.InfrastructureException);
+})();

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

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

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

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

package/dist/cjs/infrastructure/exceptions/kind/exception-classifier.d.ts

@@ -0,0 +1,4 @@
+import { ExceptionKind } from './exception-kind';
+export declare class ExceptionClassifier {
+    static classify(error: unknown): ExceptionKind;
+}

package/dist/cjs/infrastructure/exceptions/kind/exception-classifier.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionClassifier = void 0;
+const index_1 = require("../../../application/index");
+const index_2 = require("../../../domain/index");
+const exception_kind_1 = require("./exception-kind");
+class ExceptionClassifier {
+    static classify(error) {
+        if (error instanceof index_1.AggregateNotFoundException) {
+            return exception_kind_1.ExceptionKind.NotFound;
+        }
+        if (error instanceof index_1.NotAllowedException) {
+            return exception_kind_1.ExceptionKind.NotAllowed;
+        }
+        if (error instanceof index_1.ConcurrencyException) {
+            return exception_kind_1.ExceptionKind.Conflict;
+        }
+        if (error instanceof index_1.UnexpectedErrorException ||
+            error instanceof index_2.InvalidEventDefinitionException) {
+            return exception_kind_1.ExceptionKind.Internal;
+        }
+        if (error instanceof index_2.TypePrimitiveException || error instanceof index_2.RequiredValueException) {
+            return exception_kind_1.ExceptionKind.Malformed;
+        }
+        if (error instanceof index_2.DomainException) {
+            return exception_kind_1.ExceptionKind.Invalid;
+        }
+        if (error instanceof index_1.ApplicationException) {
+            return exception_kind_1.ExceptionKind.Rejected;
+        }
+        return exception_kind_1.ExceptionKind.Internal;
+    }
+}
+exports.ExceptionClassifier = ExceptionClassifier;

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

@@ -0,0 +1,9 @@
+export declare enum ExceptionKind {
+    NotFound = "not_found",
+    NotAllowed = "not_allowed",
+    Conflict = "conflict",
+    Malformed = "malformed",
+    Invalid = "invalid",
+    Rejected = "rejected",
+    Internal = "internal"
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionKind = void 0;
+var ExceptionKind;
+(function (ExceptionKind) {
+    ExceptionKind["NotFound"] = "not_found";
+    ExceptionKind["NotAllowed"] = "not_allowed";
+    ExceptionKind["Conflict"] = "conflict";
+    ExceptionKind["Malformed"] = "malformed";
+    ExceptionKind["Invalid"] = "invalid";
+    ExceptionKind["Rejected"] = "rejected";
+    ExceptionKind["Internal"] = "internal";
+})(ExceptionKind || (exports.ExceptionKind = ExceptionKind = {}));

package/dist/cjs/infrastructure/exceptions/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/infrastructure/exceptions/unknown-event.exception.js

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