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

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

@@ -0,0 +1,21 @@
+export { SystemClock } from './clock/system-clock';
+export { FixedClock } from './clock/fixed-clock';
+export { DomainEventBus } from './event/domain-event-bus';
+export type { Subscription } from './event/domain-event-bus';
+export { EventRegistry } from './event/event-registry';
+export type { EventFactory } from './event/event-registry';
+export type { ChannelHandler, ChannelSubscription, EventChannel } from './event/event-channel';
+export { InMemoryEventChannel } from './event/in-memory/in-memory-event-channel';
+export type { InMemoryEventChannelOptions } from './event/in-memory/in-memory-event-channel';
+export { ConsoleLogger } from './logging/console-logger';
+export type { ConsoleLoggerOptions } from './logging/console-logger';
+export { InMemoryLogger } from './logging/in-memory-logger';
+export type { LogEntry } from './logging/in-memory-logger';
+export { SilentLogger } from './logging/silent-logger';
+export { InfrastructureException } from './exceptions/infrastructure.exception';
+export { InternalErrorException } from './exceptions/internal-error.exception';
+export { UnknownEventException } from './exceptions/unknown-event.exception';
+export { EventDeliveryException } from './exceptions/event-delivery.exception';
+export { InfrastructureExceptionCode } from './exceptions/infrastructure-exception-code';
+export { ExceptionClassifier } from './exceptions/kind/exception-classifier';
+export { ExceptionKind } from './exceptions/kind/exception-kind';

package/dist/cjs/infrastructure/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionKind = exports.ExceptionClassifier = exports.InfrastructureExceptionCode = exports.EventDeliveryException = exports.UnknownEventException = exports.InternalErrorException = exports.InfrastructureException = exports.SilentLogger = exports.InMemoryLogger = exports.ConsoleLogger = exports.InMemoryEventChannel = exports.EventRegistry = exports.DomainEventBus = exports.FixedClock = exports.SystemClock = void 0;
+var system_clock_1 = require("./clock/system-clock");
+Object.defineProperty(exports, "SystemClock", { enumerable: true, get: function () { return system_clock_1.SystemClock; } });
+var fixed_clock_1 = require("./clock/fixed-clock");
+Object.defineProperty(exports, "FixedClock", { enumerable: true, get: function () { return fixed_clock_1.FixedClock; } });
+var domain_event_bus_1 = require("./event/domain-event-bus");
+Object.defineProperty(exports, "DomainEventBus", { enumerable: true, get: function () { return domain_event_bus_1.DomainEventBus; } });
+var event_registry_1 = require("./event/event-registry");
+Object.defineProperty(exports, "EventRegistry", { enumerable: true, get: function () { return event_registry_1.EventRegistry; } });
+var in_memory_event_channel_1 = require("./event/in-memory/in-memory-event-channel");
+Object.defineProperty(exports, "InMemoryEventChannel", { enumerable: true, get: function () { return in_memory_event_channel_1.InMemoryEventChannel; } });
+var console_logger_1 = require("./logging/console-logger");
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return console_logger_1.ConsoleLogger; } });
+var in_memory_logger_1 = require("./logging/in-memory-logger");
+Object.defineProperty(exports, "InMemoryLogger", { enumerable: true, get: function () { return in_memory_logger_1.InMemoryLogger; } });
+var silent_logger_1 = require("./logging/silent-logger");
+Object.defineProperty(exports, "SilentLogger", { enumerable: true, get: function () { return silent_logger_1.SilentLogger; } });
+var infrastructure_exception_1 = require("./exceptions/infrastructure.exception");
+Object.defineProperty(exports, "InfrastructureException", { enumerable: true, get: function () { return infrastructure_exception_1.InfrastructureException; } });
+var internal_error_exception_1 = require("./exceptions/internal-error.exception");
+Object.defineProperty(exports, "InternalErrorException", { enumerable: true, get: function () { return internal_error_exception_1.InternalErrorException; } });
+var unknown_event_exception_1 = require("./exceptions/unknown-event.exception");
+Object.defineProperty(exports, "UnknownEventException", { enumerable: true, get: function () { return unknown_event_exception_1.UnknownEventException; } });
+var event_delivery_exception_1 = require("./exceptions/event-delivery.exception");
+Object.defineProperty(exports, "EventDeliveryException", { enumerable: true, get: function () { return event_delivery_exception_1.EventDeliveryException; } });
+var infrastructure_exception_code_1 = require("./exceptions/infrastructure-exception-code");
+Object.defineProperty(exports, "InfrastructureExceptionCode", { enumerable: true, get: function () { return infrastructure_exception_code_1.InfrastructureExceptionCode; } });
+var exception_classifier_1 = require("./exceptions/kind/exception-classifier");
+Object.defineProperty(exports, "ExceptionClassifier", { enumerable: true, get: function () { return exception_classifier_1.ExceptionClassifier; } });
+var exception_kind_1 = require("./exceptions/kind/exception-kind");
+Object.defineProperty(exports, "ExceptionKind", { enumerable: true, get: function () { return exception_kind_1.ExceptionKind; } });

