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

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumType = void 0;
+const abstract_type_1 = require("./abstract-type");
+const index_1 = require("../../exceptions/index");
+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, '');
+        }
+        return option;
+    }
+    static matches(option, value) {
+        return (option === value ||
+            (typeof option === 'number' &&
+                typeof value === 'string' &&
+                NUMERIC_TEXT.test(value) &&
+                Number(value) === option));
+    }
+    options() {
+        const enumObject = this.getEnum();
+        return Object.entries(enumObject)
+            .filter(([, option]) => typeof enumObject[option] !== 'number')
+            .map(([, option]) => option);
+    }
+}
+exports.EnumType = EnumType;

package/dist/cjs/domain/type/equality/value-equality.d.ts

@@ -0,0 +1,7 @@
+export declare class ValueEquality {
+    static equals(left: unknown, right: unknown): boolean;
+    private static sameInstant;
+    private static sameItems;
+    private static sameEntries;
+    private static isRecord;
+}

package/dist/cjs/domain/type/equality/value-equality.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueEquality = void 0;
+class ValueEquality {
+    static equals(left, right) {
+        if (left === right || (Number.isNaN(left) && Number.isNaN(right))) {
+            return true;
+        }
+        if (left instanceof Date || right instanceof Date) {
+            return ValueEquality.sameInstant(left, right);
+        }
+        if (Array.isArray(left) || Array.isArray(right)) {
+            return ValueEquality.sameItems(left, right);
+        }
+        if (ValueEquality.isRecord(left) && ValueEquality.isRecord(right)) {
+            return ValueEquality.sameEntries(left, right);
+        }
+        return false;
+    }
+    static sameInstant(left, right) {
+        return (left instanceof Date &&
+            right instanceof Date &&
+            ValueEquality.equals(left.getTime(), right.getTime()));
+    }
+    static sameItems(left, right) {
+        return (Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((item, index) => ValueEquality.equals(item, right[index])));
+    }
+    static sameEntries(left, right) {
+        const keys = Object.keys(left);
+        return (keys.length === Object.keys(right).length &&
+            keys.every((key) => Object.prototype.hasOwnProperty.call(right, key) &&
+                ValueEquality.equals(left[key], right[key])));
+    }
+    static isRecord(value) {
+        return typeof value === 'object' && value !== null;
+    }
+}
+exports.ValueEquality = ValueEquality;

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

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

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

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

package/dist/cjs/domain/type/immutable/immutable-date.d.ts

@@ -0,0 +1,4 @@
+export declare class ImmutableDate extends Date {
+    private static readonly setters;
+    constructor(date: Date);
+}

package/dist/cjs/domain/type/immutable/immutable-date.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImmutableDate = void 0;
+class ImmutableDate extends Date {
+    constructor(date) {
+        super(date.getTime());
+        Object.freeze(this);
+    }
+}
+exports.ImmutableDate = ImmutableDate;
+ImmutableDate.setters = [
+    'setDate',
+    'setFullYear',
+    'setHours',
+    'setMilliseconds',
+    'setMinutes',
+    'setMonth',
+    'setSeconds',
+    'setTime',
+    'setUTCDate',
+    'setUTCFullYear',
+    'setUTCHours',
+    'setUTCMilliseconds',
+    'setUTCMinutes',
+    'setUTCMonth',
+    'setUTCSeconds',
+    'setYear',
+];
+(() => {
+    for (const setter of ImmutableDate.setters) {
+        Object.defineProperty(ImmutableDate.prototype, setter, {
+            value() {
+                throw new TypeError(`Cannot call ${setter}: the date is immutable`);
+            },
+        });
+    }
+})();

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

@@ -0,0 +1,4 @@
+export declare class Immutable {
+    static freeze<T>(value: T): T;
+    static date(date: Date): Date;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Immutable = void 0;
+const immutable_date_1 = require("./immutable-date");
+class Immutable {
+    static freeze(value) {
+        if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+            Object.freeze(value);
+            for (const child of Object.values(value)) {
+                Immutable.freeze(child);
+            }
+        }
+        return value;
+    }
+    static date(date) {
+        return new immutable_date_1.ImmutableDate(date);
+    }
+}
+exports.Immutable = Immutable;

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

@@ -0,0 +1,17 @@
+export { AbstractType } from './abstract-type';
+export { Required } from './required/required';
+export type { RequiredType } from './required/required';
+export { ArrayType } from './array-type';
+export { BooleanType } from './boolean-type';
+export { CreatedAt, DateType, UpdatedAt } from './date-type';
+export { EnumType } from './enum-type';
+export { JsonType } from './json-type';
+export type { JsonTypeValue } from './json-type';
+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

