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

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

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

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

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

@@ -0,0 +1,13 @@
+import { Required } from './required/required.js';
+import { UuidType } from './uuid-type.js';
+import { TypePrimitiveException } from '../../exceptions/index.js';
+const NIL_OR_MAX_UUID = /^(?:0{8}-0{4}-0{4}-0{4}-0{12}|f{8}-f{4}-f{4}-f{4}-f{12})$/i;
+export class IdType extends Required(UuidType) {
+    filter(value) {
+        const id = super.filter(value);
+        if (NIL_OR_MAX_UUID.test(id)) {
+            throw new TypePrimitiveException('Id', value);
+        }
+        return id;
+    }
+}

package/dist/esm/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/esm/domain/type/immutable/immutable-date.js

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

package/dist/esm/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/esm/domain/type/immutable/immutable.js

@@ -0,0 +1,15 @@
+import { ImmutableDate } from './immutable-date.js';
+export 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 ImmutableDate(date);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { AbstractType } from './abstract-type.js';
+export type JsonTypeValue = Record<string, any>;
+export declare class JsonType<T extends JsonTypeValue = JsonTypeValue> extends AbstractType<T> {
+    protected filter(value: unknown): T;
+}

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

@@ -0,0 +1,13 @@
+import { toJson } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { Immutable } from './immutable/immutable.js';
+import { TypePrimitiveException } from '../../exceptions/index.js';
+export class JsonType extends AbstractType {
+    filter(value) {
+        const converted = toJson(value);
+        if (!converted.ok) {
+            throw new TypePrimitiveException('Json', value);
+        }
+        return Immutable.freeze(JSON.parse(JSON.stringify(converted.value)));
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+import { toFloat } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { TypePrimitiveException } from '../../exceptions/index.js';
+export class NumberType extends AbstractType {
+    filter(value) {
+        const converted = toFloat(value);
+        if (!converted.ok) {
+            throw new TypePrimitiveException('Number', value);
+        }
+        return converted.value;
+    }
+}

package/dist/esm/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/esm/domain/type/required/required-mark.js

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

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

@@ -0,0 +1,7 @@
+import type { AbstractType } from '../abstract-type.js';
+import type { RequiredMarked } from './required-mark.js';
+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/esm/domain/type/required/required.js

@@ -0,0 +1,18 @@
+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;
+};
+import { Validations } from '@archi-code/validation';
+import { RequiredMark } from './required-mark.js';
+export function Required(Base) {
+    let RequiredValue = class RequiredValue extends Base {
+    };
+    RequiredValue = __decorate([
+        Validations([{ validator: 'isRequired' }])
+    ], RequiredValue);
+    Object.defineProperty(RequiredValue, 'name', { value: `Required(${Base.name})` });
+    RequiredMark.mark(RequiredValue.prototype);
+    return RequiredValue;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { toString as convertToString } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { TypePrimitiveException } from '../../exceptions/index.js';
+export class StringType extends AbstractType {
+    filter(value) {
+        const converted = convertToString(value);
+        if (!converted.ok) {
+            throw new TypePrimitiveException('String', value);
+        }
+        return converted.value;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { AbstractType } from './abstract-type.js';
+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/esm/domain/type/uuid-type.js

@@ -0,0 +1,23 @@
+import { v4 as uuidv4, v5 as uuidv5 } from 'uuid';
+import { isUUID, toString as convertToString } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { TypePrimitiveException } from '../../exceptions/index.js';
+const DNS_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+export class UuidType extends AbstractType {
+    static random() {
+        return uuidv4();
+    }
+    static generate() {
+        return new this(uuidv4());
+    }
+    static fromValue(value, namespace = DNS_NAMESPACE) {
+        return uuidv5(value, namespace);
+    }
+    filter(value) {
+        const converted = convertToString(value);
+        if (!converted.ok || !isUUID(converted.value)) {
+            throw new TypePrimitiveException('UUID', value);
+        }
+        return converted.value.toLowerCase();
+    }
+}

package/dist/esm/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/esm/domain/type/value-objects/value-objects.js

@@ -0,0 +1,66 @@
+import { DomainException, InternalErrorException, ValidationException, } from '../../../exceptions/index.js';
+export 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 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 ValidationException) {
+            return error.errors.map((issue) => ({
+                field: issue.field === null ? field : `${field}.${issue.field}`,
+                code: issue.code,
+                message: issue.message,
+            }));
+        }
+        if (error instanceof DomainException) {
+            return [{ field, code: error.code, message: error.message }];
+        }
+        throw error;
+    }
+    static assertNoIssues(issues) {
+        if (issues.length > 0) {
+            throw new ValidationException(issues);
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+import { ExceptionCode } from './exception-code.js';
+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/esm/exceptions/abstract.exception.js

@@ -0,0 +1,62 @@
+var _a;
+import { ExceptionCode } from './exception-code.js';
+import { ExceptionBrand } from './brand/exception-brand.js';
+export class AbstractException extends Error {
+    static [Symbol.hasInstance](candidate) {
+        return (Function.prototype[Symbol.hasInstance].call(this, candidate) ||
+            ExceptionBrand.matches(this, candidate));
+    }
+    constructor(message, exceptionCodes, options = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.exceptionCodes = exceptionCodes;
+        this.code =
+            exceptionCodes.length > 0
+                ? exceptionCodes[exceptionCodes.length - 1]
+                : ExceptionCode.ErrorException;
+        this.createdAt = Date.now();
+        if ('cause' in options) {
+            Object.defineProperty(this, 'cause', {
+                value: options.cause,
+                writable: true,
+                configurable: true,
+            });
+        }
+        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(),
+        };
+    }
+}
+_a = AbstractException;
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionBrand.anyCode);
+})();
+AbstractException.ExceptionCodeStrings = Object.keys(ExceptionCode)
+    .filter((key) => isNaN(Number(key)))
+    .reduce((acc, key) => {
+    const value = ExceptionCode[key];
+    acc[value] = key.replace(/([A-Z])/g, ' $1').trim();
+    return acc;
+}, {});

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+var _a;
+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);
+    }
+}
+_a = ConcurrencyException;
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionCode.ConcurrencyConflict);
+})();

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