package/dist/cjs/infrastructure/logging/console-logger.d.ts

@@ -0,0 +1,17 @@
+import type { Clock, LogContext, Logger, LogLevel } from '../../application/index';
+export interface ConsoleLoggerOptions {
+    readonly level?: LogLevel;
+    readonly clock?: Clock;
+}
+export declare class ConsoleLogger implements Logger {
+    private static readonly levels;
+    private readonly output;
+    private readonly minimum;
+    private readonly clock;
+    constructor({ level, clock }?: ConsoleLoggerOptions);
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+    private write;
+}

package/dist/cjs/infrastructure/logging/console-logger.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const internal_error_exception_1 = require("../exceptions/internal-error.exception");
+const system_clock_1 = require("../clock/system-clock");
+const log_serializer_1 = require("./log-serializer");
+class ConsoleLogger {
+    constructor({ level = 'info', clock = new system_clock_1.SystemClock() } = {}) {
+        this.output = console;
+        this.minimum = ConsoleLogger.levels.indexOf(level);
+        if (this.minimum === -1) {
+            throw new internal_error_exception_1.InternalErrorException(`unknown log level "${String(level)}": use ${ConsoleLogger.levels.join(', ')}`);
+        }
+        this.clock = clock;
+    }
+    debug(message, context) {
+        this.write('debug', message, context);
+    }
+    info(message, context) {
+        this.write('info', message, context);
+    }
+    warn(message, context) {
+        this.write('warn', message, context);
+    }
+    error(message, context) {
+        this.write('error', message, context);
+    }
+    write(level, message, context) {
+        if (ConsoleLogger.levels.indexOf(level) < this.minimum) {
+            return;
+        }
+        const entry = { time: this.clock.now().toISOString(), level, message };
+        this.output[level](log_serializer_1.LogSerializer.line(entry, context));
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+ConsoleLogger.levels = ['debug', 'info', 'warn', 'error'];

package/dist/cjs/infrastructure/logging/in-memory-logger.d.ts

@@ -0,0 +1,15 @@
+import type { LogContext, Logger, LogLevel } from '../../application/index';
+export interface LogEntry {
+    readonly level: LogLevel;
+    readonly message: string;
+    readonly context?: LogContext;
+}
+export declare class InMemoryLogger implements Logger {
+    private readonly recorded;
+    get entries(): readonly LogEntry[];
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+    private record;
+}

package/dist/cjs/infrastructure/logging/in-memory-logger.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryLogger = void 0;
+class InMemoryLogger {
+    constructor() {
+        this.recorded = [];
+    }
+    get entries() {
+        return [...this.recorded];
+    }
+    debug(message, context) {
+        this.record('debug', message, context);
+    }
+    info(message, context) {
+        this.record('info', message, context);
+    }
+    warn(message, context) {
+        this.record('warn', message, context);
+    }
+    error(message, context) {
+        this.record('error', message, context);
+    }
+    record(level, message, context) {
+        this.recorded.push(context === undefined ? { level, message } : { level, message, context });
+    }
+}
+exports.InMemoryLogger = InMemoryLogger;

package/dist/cjs/infrastructure/logging/log-serializer.d.ts

@@ -0,0 +1,7 @@
+import type { LogContext } from '../../application/index';
+export declare class LogSerializer {
+    static line(entry: Readonly<Record<string, string>>, context: LogContext | undefined): string;
+    private static plain;
+    private static plainObject;
+    private static plainError;
+}

package/dist/cjs/infrastructure/logging/log-serializer.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogSerializer = void 0;
+class LogSerializer {
+    static line(entry, context) {
+        if (context === undefined) {
+            return JSON.stringify(entry);
+        }
+        try {
+            return JSON.stringify({ ...entry, context: LogSerializer.plain(context, new Set()) });
+        }
+        catch {
+            return JSON.stringify({ ...entry, context: '[Unserializable]' });
+        }
+    }
+    static plain(value, ancestors) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value !== 'object' || value === null) {
+            return value;
+        }
+        if (ancestors.has(value)) {
+            return '[Circular]';
+        }
+        ancestors.add(value);
+        try {
+            return LogSerializer.plainObject(value, ancestors);
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    }
+    static plainObject(value, ancestors) {
+        if (value instanceof Error) {
+            return LogSerializer.plainError(value, ancestors);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => LogSerializer.plain(item, ancestors));
+        }
+        const { toJSON } = value;
+        if (typeof toJSON === 'function') {
+            return LogSerializer.plain(toJSON.call(value), ancestors);
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, LogSerializer.plain(item, ancestors)]));
+    }
+    static plainError(error, ancestors) {
+        const { code, errors, cause } = error;
+        return {
+            name: error.name,
+            message: error.message,
+            ...(typeof code === 'string' ? { code } : {}),
+            ...(Array.isArray(errors) ? { errors: LogSerializer.plain(errors, ancestors) } : {}),
+            ...(error.stack === undefined ? {} : { stack: error.stack }),
+            ...(cause === undefined ? {} : { cause: LogSerializer.plain(cause, ancestors) }),
+        };
+    }
+}
+exports.LogSerializer = LogSerializer;

