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

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

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumType = void 0;
 const abstract_type_1 = require("./abstract-type");
-const index_1 = require("../../exceptions/index");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
 const NUMERIC_TEXT = /^-?\d+(?:\.\d+)?$/;
 class EnumType extends abstract_type_1.AbstractType {
     filter(value) {
         const options = this.options();
         const option = options.find((candidate) => EnumType.matches(candidate, value));
         if (option === undefined) {
-            throw new index_1.TypePrimitiveException(`Expected one of [${options.join(', ')}]`, value, '');
+            throw new type_primitive_exception_1.TypePrimitiveException(`Expected one of [${options.join(', ')}]`, value, '');
         }
         return option;
     }

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

@@ -1,5 +1,5 @@
 import { UuidType } from './uuid-type';
-declare const IdType_base: import("./required/required").RequiredType<typeof UuidType>;
+declare const IdType_base: import("./required/required-type").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/cjs/domain/type/id-type.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdType = void 0;
-const required_1 = require("./required/required");
+const required_type_1 = require("./required/required-type");
 const uuid_type_1 = require("./uuid-type");
-const index_1 = require("../../exceptions/index");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
 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;
-class IdType extends (0, required_1.Required)(uuid_type_1.UuidType) {
+class IdType extends (0, required_type_1.Required)(uuid_type_1.UuidType) {
     filter(value) {
         const id = super.filter(value);
         if (NIL_OR_MAX_UUID.test(id)) {
-            throw new index_1.TypePrimitiveException('Id', value);
+            throw new type_primitive_exception_1.TypePrimitiveException('Id', value);
         }
         return id;
     }

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

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

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Composite = exports.ValueObjects = exports.Immutable = exports.UuidType = exports.IdType = exports.StringType = exports.NumberType = exports.JsonType = exports.EnumType = exports.UpdatedAt = exports.DateType = exports.CreatedAt = exports.BooleanType = exports.ArrayType = exports.Required = exports.AbstractType = void 0;
+exports.Composite = exports.UuidType = exports.IdType = exports.StringType = exports.NumberType = exports.JsonType = exports.EnumType = exports.UpdatedAt = exports.DateType = exports.CreatedAt = exports.BooleanType = exports.ArrayType = exports.Required = exports.AbstractType = void 0;
 var abstract_type_1 = require("./abstract-type");
 Object.defineProperty(exports, "AbstractType", { enumerable: true, get: function () { return abstract_type_1.AbstractType; } });
-var required_1 = require("./required/required");
-Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return required_1.Required; } });
+var required_type_1 = require("./required/required-type");
+Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return required_type_1.Required; } });
 var array_type_1 = require("./array-type");
 Object.defineProperty(exports, "ArrayType", { enumerable: true, get: function () { return array_type_1.ArrayType; } });
 var boolean_type_1 = require("./boolean-type");
@@ -25,9 +25,5 @@ var id_type_1 = require("./id-type");
 Object.defineProperty(exports, "IdType", { enumerable: true, get: function () { return id_type_1.IdType; } });
 var uuid_type_1 = require("./uuid-type");
 Object.defineProperty(exports, "UuidType", { enumerable: true, get: function () { return uuid_type_1.UuidType; } });
-var immutable_1 = require("./immutable/immutable");
-Object.defineProperty(exports, "Immutable", { enumerable: true, get: function () { return immutable_1.Immutable; } });
-var value_objects_1 = require("./value-objects/value-objects");
-Object.defineProperty(exports, "ValueObjects", { enumerable: true, get: function () { return value_objects_1.ValueObjects; } });
 var composite_1 = require("./composite/composite");
 Object.defineProperty(exports, "Composite", { enumerable: true, get: function () { return composite_1.Composite; } });

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

@@ -2,4 +2,8 @@ import { AbstractType } from './abstract-type';
 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/cjs/domain/type/json-type.js

@@ -3,15 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonType = void 0;
 const validation_1 = require("@archi-code/validation");
 const abstract_type_1 = require("./abstract-type");