@@ -0,0 +1,33 @@
+"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;
+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 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");
+Object.defineProperty(exports, "BooleanType", { enumerable: true, get: function () { return boolean_type_1.BooleanType; } });
+var date_type_1 = require("./date-type");
+Object.defineProperty(exports, "CreatedAt", { enumerable: true, get: function () { return date_type_1.CreatedAt; } });
+Object.defineProperty(exports, "DateType", { enumerable: true, get: function () { return date_type_1.DateType; } });
+Object.defineProperty(exports, "UpdatedAt", { enumerable: true, get: function () { return date_type_1.UpdatedAt; } });
+var enum_type_1 = require("./enum-type");
+Object.defineProperty(exports, "EnumType", { enumerable: true, get: function () { return enum_type_1.EnumType; } });
+var json_type_1 = require("./json-type");
+Object.defineProperty(exports, "JsonType", { enumerable: true, get: function () { return json_type_1.JsonType; } });
+var number_type_1 = require("./number-type");
+Object.defineProperty(exports, "NumberType", { enumerable: true, get: function () { return number_type_1.NumberType; } });
+var string_type_1 = require("./string-type");
+Object.defineProperty(exports, "StringType", { enumerable: true, get: function () { return string_type_1.StringType; } });
+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

@@ -0,0 +1,5 @@
+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;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+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");
+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);
+        }
+        return immutable_1.Immutable.freeze(JSON.parse(JSON.stringify(converted.value)));
+    }
+}
+exports.JsonType = JsonType;

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

@@ -0,0 +1,4 @@
+import { AbstractType } from './abstract-type';
+export declare class NumberType extends AbstractType<number> {
+    protected filter(value: unknown): number;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+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");
+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);
+        }
+        return converted.value;
+    }
+}
+exports.NumberType = NumberType;

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

@@ -0,0 +1,9 @@
+export declare class RequiredMark {
+    static readonly symbol: unique symbol;
+    static isMarked(instance: object): boolean;
+    static mark(prototype: object): void;
+}
+export interface RequiredMarked {
+    readonly [RequiredMark.symbol]: true;
+}
+export type ValueOf<T, I> = I extends RequiredMarked ? T : T | null;

package/dist/cjs/domain/type/required/required-mark.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredMark = void 0;
+class RequiredMark {
+    static isMarked(instance) {
+        return instance[RequiredMark.symbol] === true;
+    }
+    static mark(prototype) {
+        Object.defineProperty(prototype, RequiredMark.symbol, { value: true });
+    }
+}
+exports.RequiredMark = RequiredMark;
+RequiredMark.symbol = Symbol.for('@archi-code/ddd/required.v1');

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

@@ -0,0 +1,7 @@
+import type { AbstractType } from '../abstract-type';
+import type { RequiredMarked } from './required-mark';
+type TypeClass = abstract new (value?: any) => AbstractType<any>;
+type RequiredValueOf<C extends TypeClass> = Exclude<ConstructorParameters<C>[0], null | undefined>;
+export type RequiredType<C extends TypeClass> = Omit<C, 'prototype'> & (abstract new (value: RequiredValueOf<C>) => InstanceType<C> & RequiredMarked);
+export declare function Required<C extends TypeClass>(Base: C): RequiredType<C>;
+export {};

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

@@ -0,0 +1,21 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Required = Required;
+const validation_1 = require("@archi-code/validation");
+const required_mark_1 = require("./required-mark");
+function Required(Base) {
+    let RequiredValue = class RequiredValue extends Base {
+    };
+    RequiredValue = __decorate([
+        (0, validation_1.Validations)([{ validator: 'isRequired' }])
+    ], RequiredValue);
+    Object.defineProperty(RequiredValue, 'name', { value: `Required(${Base.name})` });
+    required_mark_1.RequiredMark.mark(RequiredValue.prototype);
+    return RequiredValue;
+}

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

@@ -0,0 +1,4 @@
+import { AbstractType } from './abstract-type';
+export declare class StringType extends AbstractType<string> {
+    protected filter(value: unknown): string;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+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");
+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);
+        }
+        return converted.value;
+    }
+}
+exports.StringType = StringType;

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

@@ -0,0 +1,7 @@
+import { AbstractType } from './abstract-type';
+export declare class UuidType extends AbstractType<string> {
+    static random(): string;
+    static generate<T extends AbstractType<string>>(this: new (value: string) => T): T;
+    static fromValue(value: string, namespace?: string): string;
+    protected filter(value: unknown): string;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 DNS_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+class UuidType extends abstract_type_1.AbstractType {
+    static random() {
+        return (0, uuid_1.v4)();
+    }
+    static generate() {
+        return new this((0, uuid_1.v4)());
+    }
+    static fromValue(value, namespace = DNS_NAMESPACE) {
+        return (0, uuid_1.v5)(value, namespace);
+    }
+    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);
+        }
+        return converted.value.toLowerCase();
+    }
+}
+exports.UuidType = UuidType;

package/dist/cjs/domain/type/value-objects/value-objects.d.ts

@@ -0,0 +1,16 @@
+type Factories = Record<string, () => unknown>;
+type Built<F extends Factories> = {
+    [Field in keyof F]: ReturnType<F[Field]>;
+};
+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 {
+    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 isThenable;
+    private static issuesOf;
+    private static assertNoIssues;
+}
+export {};