package/dist/cjs/infrastructure/logging/silent-logger.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from '../../application/index';
+export declare class SilentLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/dist/cjs/infrastructure/logging/silent-logger.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SilentLogger = void 0;
+class SilentLogger {
+    debug() {
+        return undefined;
+    }
+    info() {
+        return undefined;
+    }
+    warn() {
+        return undefined;
+    }
+    error() {
+        return undefined;
+    }
+}
+exports.SilentLogger = SilentLogger;

package/dist/cjs/shared/exceptions/abstract.exception.d.ts

@@ -0,0 +1,25 @@
+export interface ExceptionOptions {
+    cause?: unknown;
+}
+export type ExceptionCodeNames = Readonly<Record<string, string>>;
+export declare abstract class AbstractException extends Error {
+    private static readonly fallbackCode;
+    readonly cause?: unknown;
+    private readonly exceptionCodes;
+    private readonly codeNames;
+    readonly code: string;
+    private readonly createdAt;
+    static [Symbol.hasInstance](candidate: unknown): boolean;
+    constructor(message: string, exceptionCodes: string[], options?: ExceptionOptions, codeNames?: ExceptionCodeNames);
+    get timestamp(): Date;
+    get description(): string;
+    private labelOf;
+    print(): string;
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        description: string;
+        timestamp: string;
+    };
+}

package/dist/cjs/shared/exceptions/abstract.exception.js

