@archi-code/ddd 3.0.0-alpha.1 → 3.0.0-alpha.2

package/dist/esm/domain/type/date-type.js

@@ -1,8 +1,40 @@
 import { toDate } from '@archi-code/validation';
 import { AbstractType } from './abstract-type.js';
-import { Immutable } from './immutable/immutable.js';
-import { Required } from './required/required.js';
-import { TypePrimitiveException } from '../../exceptions/index.js';
+import { Required } from './required/required-type.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
+class ImmutableDate extends Date {
+    constructor(date) {
+        super(date.getTime());
+        Object.freeze(this);
+    }
+}
+ImmutableDate.setters = [
+    'setDate',
+    'setFullYear',
+    'setHours',
+    'setMilliseconds',
+    'setMinutes',
+    'setMonth',
+    'setSeconds',
+    'setTime',
+    'setUTCDate',
+    'setUTCFullYear',
+    'setUTCHours',
+    'setUTCMilliseconds',
+    'setUTCMinutes',
+    'setUTCMonth',
+    'setUTCSeconds',
+    'setYear',
+];
+(() => {
+    for (const setter of ImmutableDate.setters) {
+        Object.defineProperty(ImmutableDate.prototype, setter, {
+            value() {
+                throw new TypeError(`Cannot call ${setter}: the date is immutable`);
+            },
+        });
+    }
+})();
 const TIME_WITHOUT_ZONE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
 export class DateType extends AbstractType {
     filter(value) {
@@ -10,11 +42,14 @@ export class DateType extends AbstractType {
         if (!converted.ok || (typeof value === 'string' && TIME_WITHOUT_ZONE.test(value))) {
             throw new TypePrimitiveException('Date', value);
         }
-        return Immutable.date(converted.value);
+        return new ImmutableDate(converted.value);
     }
     toString() {
         return this._value === null ? '' : this._value.toISOString();
     }
+    hasSameValue(other) {
+        return this._value?.getTime() === other._value?.getTime();
+    }
 }
 const SYSTEM_TIME = { now: () => new Date() };
 export class CreatedAt extends Required(DateType) {

package/dist/esm/domain/type/enum-type.js

@@ -1,5 +1,5 @@
 import { AbstractType } from './abstract-type.js';
-import { TypePrimitiveException } from '../../exceptions/index.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
 const NUMERIC_TEXT = /^-?\d+(?:\.\d+)?$/;
 export class EnumType extends AbstractType {
     filter(value) {

package/dist/esm/domain/type/id-type.d.ts

@@ -1,5 +1,5 @@
 import { UuidType } from './uuid-type.js';
-declare const IdType_base: import("./required/required.js").RequiredType<typeof UuidType>;
+declare const IdType_base: import("./required/required-type.js").RequiredType<typeof UuidType>;
 export declare class IdType<Brand extends string = string> extends IdType_base {
     protected readonly idBrand: Brand;
     protected filter(value: unknown): string;

package/dist/esm/domain/type/id-type.js

@@ -1,6 +1,6 @@
-import { Required } from './required/required.js';
+import { Required } from './required/required-type.js';
 import { UuidType } from './uuid-type.js';
-import { TypePrimitiveException } from '../../exceptions/index.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
 const NIL_OR_MAX_UUID = /^(?:0{8}-0{4}-0{4}-0{4}-0{12}|f{8}-f{4}-f{4}-f{4}-f{12})$/i;
 export class IdType extends Required(UuidType) {
     filter(value) {

package/dist/esm/domain/type/index.d.ts

@@ -1,6 +1,6 @@
 export { AbstractType } from './abstract-type.js';
-export { Required } from './required/required.js';
-export type { RequiredType } from './required/required.js';
+export { Required } from './required/required-type.js';
+export type { RequiredType } from './required/required-type.js';
 export { ArrayType } from './array-type.js';
 export { BooleanType } from './boolean-type.js';
 export { CreatedAt, DateType, UpdatedAt } from './date-type.js';
@@ -11,7 +11,5 @@ export { NumberType } from './number-type.js';
 export { StringType } from './string-type.js';
 export { IdType } from './id-type.js';
 export { UuidType } from './uuid-type.js';
-export { Immutable } from './immutable/immutable.js';
-export { ValueObjects } from './value-objects/value-objects.js';
 export { Composite } from './composite/composite.js';
 export type { CompositeInput, CompositePrimitives, CompositeProps, CompositeSchema, CompositeType, CompositeValue, } from './composite/composite.js';

package/dist/esm/domain/type/index.js

@@ -1,5 +1,5 @@
 export { AbstractType } from './abstract-type.js';
-export { Required } from './required/required.js';
+export { Required } from './required/required-type.js';
 export { ArrayType } from './array-type.js';
 export { BooleanType } from './boolean-type.js';
 export { CreatedAt, DateType, UpdatedAt } from './date-type.js';
@@ -9,6 +9,4 @@ export { NumberType } from './number-type.js';
 export { StringType } from './string-type.js';
 export { IdType } from './id-type.js';
 export { UuidType } from './uuid-type.js';
-export { Immutable } from './immutable/immutable.js';
-export { ValueObjects } from './value-objects/value-objects.js';
 export { Composite } from './composite/composite.js';

package/dist/esm/domain/type/json-type.d.ts

@@ -2,4 +2,8 @@ import { AbstractType } from './abstract-type.js';
 export type JsonTypeValue = Record<string, any>;
 export declare class JsonType<T extends JsonTypeValue = JsonTypeValue> extends AbstractType<T> {
     protected filter(value: unknown): T;
+    protected hasSameValue(other: this): boolean;
+    private static sameJson;
+    private static deepFreeze;
+    private static isObject;
 }

package/dist/esm/domain/type/json-type.js

@@ -1,13 +1,42 @@
 import { toJson } from '@archi-code/validation';
 import { AbstractType } from './abstract-type.js';
-import { Immutable } from './immutable/immutable.js';
-import { TypePrimitiveException } from '../../exceptions/index.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
 export class JsonType extends AbstractType {
     filter(value) {
         const converted = toJson(value);
         if (!converted.ok) {
             throw new TypePrimitiveException('Json', value);
         }
-        return Immutable.freeze(JSON.parse(JSON.stringify(converted.value)));
+        return JsonType.deepFreeze(JSON.parse(JSON.stringify(converted.value)));
+    }
+    hasSameValue(other) {
+        return JsonType.sameJson(this._value, other._value);
+    }
+    static sameJson(left, right) {
+        if (Array.isArray(left) || Array.isArray(right)) {
+            return (Array.isArray(left) &&
+                Array.isArray(right) &&
+                left.length === right.length &&
+                left.every((item, index) => JsonType.sameJson(item, right[index])));
+        }
+        if (JsonType.isObject(left) && JsonType.isObject(right)) {
+            const keys = Object.keys(left);
+            return (keys.length === Object.keys(right).length &&
+                keys.every((key) => Object.prototype.hasOwnProperty.call(right, key) &&
+                    JsonType.sameJson(left[key], right[key])));
+        }
+        return left === right;
+    }
+    static deepFreeze(value) {
+        if (JsonType.isObject(value)) {
+            Object.freeze(value);
+            for (const child of Object.values(value)) {
+                JsonType.deepFreeze(child);
+            }
+        }
+        return value;
+    }
+    static isObject(value) {
+        return typeof value === 'object' && value !== null;
     }
 }

package/dist/esm/domain/type/number-type.js

@@ -1,6 +1,6 @@
 import { toFloat } from '@archi-code/validation';
 import { AbstractType } from './abstract-type.js';
-import { TypePrimitiveException } from '../../exceptions/index.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
 export class NumberType extends AbstractType {
     filter(value) {
         const converted = toFloat(value);

package/dist/esm/domain/type/required/required-mark.d.ts

@@ -6,4 +6,3 @@ export declare class RequiredMark {
 export interface RequiredMarked {
     readonly [RequiredMark.symbol]: true;
 }
-export type ValueOf<T, I> = I extends RequiredMarked ? T : T | null;

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

@@ -1,6 +1,6 @@
 import { toString as convertToString } from '@archi-code/validation';
 import { AbstractType } from './abstract-type.js';
-import { TypePrimitiveException } from '../../exceptions/index.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
 export class StringType extends AbstractType {
     filter(value) {
         const converted = convertToString(value);

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

@@ -1,7 +1,7 @@
 import { v4 as uuidv4, v5 as uuidv5 } from 'uuid';
 import { isUUID, toString as convertToString } from '@archi-code/validation';
 import { AbstractType } from './abstract-type.js';
-import { TypePrimitiveException } from '../../exceptions/index.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
 const DNS_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
 export class UuidType extends AbstractType {
     static random() {

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

@@ -1,4 +1,6 @@
-import { ApplicationException, DomainException, UnknownEventException, } from '../../exceptions/index.js';
+import { ApplicationException } from '../../application/index.js';
+import { DomainException } from '../../domain/index.js';
+import { UnknownEventException } from '../exceptions/unknown-event.exception.js';
 import { ListensTo } from '../../application/index.js';
 import { SilentLogger } from '../logging/silent-logger.js';
 export class DomainEventBus {
@@ -8,12 +10,11 @@ export class DomainEventBus {
         this.logger = logger;
     }
     async publish(events) {
-        await this.channel.send(events.map((event) => event.toJSON()));
+        await this.channel.send(events.map((event) => ({ ...event })));
         this.logger.debug('domain_events_published', {
             events: events.map((event) => ({
-                eventName: event.eventName(),
+                eventName: event.eventName,
                 eventId: event.eventId,
-                aggregateId: event.aggregateId,
             })),
         });
     }
@@ -41,7 +42,6 @@ export class DomainEventBus {
                 eventName,
                 consumer,
                 eventId: serialized.eventId,
-                aggregateId: serialized.aggregateId,
                 error,
             };
             if (error instanceof DomainException || error instanceof ApplicationException) {

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

@@ -1,5 +1,5 @@
-import { InternalErrorException, UnknownEventException } from '../../exceptions/index.js';
-import { Immutable } from '../../domain/index.js';
+import { InternalErrorException } from '../exceptions/internal-error.exception.js';
+import { UnknownEventException } from '../exceptions/unknown-event.exception.js';
 export class EventRegistry {
     constructor() {
         this.factories = new Map();
@@ -28,11 +28,11 @@ export class EventRegistry {
         }
         const rebuilt = factory(event);
         EventRegistry.assertSameIdentity(event, rebuilt);
-        return Immutable.freeze(rebuilt);
+        return rebuilt;
     }
     static assertSameIdentity(serialized, rebuilt) {
         if (rebuilt.eventId !== String(serialized.eventId).toLowerCase() ||
-            rebuilt.occurredOn.getTime() !== new Date(serialized.occurredOn).getTime()) {
+            Date.parse(rebuilt.occurredOn) !== Date.parse(serialized.occurredOn)) {
             throw new InternalErrorException(`the factory of "${serialized.eventName}" must pass the serialized event as metadata, so it keeps its eventId and occurredOn`);
         }
     }

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

@@ -1,4 +1,4 @@
-import { EventDeliveryException } from '../../../exceptions/index.js';
+import { EventDeliveryException } from '../../exceptions/event-delivery.exception.js';
 export class Emitter {
     constructor() {
         this.events = new Map();

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

@@ -12,5 +12,5 @@ export declare class InMemoryEventChannel implements EventChannel {
     get sent(): readonly SerializedEvent[];
     send(events: readonly SerializedEvent[]): Promise<void>;
     receive(eventName: string, consumer: string, handler: ChannelHandler): Promise<ChannelSubscription>;
-    private static frozenCopy;
+    private static copy;
 }

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

@@ -1,5 +1,4 @@
-import { Immutable } from '../../../domain/index.js';
-import { InfrastructureException } from '../../../exceptions/index.js';
+import { InfrastructureException } from '../../exceptions/infrastructure.exception.js';
 import { Emitter } from './emitter.js';
 export class InMemoryEventChannel {
     constructor({ delivery = 'serial' } = {}) {
@@ -13,7 +12,7 @@ export class InMemoryEventChannel {
     }
     async send(events) {
         for (const event of events) {
-            const copy = InMemoryEventChannel.frozenCopy(event);
+            const copy = InMemoryEventChannel.copy(event);
             this.sentEvents.push(copy);
             if (this.delivery === 'parallel') {
                 await this.emitter.emit(copy.eventName, copy);
@@ -29,7 +28,7 @@ export class InMemoryEventChannel {
             throw new InfrastructureException(`${consumer} already receives "${eventName}": close its subscription first.`);
         }
         this.receivers.add(receiver);
-        const off = this.emitter.on(eventName, (event) => handler(event));
+        const off = this.emitter.on(eventName, (event) => handler(InMemoryEventChannel.copy(event)));
         let open = true;
         return {
             close: async () => {
@@ -41,7 +40,7 @@ export class InMemoryEventChannel {
             },
         };
     }
-    static frozenCopy(event) {
-        return Immutable.freeze(JSON.parse(JSON.stringify(event)));
+    static copy(event) {
+        return JSON.parse(JSON.stringify(event));
     }
 }

package/dist/esm/{exceptions/infrastructure → infrastructure/exceptions}/event-delivery.exception.js

@@ -1,16 +1,16 @@
 var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { InfrastructureExceptionCode } from './infrastructure-exception-code.js';
 import { InfrastructureException } from './infrastructure.exception.js';
-import { ExceptionBrand } from '../brand/exception-brand.js';
-import { ExceptionCode } from '../exception-code.js';
 export class EventDeliveryException extends InfrastructureException {
     constructor(eventName, errors, consumers) {
         super(`${errors.length} of ${consumers} consumers of "${eventName}" failed.`, [
-            ExceptionCode.EventDelivery,
+            InfrastructureExceptionCode.EventDelivery,
         ]);
         this.errors = Object.freeze([...errors]);
     }
 }
 _a = EventDeliveryException;
 (() => {
-    ExceptionBrand.brandClass(_a, ExceptionCode.EventDelivery);
+    ExceptionBrand.brandClass(_a, InfrastructureExceptionCode.EventDelivery);
 })();

package/dist/esm/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/esm/infrastructure/exceptions/infrastructure-exception-code.js

@@ -0,0 +1,7 @@
+export var InfrastructureExceptionCode;
+(function (InfrastructureExceptionCode) {
+    InfrastructureExceptionCode["InfrastructureException"] = "INF000";
+    InfrastructureExceptionCode["InternalError"] = "INF001";
+    InfrastructureExceptionCode["UnknownEvent"] = "INF002";
+    InfrastructureExceptionCode["EventDelivery"] = "INF003";
+})(InfrastructureExceptionCode || (InfrastructureExceptionCode = {}));

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

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

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

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

package/dist/esm/{exceptions/infrastructure → infrastructure/exceptions}/internal-error.exception.d.ts

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

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

@@ -0,0 +1,13 @@
+var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { InfrastructureExceptionCode } from './infrastructure-exception-code.js';
+import { InfrastructureException } from './infrastructure.exception.js';
+export class InternalErrorException extends InfrastructureException {
+    constructor(message, options = {}) {
+        super(`Failed, internal error: ${message}`, [InfrastructureExceptionCode.InternalError], options);
+    }
+}
+_a = InternalErrorException;
+(() => {
+    ExceptionBrand.brandClass(_a, InfrastructureExceptionCode.InternalError);
+})();

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

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

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

@@ -0,0 +1,30 @@
+import { ApplicationException, AggregateNotFoundException, ConcurrencyException, NotAllowedException, UnexpectedErrorException, } from '../../../application/index.js';
+import { DomainException, InvalidEventDefinitionException, RequiredValueException, TypePrimitiveException, } from '../../../domain/index.js';
+import { ExceptionKind } from './exception-kind.js';
+export class ExceptionClassifier {
+    static classify(error) {
+        if (error instanceof AggregateNotFoundException) {
+            return ExceptionKind.NotFound;
+        }
+        if (error instanceof NotAllowedException) {
+            return ExceptionKind.NotAllowed;
+        }
+        if (error instanceof ConcurrencyException) {
+            return ExceptionKind.Conflict;
+        }
+        if (error instanceof UnexpectedErrorException ||
+            error instanceof InvalidEventDefinitionException) {
+            return ExceptionKind.Internal;
+        }
+        if (error instanceof TypePrimitiveException || error instanceof RequiredValueException) {
+            return ExceptionKind.Malformed;
+        }
+        if (error instanceof DomainException) {
+            return ExceptionKind.Invalid;
+        }
+        if (error instanceof ApplicationException) {
+            return ExceptionKind.Rejected;
+        }
+        return ExceptionKind.Internal;
+    }
+}

package/dist/esm/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/esm/infrastructure/exceptions/kind/exception-kind.js

@@ -0,0 +1,10 @@
+export 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 || (ExceptionKind = {}));

package/dist/esm/{exceptions/infrastructure → infrastructure/exceptions}/unknown-event.exception.js

@@ -1,15 +1,15 @@
 var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { InfrastructureExceptionCode } from './infrastructure-exception-code.js';
 import { InfrastructureException } from './infrastructure.exception.js';
-import { ExceptionBrand } from '../brand/exception-brand.js';
-import { ExceptionCode } from '../exception-code.js';
 export class UnknownEventException extends InfrastructureException {
     constructor(eventName) {
         super(`Unknown event "${eventName}": register it before reading it.`, [
-            ExceptionCode.UnknownEvent,
+            InfrastructureExceptionCode.UnknownEvent,
         ]);
     }
 }
 _a = UnknownEventException;
 (() => {
-    ExceptionBrand.brandClass(_a, ExceptionCode.UnknownEvent);
+    ExceptionBrand.brandClass(_a, InfrastructureExceptionCode.UnknownEvent);
 })();

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

@@ -7,10 +7,15 @@ export type { EventFactory } from './event/event-registry.js';
 export type { ChannelHandler, ChannelSubscription, EventChannel } from './event/event-channel.js';
 export { InMemoryEventChannel } from './event/in-memory/in-memory-event-channel.js';
 export type { InMemoryEventChannelOptions } from './event/in-memory/in-memory-event-channel.js';
-export { HttpErrorMapper } from './http/http-error-mapper.js';
-export type { HttpError, HttpErrorBody, HttpErrorMapperOptions } from './http/http-error-mapper.js';
 export { ConsoleLogger } from './logging/console-logger.js';
 export type { ConsoleLoggerOptions } from './logging/console-logger.js';
 export { InMemoryLogger } from './logging/in-memory-logger.js';
 export type { LogEntry } from './logging/in-memory-logger.js';
 export { SilentLogger } from './logging/silent-logger.js';
+export { InfrastructureException } from './exceptions/infrastructure.exception.js';
+export { InternalErrorException } from './exceptions/internal-error.exception.js';
+export { UnknownEventException } from './exceptions/unknown-event.exception.js';
+export { EventDeliveryException } from './exceptions/event-delivery.exception.js';
+export { InfrastructureExceptionCode } from './exceptions/infrastructure-exception-code.js';
+export { ExceptionClassifier } from './exceptions/kind/exception-classifier.js';
+export { ExceptionKind } from './exceptions/kind/exception-kind.js';

package/dist/esm/infrastructure/index.js

@@ -3,7 +3,13 @@ export { FixedClock } from './clock/fixed-clock.js';
 export { DomainEventBus } from './event/domain-event-bus.js';
 export { EventRegistry } from './event/event-registry.js';
 export { InMemoryEventChannel } from './event/in-memory/in-memory-event-channel.js';
-export { HttpErrorMapper } from './http/http-error-mapper.js';
 export { ConsoleLogger } from './logging/console-logger.js';
 export { InMemoryLogger } from './logging/in-memory-logger.js';
 export { SilentLogger } from './logging/silent-logger.js';
+export { InfrastructureException } from './exceptions/infrastructure.exception.js';
+export { InternalErrorException } from './exceptions/internal-error.exception.js';
+export { UnknownEventException } from './exceptions/unknown-event.exception.js';
+export { EventDeliveryException } from './exceptions/event-delivery.exception.js';
+export { InfrastructureExceptionCode } from './exceptions/infrastructure-exception-code.js';
+export { ExceptionClassifier } from './exceptions/kind/exception-classifier.js';
+export { ExceptionKind } from './exceptions/kind/exception-kind.js';

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

@@ -1,4 +1,4 @@
-import { InternalErrorException } from '../../exceptions/index.js';
+import { InternalErrorException } from '../exceptions/internal-error.exception.js';
 import { SystemClock } from '../clock/system-clock.js';
 import { LogSerializer } from './log-serializer.js';
 export class ConsoleLogger {

package/dist/{cjs → esm/shared}/exceptions/abstract.exception.d.ts

@@ -1,17 +1,19 @@
-import { ExceptionCode } from './exception-code';
 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;
-    readonly code: ExceptionCode | string;
+    private readonly codeNames;
+    readonly code: string;
     private readonly createdAt;
     static [Symbol.hasInstance](candidate: unknown): boolean;
-    constructor(message: string, exceptionCodes: (ExceptionCode | string)[], options?: ExceptionOptions);
-    static readonly ExceptionCodeStrings: Record<ExceptionCode, string>;
+    constructor(message: string, exceptionCodes: string[], options?: ExceptionOptions, codeNames?: ExceptionCodeNames);
     get timestamp(): Date;
     get description(): string;
+    private labelOf;
     print(): string;
     toJSON(): {
         name: string;

package/dist/esm/{exceptions → shared/exceptions}/abstract.exception.js

@@ -1,19 +1,19 @@
 var _a;
-import { ExceptionCode } from './exception-code.js';
 import { ExceptionBrand } from './brand/exception-brand.js';
 export class AbstractException extends Error {
     static [Symbol.hasInstance](candidate) {
         return (Function.prototype[Symbol.hasInstance].call(this, candidate) ||
             ExceptionBrand.matches(this, candidate));
     }
-    constructor(message, exceptionCodes, options = {}) {
+    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]
-                : ExceptionCode.ErrorException;
+                : _a.fallbackCode;
         this.createdAt = Date.now();
         if ('cause' in options) {
             Object.defineProperty(this, 'cause', {
@@ -29,12 +29,11 @@ export class AbstractException extends Error {
         return new Date(this.createdAt);
     }
     get description() {
-        return this.exceptionCodes
-            .map((code) => {
-            const codeString = _a.ExceptionCodeStrings[code] ?? this.name;
-            return `${codeString} (${code})`;
-        })
-            .join(', ');
+        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()}`;
@@ -50,13 +49,7 @@ export class AbstractException extends Error {
     }
 }
 _a = AbstractException;
+AbstractException.fallbackCode = 'E000';
 (() => {
     ExceptionBrand.brandClass(_a, ExceptionBrand.anyCode);
 })();
-AbstractException.ExceptionCodeStrings = Object.keys(ExceptionCode)
-    .filter((key) => isNaN(Number(key)))
-    .reduce((acc, key) => {
-    const value = ExceptionCode[key];
-    acc[value] = key.replace(/([A-Z])/g, ' $1').trim();
-    return acc;
-}, {});

package/dist/esm/shared/index.d.ts

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

package/dist/esm/shared/index.js

@@ -0,0 +1,5 @@
+export { AbstractException } from './exceptions/abstract.exception.js';
+export { ExceptionBrand } from './exceptions/brand/exception-brand.js';
+export { ReceivedValue } from './exceptions/received/received-value.js';
+export { IssueCollector } from './issue-collector.js';
+export { IssueCollectionError } from './issue-collection-error.js';

package/dist/esm/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[]);
+}