@@ -0,0 +1,5 @@
+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/exceptions/application/not-allowed.exception.js

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

package/dist/esm/exceptions/brand/exception-brand.d.ts

@@ -0,0 +1,6 @@
+export declare class ExceptionBrand {
+    static readonly anyCode = "*";
+    static brandClass(exceptionClass: object, code: string): void;
+    static brandInstance(exception: object, codes: readonly string[]): void;
+    static matches(exceptionClass: object, candidate: unknown): boolean;
+}

package/dist/esm/exceptions/brand/exception-brand.js

@@ -0,0 +1,25 @@
+const INSTANCE_CODES = Symbol.for('@archi-code/ddd/exception-codes.v1');
+const CLASS_CODE = Symbol.for('@archi-code/ddd/exception-class-code.v1');
+export class ExceptionBrand {
+    static brandClass(exceptionClass, code) {
+        Object.defineProperty(exceptionClass, CLASS_CODE, { value: code });
+    }
+    static brandInstance(exception, codes) {
+        Object.defineProperty(exception, INSTANCE_CODES, { value: Object.freeze([...codes]) });
+    }
+    static matches(exceptionClass, candidate) {
+        if (!Object.prototype.hasOwnProperty.call(exceptionClass, CLASS_CODE)) {
+            return false;
+        }
+        if (typeof candidate !== 'object' || candidate === null) {
+            return false;
+        }
+        const codes = candidate[INSTANCE_CODES];
+        if (!Array.isArray(codes)) {
+            return false;
+        }
+        const code = exceptionClass[CLASS_CODE];
+        return code === ExceptionBrand.anyCode || codes.includes(code);
+    }
+}
+ExceptionBrand.anyCode = '*';

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

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

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

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

package/dist/esm/exceptions/domain/required-value.exception.d.ts

@@ -0,0 +1,4 @@
+import { DomainException } from './domain.exception.js';
+export declare class RequiredValueException extends DomainException {
+    constructor(typeName: string, receivedValue: unknown);
+}

package/dist/esm/exceptions/domain/required-value.exception.js

@@ -0,0 +1,17 @@
+var _a;
+import { DomainException } from './domain.exception.js';
+import { ExceptionBrand } from '../brand/exception-brand.js';
+import { ExceptionCode } from '../exception-code.js';
+import { ReceivedValue } from '../received/received-value.js';
+export class RequiredValueException extends DomainException {
+    constructor(typeName, receivedValue) {
+        const received = ReceivedValue.describe(receivedValue);
+        super(`Validation Error: ${typeName} is required, but received ${received}.`, [
+            ExceptionCode.RequiredValue,
+        ]);
+    }
+}
+_a = RequiredValueException;
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionCode.RequiredValue);
+})();

package/dist/esm/exceptions/domain/type-primitive.exception.d.ts

@@ -0,0 +1,4 @@
+import { DomainException } from './domain.exception.js';
+export declare class TypePrimitiveException extends DomainException {
+    constructor(expectedType: string, receivedValue: unknown, template?: string);
+}