@@ -0,0 +1,59 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractException = void 0;
+const exception_brand_1 = require("./brand/exception-brand");
+class AbstractException extends Error {
+    static [Symbol.hasInstance](candidate) {
+        return (Function.prototype[Symbol.hasInstance].call(this, candidate) ||
+            exception_brand_1.ExceptionBrand.matches(this, candidate));
+    }
+    constructor(message, exceptionCodes, options = {}, codeNames = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.exceptionCodes = exceptionCodes;
+        this.codeNames = codeNames;
+        this.code =
+            exceptionCodes.length > 0
+                ? exceptionCodes[exceptionCodes.length - 1]
+                : _a.fallbackCode;
+        this.createdAt = Date.now();
+        if ('cause' in options) {
+            Object.defineProperty(this, 'cause', {
+                value: options.cause,
+                writable: true,
+                configurable: true,
+            });
+        }
+        exception_brand_1.ExceptionBrand.brandInstance(this, exceptionCodes);
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+    get timestamp() {
+        return new Date(this.createdAt);
+    }
+    get description() {
+        return this.exceptionCodes.map((code) => `${this.labelOf(code)} (${code})`).join(', ');
+    }
+    labelOf(code) {
+        const name = Object.keys(this.codeNames).find((key) => this.codeNames[key] === code);
+        return name === undefined ? this.name : name.replace(/([A-Z])/g, ' $1').trim();
+    }
+    print() {
+        return `[${this.description}]: ${this.message}, ${this.timestamp.toISOString()}`;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            description: this.description,
+            timestamp: this.timestamp.toISOString(),
+        };
+    }
+}
+exports.AbstractException = AbstractException;
+_a = AbstractException;
+AbstractException.fallbackCode = 'E000';
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_brand_1.ExceptionBrand.anyCode);
+})();

package/dist/cjs/shared/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/shared/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/shared/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/shared/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/shared/index.d.ts

@@ -0,0 +1,8 @@
+export { AbstractException } from './exceptions/abstract.exception';
+export type { ExceptionCodeNames, ExceptionOptions } from './exceptions/abstract.exception';
+export { ExceptionBrand } from './exceptions/brand/exception-brand';
+export { ReceivedValue } from './exceptions/received/received-value';
+export { IssueCollector } from './issue-collector';
+export type { IssueReader } from './issue-collector';
+export { IssueCollectionError } from './issue-collection-error';
+export type { CollectedIssue } from './issue-collection-error';

package/dist/cjs/shared/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueCollectionError = exports.IssueCollector = exports.ReceivedValue = exports.ExceptionBrand = exports.AbstractException = void 0;
+var abstract_exception_1 = require("./exceptions/abstract.exception");
+Object.defineProperty(exports, "AbstractException", { enumerable: true, get: function () { return abstract_exception_1.AbstractException; } });
+var exception_brand_1 = require("./exceptions/brand/exception-brand");
+Object.defineProperty(exports, "ExceptionBrand", { enumerable: true, get: function () { return exception_brand_1.ExceptionBrand; } });
+var received_value_1 = require("./exceptions/received/received-value");
+Object.defineProperty(exports, "ReceivedValue", { enumerable: true, get: function () { return received_value_1.ReceivedValue; } });
+var issue_collector_1 = require("./issue-collector");
+Object.defineProperty(exports, "IssueCollector", { enumerable: true, get: function () { return issue_collector_1.IssueCollector; } });
+var issue_collection_error_1 = require("./issue-collection-error");
+Object.defineProperty(exports, "IssueCollectionError", { enumerable: true, get: function () { return issue_collection_error_1.IssueCollectionError; } });

package/dist/cjs/shared/issue-collection-error.d.ts

@@ -0,0 +1,9 @@
+export interface CollectedIssue {
+    readonly field: string | null;
+    readonly code: string;
+    readonly message: string;
+}
+export declare class IssueCollectionError extends Error {
+    readonly issues: readonly CollectedIssue[];
+    constructor(issues: readonly CollectedIssue[]);
+}

package/dist/cjs/shared/issue-collection-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueCollectionError = void 0;
+class IssueCollectionError extends Error {
+    constructor(issues) {
+        super(`${issues.length} issues collected`);
+        this.name = 'IssueCollectionError';
+        this.issues = Object.freeze([...issues]);
+    }
+}
+exports.IssueCollectionError = IssueCollectionError;

