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

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ListensTo = ListensTo;
-const index_1 = require("../../exceptions/index");
+const application_exception_1 = require("../exceptions/application.exception");
 const LISTENED_EVENT = Symbol.for('@archi-code/ddd/listens-to.v1');
 function ListensTo(event, options) {
     return (listener) => {
         if (Object.prototype.hasOwnProperty.call(listener, LISTENED_EVENT)) {
-            throw new index_1.ApplicationException(`${listener.name} already listens to an event`);
+            throw new application_exception_1.ApplicationException(`${listener.name} already listens to an event`);
         }
         const consumer = options?.consumer;
         if (typeof consumer !== 'string' || consumer.trim() === '') {
-            throw new index_1.ApplicationException(`${listener.name} needs a consumer name: @ListensTo(<event class>, { consumer: '<name>' })`);
+            throw new application_exception_1.ApplicationException(`${listener.name} needs a consumer name: @ListensTo(<event class>, { consumer: '<name>' })`);
         }
         const subscription = Object.freeze({
             eventName: event.eventName,
@@ -22,7 +22,7 @@ function ListensTo(event, options) {
 ListensTo.subscriptionOf = (listener) => {
     const listenerClass = listener.constructor;
     if (!Object.prototype.hasOwnProperty.call(listenerClass, LISTENED_EVENT)) {
-        throw new index_1.ApplicationException(`${listenerClass.name} needs @ListensTo(<event class>, { consumer: '<name>' })`);
+        throw new application_exception_1.ApplicationException(`${listenerClass.name} needs @ListensTo(<event class>, { consumer: '<name>' })`);
     }
     return listenerClass[LISTENED_EVENT];
 };

package/dist/cjs/{exceptions/application → application/exceptions}/aggregate-not-found.exception.d.ts

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

package/dist/cjs/{exceptions/application → application/exceptions}/aggregate-not-found.exception.js

@@ -2,16 +2,16 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateNotFoundException = void 0;
+const index_1 = require("../../shared/index");
+const application_exception_code_1 = require("./application-exception-code");
 const application_exception_1 = require("./application.exception");
-const exception_brand_1 = require("../brand/exception-brand");
-const exception_code_1 = require("../exception-code");
 class AggregateNotFoundException extends application_exception_1.ApplicationException {
     constructor(entity, id, options = {}) {
-        super(`${entity} with ID ${id} not found.`, [exception_code_1.ExceptionCode.AggregateNotFound], options);
+        super(`${entity} with ID ${id} not found.`, [application_exception_code_1.ApplicationExceptionCode.AggregateNotFound], options);
     }
 }
 exports.AggregateNotFoundException = AggregateNotFoundException;
 _a = AggregateNotFoundException;
 (() => {
-    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.AggregateNotFound);
+    index_1.ExceptionBrand.brandClass(_a, application_exception_code_1.ApplicationExceptionCode.AggregateNotFound);
 })();

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationExceptionCode = void 0;
+var ApplicationExceptionCode;
+(function (ApplicationExceptionCode) {
+    ApplicationExceptionCode["ApplicationException"] = "APP000";
+    ApplicationExceptionCode["ConcurrencyConflict"] = "APP001";
+    ApplicationExceptionCode["AggregateNotFound"] = "APP002";
+    ApplicationExceptionCode["NotAllowed"] = "APP003";
+    ApplicationExceptionCode["UnexpectedError"] = "APP004";
+})(ApplicationExceptionCode || (exports.ApplicationExceptionCode = ApplicationExceptionCode = {}));

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

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

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

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

package/dist/cjs/{exceptions/application → application/exceptions}/concurrency.exception.d.ts

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

package/dist/cjs/{exceptions/application → application/exceptions}/concurrency.exception.js

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

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

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

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

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

package/dist/cjs/application/exceptions/unexpected-error.exception.d.ts

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

package/dist/cjs/application/exceptions/unexpected-error.exception.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnexpectedErrorException = void 0;
+const index_1 = require("../../shared/index");
+const application_exception_code_1 = require("./application-exception-code");
+const application_exception_1 = require("./application.exception");
+class UnexpectedErrorException extends application_exception_1.ApplicationException {
+    constructor(message, options = {}) {
+        super(`Failed, unexpected error: ${message}`, [application_exception_code_1.ApplicationExceptionCode.UnexpectedError], options);
+    }
+}
+exports.UnexpectedErrorException = UnexpectedErrorException;
+_a = UnexpectedErrorException;
+(() => {
+    index_1.ExceptionBrand.brandClass(_a, application_exception_code_1.ApplicationExceptionCode.UnexpectedError);
+})();

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

@@ -1,7 +1,14 @@
 export { UseCase } from './use-case/use-case';
+export { ValueObjectBuilder } from './value-object-builder/value-object-builder';
 export { EventListener } from './event/event-listener';
 export { ListensTo } from './event/listens-to';
 export type { ListenerSubscription, ListensToOptions } from './event/listens-to';
 export type { EventBus } from './event/event-bus';
 export type { Clock } from './ports/clock';
 export type { LogContext, Logger, LogLevel } from './ports/logger';
+export { ApplicationException } from './exceptions/application.exception';
+export { ConcurrencyException } from './exceptions/concurrency.exception';
+export { AggregateNotFoundException } from './exceptions/aggregate-not-found.exception';
+export { NotAllowedException } from './exceptions/not-allowed.exception';
+export { UnexpectedErrorException } from './exceptions/unexpected-error.exception';
+export { ApplicationExceptionCode } from './exceptions/application-exception-code';

package/dist/cjs/application/index.js

@@ -1,9 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListensTo = exports.EventListener = exports.UseCase = void 0;
+exports.ApplicationExceptionCode = exports.UnexpectedErrorException = exports.NotAllowedException = exports.AggregateNotFoundException = exports.ConcurrencyException = exports.ApplicationException = exports.ListensTo = exports.EventListener = exports.ValueObjectBuilder = exports.UseCase = void 0;
 var use_case_1 = require("./use-case/use-case");
 Object.defineProperty(exports, "UseCase", { enumerable: true, get: function () { return use_case_1.UseCase; } });
+var value_object_builder_1 = require("./value-object-builder/value-object-builder");
+Object.defineProperty(exports, "ValueObjectBuilder", { enumerable: true, get: function () { return value_object_builder_1.ValueObjectBuilder; } });
 var event_listener_1 = require("./event/event-listener");
 Object.defineProperty(exports, "EventListener", { enumerable: true, get: function () { return event_listener_1.EventListener; } });
 var listens_to_1 = require("./event/listens-to");
 Object.defineProperty(exports, "ListensTo", { enumerable: true, get: function () { return listens_to_1.ListensTo; } });
+var application_exception_1 = require("./exceptions/application.exception");
+Object.defineProperty(exports, "ApplicationException", { enumerable: true, get: function () { return application_exception_1.ApplicationException; } });
+var concurrency_exception_1 = require("./exceptions/concurrency.exception");
+Object.defineProperty(exports, "ConcurrencyException", { enumerable: true, get: function () { return concurrency_exception_1.ConcurrencyException; } });
+var aggregate_not_found_exception_1 = require("./exceptions/aggregate-not-found.exception");
+Object.defineProperty(exports, "AggregateNotFoundException", { enumerable: true, get: function () { return aggregate_not_found_exception_1.AggregateNotFoundException; } });
+var not_allowed_exception_1 = require("./exceptions/not-allowed.exception");
+Object.defineProperty(exports, "NotAllowedException", { enumerable: true, get: function () { return not_allowed_exception_1.NotAllowedException; } });
+var unexpected_error_exception_1 = require("./exceptions/unexpected-error.exception");
+Object.defineProperty(exports, "UnexpectedErrorException", { enumerable: true, get: function () { return unexpected_error_exception_1.UnexpectedErrorException; } });
+var application_exception_code_1 = require("./exceptions/application-exception-code");
+Object.defineProperty(exports, "ApplicationExceptionCode", { enumerable: true, get: function () { return application_exception_code_1.ApplicationExceptionCode; } });

package/dist/cjs/application/use-case/use-case.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UseCase = void 0;
 const validation_1 = require("@archi-code/validation");
-const index_1 = require("../../exceptions/index");
+const index_1 = require("../../shared/index");
+const unexpected_error_exception_1 = require("../exceptions/unexpected-error.exception");
 class UseCase {
     async execute(input) {
         try {
@@ -12,7 +13,7 @@ class UseCase {
             if (error instanceof index_1.AbstractException) {
                 throw error;
             }
-            throw new index_1.InternalErrorException(`${this.constructor.name}: ${UseCase.describe(error)}`, {
+            throw new unexpected_error_exception_1.UnexpectedErrorException(`${this.constructor.name}: ${UseCase.describe(error)}`, {
                 cause: error,
             });
         }

package/dist/{esm/domain/type/value-objects/value-objects.d.ts → cjs/application/value-object-builder/value-object-builder.d.ts}

@@ -5,12 +5,12 @@ type Built<F extends Factories> = {
 type Synchronous<F extends Factories> = {
     [Field in keyof F]: [ReturnType<F[Field]>] extends [never] ? F[Field] : [ReturnType<F[Field]>] extends [PromiseLike<unknown>] ? never : F[Field];
 };
-export declare class ValueObjects {
+export declare class ValueObjectBuilder {
     static build<F extends Factories>(factories: F & Synchronous<F>): Built<F>;
     static buildList<Value, Item>(values: readonly Value[], factory: (value: Value, index: number) => Item): Item[];
     private static synchronous;
+    private static validated;
+    private static read;
     private static isThenable;
-    private static issuesOf;
-    private static assertNoIssues;
 }
 export {};

package/dist/cjs/application/value-object-builder/value-object-builder.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObjectBuilder = void 0;
+const index_1 = require("../../domain/index");
+const index_2 = require("../../shared/index");
+const unexpected_error_exception_1 = require("../exceptions/unexpected-error.exception");
+class ValueObjectBuilder {
+    static build(factories) {
+        const builds = Object.fromEntries(Object.entries(factories).map(([field, factory]) => [
+            field,
+            () => ValueObjectBuilder.synchronous(field, factory()),
+        ]));
+        return ValueObjectBuilder.validated(() => index_2.IssueCollector.collectFields(builds, ValueObjectBuilder.read));
+    }
+    static buildList(values, factory) {
+        return ValueObjectBuilder.validated(() => index_2.IssueCollector.collectItems(values, (value, index) => ValueObjectBuilder.synchronous(String(index), factory(value, index)), ValueObjectBuilder.read));
+    }
+    static synchronous(field, result) {
+        if (!ValueObjectBuilder.isThenable(result)) {
+            return result;
+        }
+        result.then(undefined, () => undefined);
+        throw new unexpected_error_exception_1.UnexpectedErrorException(`ValueObjectBuilder: the factory of "${field}" returned a Promise; build value objects synchronously`);
+    }
+    static validated(collect) {
+        try {
+            return collect();
+        }
+        catch (error) {
+            if (error instanceof index_2.IssueCollectionError) {
+                throw new index_1.ValidationException(error.issues);
+            }
+            throw error;
+        }
+    }
+    static read(error) {
+        if (error instanceof index_1.ValidationException) {
+            return error.errors;
+        }
+        if (error instanceof index_1.DomainException) {
+            return [{ field: null, code: error.code, message: error.message }];
+        }
+        return null;
+    }
+    static isThenable(result) {
+        return ((typeof result === 'object' || typeof result === 'function') &&
+            result !== null &&
+            typeof result.then === 'function');
+    }
+}
+exports.ValueObjectBuilder = ValueObjectBuilder;

package/dist/cjs/domain/aggregate/aggregate-root.d.ts

@@ -4,11 +4,6 @@ import type { EventBase } from '../event/event-base';
 import type { IdType } from '../type/id-type';
 export declare abstract class AggregateRoot<Id extends EntityId = IdType, Event extends EventBase = EventBase> extends Entity<Id> {
     private readonly domainEvents;
-    private persistedVersion;
-    constructor(id: Id);
-    get version(): number;
     protected record(event: Event): void;
     pullDomainEvents(): Event[];
-    restoreVersion(version: number): this;
-    markPersisted(): void;
 }

package/dist/cjs/domain/aggregate/aggregate-root.js

@@ -2,32 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateRoot = void 0;
 const entity_1 = require("../entity/entity");
-const immutable_1 = require("../type/immutable/immutable");
-const index_1 = require("../../exceptions/index");
 class AggregateRoot extends entity_1.Entity {
-    constructor(id) {
-        super(id);
-        Object.defineProperty(this, 'domainEvents', { value: [] });
-        Object.defineProperty(this, 'persistedVersion', { value: 0, writable: true });
-    }
-    get version() {
-        return this.persistedVersion;
+    constructor() {
+        super(...arguments);
+        this.domainEvents = [];
     }
     record(event) {
-        this.domainEvents.push(immutable_1.Immutable.freeze(event));
+        this.domainEvents.push(event);
     }
     pullDomainEvents() {
         return this.domainEvents.splice(0);
     }
-    restoreVersion(version) {
-        if (!Number.isSafeInteger(version) || version < 0) {
-            throw new index_1.InternalErrorException(`${this.constructor.name} cannot be restored with version ${String(version)}`);
-        }
-        this.persistedVersion = version;
-        return this;
-    }
-    markPersisted() {
-        this.persistedVersion += 1;
-    }
 }
 exports.AggregateRoot = AggregateRoot;

package/dist/cjs/domain/entity/entity.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Entity = void 0;
-const index_1 = require("../../exceptions/index");
+const required_value_exception_1 = require("../exceptions/required-value.exception");
 class Entity {
     constructor(id) {
         this.id = id;
         if (id?.isNull !== false) {
-            throw new index_1.RequiredValueException(`${new.target.name}.id`, id?.value);
+            throw new required_value_exception_1.RequiredValueException(`${new.target.name}.id`, id?.value);
         }
     }
     equals(other) {

package/dist/cjs/domain/event/event-base.d.ts

@@ -7,23 +7,17 @@ export interface EventMetadata {
 }
 export interface SerializedEvent {
     eventName: string;
-    eventVersion: number;
     eventId: string;
-    aggregateId: string;
     occurredOn: string;
     [payload: string]: unknown;
 }
 export interface EventClass<Event extends EventBase = EventBase> {
     readonly eventName: string;
-    readonly eventVersion?: number;
     new (...args: any[]): Event;
 }
 export declare abstract class EventBase {
+    readonly eventName: string;
     readonly eventId: string;
-    readonly aggregateId: string;
-    readonly occurredOn: Date;
-    constructor(aggregateId: string, metadata?: EventMetadata);
-    eventName(): string;
-    eventVersion(): number;
-    toJSON(): SerializedEvent;
+    readonly occurredOn: string;
+    constructor(metadata?: EventMetadata);
 }

package/dist/cjs/domain/event/event-base.js

@@ -4,48 +4,18 @@ exports.EventBase = void 0;
 const date_type_1 = require("../type/date-type");
 const id_type_1 = require("../type/id-type");
 const uuid_type_1 = require("../type/uuid-type");
-const index_1 = require("../../exceptions/index");
+const invalid_event_definition_exception_1 = require("../exceptions/invalid-event-definition.exception");
 class EventBase {
-    constructor(aggregateId, metadata = {}) {
-        const { eventName, eventVersion = 1 } = this.constructor;
+    constructor(metadata = {}) {
+        const { eventName } = this.constructor;
         if (typeof eventName !== 'string' || eventName.trim() === '') {
-            throw new index_1.InternalErrorException(`${this.constructor.name} must declare a static eventName`);
+            throw new invalid_event_definition_exception_1.InvalidEventDefinitionException(this.constructor.name);
         }
-        if (!Number.isSafeInteger(eventVersion) || eventVersion < 1) {
-            throw new index_1.InternalErrorException(`${this.constructor.name}.eventVersion must be a whole number from 1`);
-        }
-        if (aggregateId === null ||
-            aggregateId === undefined ||
-            (typeof aggregateId === 'string' && aggregateId.trim() === '')) {
-            throw new index_1.RequiredValueException(`${this.constructor.name}.aggregateId`, aggregateId);
-        }
-        this.aggregateId = aggregateId;
+        this.eventName = eventName;
         this.eventId = new id_type_1.IdType(metadata.eventId ?? uuid_type_1.UuidType.random()).value;
-        this.occurredOn =
-            metadata.occurredOn === undefined
-                ? date_type_1.CreatedAt.now(metadata.clock).value
-                : new date_type_1.CreatedAt(metadata.occurredOn).value;
-    }
-    eventName() {
-        return this.constructor.eventName;
-    }
-    eventVersion() {
-        return this.constructor.eventVersion ?? 1;
-    }
-    toJSON() {
-        const serialized = {
-            eventName: this.eventName(),
-            eventVersion: this.eventVersion(),
-            eventId: this.eventId,
-            aggregateId: this.aggregateId,
-            occurredOn: this.occurredOn.toISOString(),
-        };
-        for (const [key, value] of Object.entries(this)) {
-            if (!(key in serialized)) {
-                serialized[key] = value;
-            }
-        }
-        return serialized;
+        this.occurredOn = (metadata.occurredOn === undefined
+            ? date_type_1.CreatedAt.now(metadata.clock)
+            : new date_type_1.CreatedAt(metadata.occurredOn)).value.toISOString();
     }
 }
 exports.EventBase = EventBase;

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

@@ -0,0 +1,7 @@
+export declare enum DomainExceptionCode {
+    DomainException = "DOM000",
+    ValidationFailed = "DOM001",
+    TypeFailed = "DOM003",
+    RequiredValue = "DOM004",
+    InvalidEventDefinition = "DOM005"
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainExceptionCode = void 0;
+var DomainExceptionCode;
+(function (DomainExceptionCode) {
+    DomainExceptionCode["DomainException"] = "DOM000";
+    DomainExceptionCode["ValidationFailed"] = "DOM001";
+    DomainExceptionCode["TypeFailed"] = "DOM003";
+    DomainExceptionCode["RequiredValue"] = "DOM004";
+    DomainExceptionCode["InvalidEventDefinition"] = "DOM005";
+})(DomainExceptionCode || (exports.DomainExceptionCode = DomainExceptionCode = {}));

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

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

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

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

package/dist/cjs/domain/exceptions/invalid-event-definition.exception.d.ts

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

package/dist/cjs/domain/exceptions/invalid-event-definition.exception.js

@@ -0,0 +1,19 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidEventDefinitionException = void 0;
+const index_1 = require("../../shared/index");
+const domain_exception_code_1 = require("./domain-exception-code");
+const domain_exception_1 = require("./domain.exception");
+class InvalidEventDefinitionException extends domain_exception_1.DomainException {
+    constructor(eventClassName) {
+        super(`${eventClassName} must declare a static eventName`, [
+            domain_exception_code_1.DomainExceptionCode.InvalidEventDefinition,
+        ]);
+    }
+}
+exports.InvalidEventDefinitionException = InvalidEventDefinitionException;
+_a = InvalidEventDefinitionException;
+(() => {
+    index_1.ExceptionBrand.brandClass(_a, domain_exception_code_1.DomainExceptionCode.InvalidEventDefinition);
+})();

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

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

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

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

package/dist/cjs/{exceptions/domain → domain/exceptions}/validation.exception.js

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