-const immutable_1 = require("./immutable/immutable");
-const index_1 = require("../../exceptions/index");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
 class JsonType extends abstract_type_1.AbstractType {
     filter(value) {
         const converted = (0, validation_1.toJson)(value);
         if (!converted.ok) {
-            throw new index_1.TypePrimitiveException('Json', value);
+            throw new type_primitive_exception_1.TypePrimitiveException('Json', value);
         }
-        return immutable_1.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;
     }
 }
 exports.JsonType = JsonType;

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

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NumberType = void 0;
 const validation_1 = require("@archi-code/validation");
 const abstract_type_1 = require("./abstract-type");
-const index_1 = require("../../exceptions/index");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
 class NumberType extends abstract_type_1.AbstractType {
     filter(value) {
         const converted = (0, validation_1.toFloat)(value);
         if (!converted.ok) {
-            throw new index_1.TypePrimitiveException('Number', value);
+            throw new type_primitive_exception_1.TypePrimitiveException('Number', value);
         }
         return converted.value;
     }

package/dist/cjs/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/cjs/domain/type/string-type.js

@@ -3,12 +3,12 @@ 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 index_1 = require("../../exceptions/index");
+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 index_1.TypePrimitiveException('String', value);
+            throw new type_primitive_exception_1.TypePrimitiveException('String', value);
         }
         return converted.value;
     }

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

@@ -4,7 +4,7 @@ exports.UuidType = void 0;
 const uuid_1 = require("uuid");
 const validation_1 = require("@archi-code/validation");
 const abstract_type_1 = require("./abstract-type");