package/dist/cjs/shared/issue-collector.d.ts

@@ -0,0 +1,8 @@
+import type { CollectedIssue } from './issue-collection-error';
+export type IssueReader = (error: unknown) => readonly CollectedIssue[] | null;
+export declare class IssueCollector {
+    static collectFields(builds: Readonly<Record<string, () => unknown>>, readIssues: IssueReader): Record<string, unknown>;
+    static collectItems<Item, Built>(items: readonly Item[], build: (item: Item, index: number) => Built, readIssues: IssueReader): Built[];
+    private static collect;
+    private static issuesAt;
+}

package/dist/cjs/shared/issue-collector.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueCollector = void 0;
+const issue_collection_error_1 = require("./issue-collection-error");
+class IssueCollector {
+    static collectFields(builds, readIssues) {
+        return Object.fromEntries(IssueCollector.collect(Object.entries(builds), readIssues));
+    }
+    static collectItems(items, build, readIssues) {
+        const builds = items.map((item, index) => [String(index), () => build(item, index)]);
+        return IssueCollector.collect(builds, readIssues).map(([, built]) => built);
+    }
+    static collect(builds, readIssues) {
+        const built = [];
+        const issues = [];
+        for (const [path, build] of builds) {
+            try {
+                built.push([path, build()]);
+            }
+            catch (error) {
+                issues.push(...IssueCollector.issuesAt(path, error, readIssues));
+            }
+        }
+        if (issues.length > 0) {
+            throw new issue_collection_error_1.IssueCollectionError(issues);
+        }
+        return built;
+    }
+    static issuesAt(path, error, readIssues) {
+        const issues = readIssues(error);
+        if (issues === null) {
+            throw error;
+        }
+        return issues.map((issue) => ({
+            field: issue.field === null ? path : `${path}.${issue.field}`,
+            code: issue.code,
+            message: issue.message,
+        }));
+    }
+}
+exports.IssueCollector = IssueCollector;

package/dist/esm/application/event/event-bus.d.ts

@@ -0,0 +1,4 @@
+import type { EventBase } from '../../domain/index.js';
+export interface EventBus<Event extends EventBase = EventBase> {
+    publish(events: readonly Event[]): Promise<void>;
+}

package/dist/esm/application/event/event-bus.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/application/event/event-listener.d.ts

@@ -0,0 +1,4 @@
+import type { EventBase } from '../../domain/index.js';
+export declare abstract class EventListener<Event extends EventBase = EventBase> {
+    abstract handle(event: Event): Promise<void> | void;
+}

package/dist/esm/application/event/event-listener.js

@@ -0,0 +1,2 @@
+export class EventListener {
+}

package/dist/esm/application/event/listens-to.d.ts

@@ -0,0 +1,15 @@
+import type { EventBase, EventClass } from '../../domain/index.js';
+import type { EventListener } from './event-listener.js';
+type ListenerClass<Event extends EventBase> = abstract new (...args: any[]) => EventListener<Event>;
+export interface ListensToOptions {
+    readonly consumer: string;
+}
+export interface ListenerSubscription {
+    readonly eventName: string;
+    readonly consumer: string;
+}
+export declare function ListensTo<Event extends EventBase>(event: EventClass<Event>, options: ListensToOptions): (listener: ListenerClass<Event>) => void;
+export declare namespace ListensTo {
+    var subscriptionOf: (listener: EventListener<any>) => ListenerSubscription;
+}
+export {};

package/dist/esm/application/event/listens-to.js

