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

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleLogger = void 0;
-const index_1 = require("../../exceptions/index");
+const internal_error_exception_1 = require("../exceptions/internal-error.exception");
 const system_clock_1 = require("../clock/system-clock");
 const log_serializer_1 = require("./log-serializer");
 class ConsoleLogger {
@@ -9,7 +9,7 @@ class ConsoleLogger {
         this.output = console;
         this.minimum = ConsoleLogger.levels.indexOf(level);
         if (this.minimum === -1) {
-            throw new index_1.InternalErrorException(`unknown log level "${String(level)}": use ${ConsoleLogger.levels.join(', ')}`);
+            throw new internal_error_exception_1.InternalErrorException(`unknown log level "${String(level)}": use ${ConsoleLogger.levels.join(', ')}`);
         }
         this.clock = clock;
     }

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

@@ -1,17 +1,19 @@
-import { ExceptionCode } from './exception-code.js';
 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/cjs/{exceptions → shared/exceptions}/abstract.exception.js

@@ -2,21 +2,21 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractException = void 0;
-const exception_code_1 = require("./exception-code");
 const exception_brand_1 = require("./brand/exception-brand");
 class AbstractException extends Error {
     static [Symbol.hasInstance](candidate) {
         return (Function.prototype[Symbol.hasInstance].call(this, candidate) ||
             exception_brand_1.ExceptionBrand.matches(this, candidate));
     }
-    constructor(message, exceptionCodes, options = {}) {
+    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]
-                : exception_code_1.ExceptionCode.ErrorException;
+                : _a.fallbackCode;
         this.createdAt = Date.now();
         if ('cause' in options) {
             Object.defineProperty(this, 'cause', {
@@ -32,12 +32,11 @@ 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()}`;
@@ -54,13 +53,7 @@ class AbstractException extends Error {
 }
 exports.AbstractException = AbstractException;
 _a = AbstractException;
+AbstractException.fallbackCode = 'E000';
 (() => {
     exception_brand_1.ExceptionBrand.brandClass(_a, exception_brand_1.ExceptionBrand.anyCode);
 })();
-AbstractException.ExceptionCodeStrings = Object.keys(exception_code_1.ExceptionCode)
-    .filter((key) => isNaN(Number(key)))
-    .reduce((acc, key) => {
-    const value = exception_code_1.ExceptionCode[key];
-    acc[value] = key.replace(/([A-Z])/g, ' $1').trim();
-    return acc;
-}, {});

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

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

package/dist/cjs/shared/index.js

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { ApplicationException } from '../../exceptions/index.js';
+import { ApplicationException } from '../exceptions/application.exception.js';
 const LISTENED_EVENT = Symbol.for('@archi-code/ddd/listens-to.v1');
 export function ListensTo(event, options) {
     return (listener) => {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,13 +1,13 @@
 var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { ApplicationExceptionCode } from './application-exception-code.js';
 import { ApplicationException } from './application.exception.js';
-import { ExceptionBrand } from '../brand/exception-brand.js';
-import { ExceptionCode } from '../exception-code.js';
 export class ConcurrencyException extends ApplicationException {
     constructor(aggregateName, id, expectedVersion, options = {}) {
-        super(`${aggregateName} with ID ${id} was changed by someone else: expected version ${expectedVersion}.`, [ExceptionCode.ConcurrencyConflict], options);
+        super(`${aggregateName} with ID ${id} was changed by someone else: expected version ${expectedVersion}.`, [ApplicationExceptionCode.ConcurrencyConflict], options);
     }
 }
 _a = ConcurrencyException;
 (() => {
-    ExceptionBrand.brandClass(_a, ExceptionCode.ConcurrencyConflict);
+    ExceptionBrand.brandClass(_a, ApplicationExceptionCode.ConcurrencyConflict);
 })();

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

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

package/dist/esm/application/exceptions/not-allowed.exception.js

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

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

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

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

@@ -0,0 +1,13 @@
+var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { ApplicationExceptionCode } from './application-exception-code.js';
+import { ApplicationException } from './application.exception.js';
+export class UnexpectedErrorException extends ApplicationException {
+    constructor(message, options = {}) {
+        super(`Failed, unexpected error: ${message}`, [ApplicationExceptionCode.UnexpectedError], options);
+    }
+}
+_a = UnexpectedErrorException;
+(() => {
+    ExceptionBrand.brandClass(_a, ApplicationExceptionCode.UnexpectedError);
+})();

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

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

package/dist/esm/application/index.js

@@ -1,3 +1,10 @@
 export { UseCase } from './use-case/use-case.js';
+export { ValueObjectBuilder } from './value-object-builder/value-object-builder.js';
 export { EventListener } from './event/event-listener.js';
 export { ListensTo } from './event/listens-to.js';
+export { ApplicationException } from './exceptions/application.exception.js';
+export { ConcurrencyException } from './exceptions/concurrency.exception.js';
+export { AggregateNotFoundException } from './exceptions/aggregate-not-found.exception.js';
+export { NotAllowedException } from './exceptions/not-allowed.exception.js';
+export { UnexpectedErrorException } from './exceptions/unexpected-error.exception.js';
+export { ApplicationExceptionCode } from './exceptions/application-exception-code.js';

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

@@ -1,5 +1,6 @@
 import { anyToString } from '@archi-code/validation';
-import { AbstractException, InternalErrorException } from '../../exceptions/index.js';
+import { AbstractException } from '../../shared/index.js';
+import { UnexpectedErrorException } from '../exceptions/unexpected-error.exception.js';
 export class UseCase {
     async execute(input) {
         try {
@@ -9,7 +10,7 @@ export class UseCase {
             if (error instanceof AbstractException) {
                 throw error;
             }
-            throw new InternalErrorException(`${this.constructor.name}: ${UseCase.describe(error)}`, {
+            throw new UnexpectedErrorException(`${this.constructor.name}: ${UseCase.describe(error)}`, {
                 cause: error,
             });
         }

package/dist/{cjs/domain/type/value-objects/value-objects.d.ts → esm/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/esm/application/value-object-builder/value-object-builder.js

@@ -0,0 +1,47 @@
+import { DomainException, ValidationException } from '../../domain/index.js';
+import { IssueCollectionError, IssueCollector } from '../../shared/index.js';
+import { UnexpectedErrorException } from '../exceptions/unexpected-error.exception.js';
+export class ValueObjectBuilder {
+    static build(factories) {
+        const builds = Object.fromEntries(Object.entries(factories).map(([field, factory]) => [
+            field,
+            () => ValueObjectBuilder.synchronous(field, factory()),
+        ]));
+        return ValueObjectBuilder.validated(() => IssueCollector.collectFields(builds, ValueObjectBuilder.read));
+    }
+    static buildList(values, factory) {
+        return ValueObjectBuilder.validated(() => 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 UnexpectedErrorException(`ValueObjectBuilder: the factory of "${field}" returned a Promise; build value objects synchronously`);
+    }
+    static validated(collect) {
+        try {
+            return collect();
+        }
+        catch (error) {
+            if (error instanceof IssueCollectionError) {
+                throw new ValidationException(error.issues);
+            }
+            throw error;
+        }
+    }
+    static read(error) {
+        if (error instanceof ValidationException) {
+            return error.errors;
+        }
+        if (error instanceof 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');
+    }
+}

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

@@ -4,11 +4,6 @@ import type { EventBase } from '../event/event-base.js';
 import type { IdType } from '../type/id-type.js';
 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/esm/domain/aggregate/aggregate-root.js

@@ -1,29 +1,13 @@
 import { Entity } from '../entity/entity.js';
-import { Immutable } from '../type/immutable/immutable.js';
-import { InternalErrorException } from '../../exceptions/index.js';
 export class AggregateRoot extends 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.freeze(event));
+        this.domainEvents.push(event);
     }
     pullDomainEvents() {
         return this.domainEvents.splice(0);
     }
-    restoreVersion(version) {
-        if (!Number.isSafeInteger(version) || version < 0) {
-            throw new InternalErrorException(`${this.constructor.name} cannot be restored with version ${String(version)}`);
-        }
-        this.persistedVersion = version;
-        return this;
-    }
-    markPersisted() {
-        this.persistedVersion += 1;
-    }
 }

package/dist/esm/domain/entity/entity.js

@@ -1,4 +1,4 @@
-import { RequiredValueException } from '../../exceptions/index.js';
+import { RequiredValueException } from '../exceptions/required-value.exception.js';
 export class Entity {
     constructor(id) {
         this.id = id;

package/dist/esm/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/esm/domain/event/event-base.js

@@ -1,47 +1,17 @@
 import { CreatedAt } from '../type/date-type.js';
 import { IdType } from '../type/id-type.js';
 import { UuidType } from '../type/uuid-type.js';
-import { InternalErrorException, RequiredValueException } from '../../exceptions/index.js';
+import { InvalidEventDefinitionException } from '../exceptions/invalid-event-definition.exception.js';
 export 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 InternalErrorException(`${this.constructor.name} must declare a static eventName`);
+            throw new InvalidEventDefinitionException(this.constructor.name);
         }
-        if (!Number.isSafeInteger(eventVersion) || eventVersion < 1) {
-            throw new InternalErrorException(`${this.constructor.name}.eventVersion must be a whole number from 1`);
-        }
-        if (aggregateId === null ||
-            aggregateId === undefined ||
-            (typeof aggregateId === 'string' && aggregateId.trim() === '')) {
-            throw new RequiredValueException(`${this.constructor.name}.aggregateId`, aggregateId);
-        }
-        this.aggregateId = aggregateId;
+        this.eventName = eventName;
         this.eventId = new IdType(metadata.eventId ?? UuidType.random()).value;
-        this.occurredOn =
-            metadata.occurredOn === undefined
-                ? CreatedAt.now(metadata.clock).value
-                : new 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
+            ? CreatedAt.now(metadata.clock)
+            : new CreatedAt(metadata.occurredOn)).value.toISOString();
     }
 }

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

@@ -0,0 +1,8 @@
+export var DomainExceptionCode;
+(function (DomainExceptionCode) {
+    DomainExceptionCode["DomainException"] = "DOM000";
+    DomainExceptionCode["ValidationFailed"] = "DOM001";
+    DomainExceptionCode["TypeFailed"] = "DOM003";
+    DomainExceptionCode["RequiredValue"] = "DOM004";
+    DomainExceptionCode["InvalidEventDefinition"] = "DOM005";
+})(DomainExceptionCode || (DomainExceptionCode = {}));

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

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

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

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