-const index_1 = require("../../exceptions/index");
+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() {
@@ -19,7 +19,7 @@ class UuidType extends abstract_type_1.AbstractType {
     filter(value) {
         const converted = (0, validation_1.toString)(value);
         if (!converted.ok || !(0, validation_1.isUUID)(converted.value)) {
-            throw new index_1.TypePrimitiveException('UUID', value);
+            throw new type_primitive_exception_1.TypePrimitiveException('UUID', value);
         }
         return converted.value.toLowerCase();
     }

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

@@ -1,8 +1,10 @@
 "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 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()) {
@@ -11,20 +13,19 @@ 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,
             })),
         });
     }
     async subscribe(listener) {
-        const subscription = index_2.ListensTo.subscriptionOf(listener);
+        const subscription = index_3.ListensTo.subscriptionOf(listener);
         const { eventName, consumer } = subscription;
         if (!this.registry.has(eventName)) {
-            throw new index_1.UnknownEventException(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 });
@@ -44,10 +45,9 @@ class DomainEventBus {
                 eventName,
                 consumer,
                 eventId: serialized.eventId,
-                aggregateId: serialized.aggregateId,
                 error,
             };
-            if (error instanceof index_1.DomainException || error instanceof index_1.ApplicationException) {
+            if (error instanceof index_2.DomainException || error instanceof index_1.ApplicationException) {
                 this.logger.warn('event_listener_rejected', context);
             }
             else {

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventRegistry = void 0;
-const index_1 = require("../../exceptions/index");
-const index_2 = require("../../domain/index");
+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();
@@ -10,7 +10,7 @@ class EventRegistry {
     register(event, factory) {
         const { eventName } = event;
         if (this.factories.has(eventName)) {
-            throw new index_1.InternalErrorException(`event "${eventName}" is already registered`);
+            throw new internal_error_exception_1.InternalErrorException(`event "${eventName}" is already registered`);
         }
         this.factories.set(eventName, factory);
         return this;
@@ -20,23 +20,23 @@ class EventRegistry {
     }
     fromJSON(event) {
         if (typeof event !== 'object' || event === null) {
-            throw new index_1.InternalErrorException('a serialized event must be a JSON object');
+            throw new internal_error_exception_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');
+            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 index_1.UnknownEventException(event.eventName);
+            throw new unknown_event_exception_1.UnknownEventException(event.eventName);
         }
         const rebuilt = factory(event);
         EventRegistry.assertSameIdentity(event, rebuilt);
-        return index_2.Immutable.freeze(rebuilt);
+        return 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`);
+            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`);
         }
     }
 }

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = void 0;
-const index_1 = require("../../../exceptions/index");
+const event_delivery_exception_1 = require("../../exceptions/event-delivery.exception");
 class Emitter {
     constructor() {
         this.events = new Map();
@@ -33,7 +33,7 @@ class Emitter {
         }));
         const errors = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
         if (errors.length > 0) {
-            throw new index_1.EventDeliveryException(eventName, errors, snapshot.length);
+            throw new event_delivery_exception_1.EventDeliveryException(eventName, errors, snapshot.length);
         }
     }
     async emitSerial(eventName, data) {

package/dist/cjs/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/cjs/infrastructure/event/in-memory/in-memory-event-channel.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryEventChannel = void 0;
-const index_1 = require("../../../domain/index");
-const index_2 = require("../../../exceptions/index");
+const infrastructure_exception_1 = require("../../exceptions/infrastructure.exception");
 const emitter_1 = require("./emitter");
 class InMemoryEventChannel {
     constructor({ delivery = 'serial' } = {}) {
@@ -16,7 +15,7 @@ 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,10 +28,10 @@ class InMemoryEventChannel {
     async receive(eventName, consumer, handler) {
         const receiver = JSON.stringify([eventName, consumer]);
         if (this.receivers.has(receiver)) {
-            throw new index_2.InfrastructureException(`${consumer} already receives "${eventName}": close its subscription first.`);
+            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(event));
+        const off = this.emitter.on(eventName, (event) => handler(InMemoryEventChannel.copy(event)));
         let open = true;
         return {
             close: async () => {
@@ -44,8 +43,8 @@ class InMemoryEventChannel {
             },
         };
     }
-    static frozenCopy(event) {
-        return index_1.Immutable.freeze(JSON.parse(JSON.stringify(event)));
+    static copy(event) {
+        return JSON.parse(JSON.stringify(event));
     }
 }
 exports.InMemoryEventChannel = InMemoryEventChannel;

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

@@ -2,13 +2,13 @@
 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");
-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,
+            infrastructure_exception_code_1.InfrastructureExceptionCode.EventDelivery,
         ]);
         this.errors = Object.freeze([...errors]);
     }
@@ -16,5 +16,5 @@ class EventDeliveryException extends infrastructure_exception_1.InfrastructureEx
 exports.EventDeliveryException = EventDeliveryException;
 _a = EventDeliveryException;
 (() => {
-    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.EventDelivery);
+    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/{exceptions/infrastructure → infrastructure/exceptions}/internal-error.exception.d.ts

@@ -1,5 +1,5 @@
+import type { ExceptionOptions } from '../../shared/index';
 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 → infrastructure/exceptions}/internal-error.exception.js

@@ -2,16 +2,16 @@
 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");
-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);
+        super(`Failed, internal error: ${message}`, [infrastructure_exception_code_1.InfrastructureExceptionCode.InternalError], options);
     }
 }
 exports.InternalErrorException = InternalErrorException;
 _a = InternalErrorException;
 (() => {
-    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.InternalError);
+    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/{exceptions/infrastructure → infrastructure/exceptions}/unknown-event.exception.js

@@ -2,18 +2,18 @@
 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");
-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,
+            infrastructure_exception_code_1.InfrastructureExceptionCode.UnknownEvent,
         ]);
     }
 }
 exports.UnknownEventException = UnknownEventException;
 _a = UnknownEventException;
 (() => {
-    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.UnknownEvent);
+    index_1.ExceptionBrand.brandClass(_a, infrastructure_exception_code_1.InfrastructureExceptionCode.UnknownEvent);
 })();

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

@@ -7,10 +7,15 @@ 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 { HttpErrorMapper } from './http/http-error-mapper';
-export type { HttpError, HttpErrorBody, HttpErrorMapperOptions } from './http/http-error-mapper';
 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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SilentLogger = exports.InMemoryLogger = exports.ConsoleLogger = exports.HttpErrorMapper = exports.InMemoryEventChannel = exports.EventRegistry = exports.DomainEventBus = exports.FixedClock = exports.SystemClock = void 0;
+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");
@@ -11,11 +11,23 @@ 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 http_error_mapper_1 = require("./http/http-error-mapper");
-Object.defineProperty(exports, "HttpErrorMapper", { enumerable: true, get: function () { return http_error_mapper_1.HttpErrorMapper; } });
 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; } });