@@ -0,0 +1,25 @@
+import { ApplicationException } from '../exceptions/application.exception.js';
+const LISTENED_EVENT = Symbol.for('@archi-code/ddd/listens-to.v1');
+export function ListensTo(event, options) {
+    return (listener) => {
+        if (Object.prototype.hasOwnProperty.call(listener, LISTENED_EVENT)) {
+            throw new ApplicationException(`${listener.name} already listens to an event`);
+        }
+        const consumer = options?.consumer;
+        if (typeof consumer !== 'string' || consumer.trim() === '') {
+            throw new ApplicationException(`${listener.name} needs a consumer name: @ListensTo(<event class>, { consumer: '<name>' })`);
+        }
+        const subscription = Object.freeze({
+            eventName: event.eventName,
+            consumer,
+        });
+        Object.defineProperty(listener, LISTENED_EVENT, { value: subscription });
+    };
+}
+ListensTo.subscriptionOf = (listener) => {
+    const listenerClass = listener.constructor;
+    if (!Object.prototype.hasOwnProperty.call(listenerClass, LISTENED_EVENT)) {
+        throw new ApplicationException(`${listenerClass.name} needs @ListensTo(<event class>, { consumer: '<name>' })`);
+    }
+    return listenerClass[LISTENED_EVENT];
+};

package/dist/esm/application/exceptions/aggregate-not-found.exception.d.ts

@@ -0,0 +1,5 @@
+import type { ExceptionOptions } from '../../shared/index.js';
+import { ApplicationException } from './application.exception.js';
+export declare class AggregateNotFoundException extends ApplicationException {
+    constructor(entity: string, id: string, options?: ExceptionOptions);
+}

package/dist/esm/application/exceptions/aggregate-not-found.exception.js

@@ -0,0 +1,13 @@
+var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { ApplicationExceptionCode } from './application-exception-code.js';
+import { ApplicationException } from './application.exception.js';
+export class AggregateNotFoundException extends ApplicationException {
+    constructor(entity, id, options = {}) {
+        super(`${entity} with ID ${id} not found.`, [ApplicationExceptionCode.AggregateNotFound], options);
+    }
+}
+_a = AggregateNotFoundException;
+(() => {
+    ExceptionBrand.brandClass(_a, ApplicationExceptionCode.AggregateNotFound);
+})();

package/dist/esm/application/exceptions/application-exception-code.d.ts

@@ -0,0 +1,7 @@
+export declare enum ApplicationExceptionCode {
+    ApplicationException = "APP000",
+    ConcurrencyConflict = "APP001",
+    AggregateNotFound = "APP002",
+    NotAllowed = "APP003",
+    UnexpectedError = "APP004"
+}

package/dist/esm/application/exceptions/application-exception-code.js

@@ -0,0 +1,8 @@
+export var ApplicationExceptionCode;
+(function (ApplicationExceptionCode) {
+    ApplicationExceptionCode["ApplicationException"] = "APP000";
+    ApplicationExceptionCode["ConcurrencyConflict"] = "APP001";
+    ApplicationExceptionCode["AggregateNotFound"] = "APP002";
+    ApplicationExceptionCode["NotAllowed"] = "APP003";
+    ApplicationExceptionCode["UnexpectedError"] = "APP004";
+})(ApplicationExceptionCode || (ApplicationExceptionCode = {}));

package/dist/esm/application/exceptions/application.exception.d.ts

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

package/dist/esm/application/exceptions/application.exception.js

@@ -0,0 +1,12 @@
+var _a;
+import { AbstractException, ExceptionBrand } from '../../shared/index.js';
+import { ApplicationExceptionCode } from './application-exception-code.js';
+export class ApplicationException extends AbstractException {
+    constructor(message, exceptionCodes = [], options = {}) {
+        super(message, [ApplicationExceptionCode.ApplicationException, ...exceptionCodes], options, ApplicationExceptionCode);
+    }
+}
+_a = ApplicationException;
+(() => {
+    ExceptionBrand.brandClass(_a, ApplicationExceptionCode.ApplicationException);
+})();

package/dist/esm/application/exceptions/concurrency.exception.d.ts

@@ -0,0 +1,5 @@
+import type { ExceptionOptions } from '../../shared/index.js';
+import { ApplicationException } from './application.exception.js';
+export declare class ConcurrencyException extends ApplicationException {
+    constructor(aggregateName: string, id: string, expectedVersion: number, options?: ExceptionOptions);
+}