package/dist/cjs/domain/type/value-objects/value-objects.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObjects = void 0;
+const index_1 = require("../../../exceptions/index");
+class ValueObjects {
+    static build(factories) {
+        const built = {};
+        const issues = [];
+        for (const [field, factory] of Object.entries(factories)) {
+            try {
+                Object.defineProperty(built, field, {
+                    value: ValueObjects.synchronous(field, factory()),
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+            catch (error) {
+                issues.push(...ValueObjects.issuesOf(field, error));
+            }
+        }
+        ValueObjects.assertNoIssues(issues);
+        return built;
+    }
+    static buildList(values, factory) {
+        const built = [];
+        const issues = [];
+        values.forEach((value, index) => {
+            try {
+                built.push(ValueObjects.synchronous(String(index), factory(value, index)));
+            }
+            catch (error) {
+                issues.push(...ValueObjects.issuesOf(String(index), error));
+            }
+        });
+        ValueObjects.assertNoIssues(issues);
+        return built;
+    }
+    static synchronous(field, result) {
+        if (!ValueObjects.isThenable(result)) {
+            return result;
+        }
+        result.then(undefined, () => undefined);
+        throw new index_1.InternalErrorException(`ValueObjects: the factory of "${field}" returned a Promise; build value objects synchronously`);
+    }
+    static isThenable(result) {
+        return ((typeof result === 'object' || typeof result === 'function') &&
+            result !== null &&
+            typeof result.then === 'function');
+    }
+    static issuesOf(field, error) {
+        if (error instanceof index_1.ValidationException) {
+            return error.errors.map((issue) => ({
+                field: issue.field === null ? field : `${field}.${issue.field}`,
+                code: issue.code,
+                message: issue.message,
+            }));
+        }
+        if (error instanceof index_1.DomainException) {
+            return [{ field, code: error.code, message: error.message }];
+        }
+        throw error;
+    }
+    static assertNoIssues(issues) {
+        if (issues.length > 0) {
+            throw new index_1.ValidationException(issues);
+        }
+    }
+}
+exports.ValueObjects = ValueObjects;

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

@@ -0,0 +1,23 @@
+import { ExceptionCode } from './exception-code';
+export interface ExceptionOptions {
+    cause?: unknown;
+}
+export declare abstract class AbstractException extends Error {
+    readonly cause?: unknown;
+    private readonly exceptionCodes;
+    readonly code: ExceptionCode | string;
+    private readonly createdAt;
+    static [Symbol.hasInstance](candidate: unknown): boolean;
+    constructor(message: string, exceptionCodes: (ExceptionCode | string)[], options?: ExceptionOptions);
+    static readonly ExceptionCodeStrings: Record<ExceptionCode, string>;
+    get timestamp(): Date;
+    get description(): string;
+    print(): string;
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        description: string;
+        timestamp: string;
+    };
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+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 = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.exceptionCodes = exceptionCodes;
+        this.code =
+            exceptionCodes.length > 0
+                ? exceptionCodes[exceptionCodes.length - 1]
+                : exception_code_1.ExceptionCode.ErrorException;
+        this.createdAt = Date.now();
+        if ('cause' in options) {
+            Object.defineProperty(this, 'cause', {
+                value: options.cause,
+                writable: true,
+                configurable: true,
+            });
+        }
+        exception_brand_1.ExceptionBrand.brandInstance(this, exceptionCodes);
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+    get timestamp() {
+        return new Date(this.createdAt);
+    }
+    get description() {
+        return this.exceptionCodes
+            .map((code) => {
+            const codeString = _a.ExceptionCodeStrings[code] ?? this.name;
+            return `${codeString} (${code})`;
+        })
+            .join(', ');
+    }
+    print() {
+        return `[${this.description}]: ${this.message}, ${this.timestamp.toISOString()}`;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            description: this.description,
+            timestamp: this.timestamp.toISOString(),
+        };
+    }
+}
+exports.AbstractException = AbstractException;
+_a = AbstractException;
+(() => {
+    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/exceptions/application/aggregate-not-found.exception.d.ts

@@ -0,0 +1,5 @@
+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/aggregate-not-found.exception.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateNotFoundException = void 0;
+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);
+    }
+}
+exports.AggregateNotFoundException = AggregateNotFoundException;
+_a = AggregateNotFoundException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.AggregateNotFound);
+})();

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationException = void 0;
+const abstract_exception_1 = require("../abstract.exception");
+const exception_brand_1 = require("../brand/exception-brand");
+const exception_code_1 = require("../exception-code");
+class ApplicationException extends abstract_exception_1.AbstractException {
+    constructor(message, exceptionCodes = [], options = {}) {
+        super(message, [exception_code_1.ExceptionCode.ApplicationException, ...exceptionCodes], options);
+    }
+}
+exports.ApplicationException = ApplicationException;
+_a = ApplicationException;
+(() => {
+    exception_brand_1.ExceptionBrand.brandClass(_a, exception_code_1.ExceptionCode.ApplicationException);
+})();

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

@@ -0,0 +1,5 @@
+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);
+}