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

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

@@ -1,10 +1,17 @@
 export * from './event/event-base';
 export * from './entity/entity';
 export * from './aggregate/aggregate-root';
-export * from './type';
+export * from './type/index';
 export * from './primitive/primitive-types';
 export type { AggregateFinder } from './repository/aggregate-finder';
 export type { AggregateSaver } from './repository/aggregate-saver';
 export type { AggregateRemover } from './repository/aggregate-remover';
 export { Specification } from './specification/specification';
 export type { SatisfiedBy } from './specification/specification';
+export { DomainException } from './exceptions/domain.exception';
+export { ValidationException } from './exceptions/validation.exception';
+export type { ValidationIssue, ValidationIssueInput } from './exceptions/validation.exception';
+export { TypePrimitiveException } from './exceptions/type-primitive.exception';
+export { RequiredValueException } from './exceptions/required-value.exception';
+export { InvalidEventDefinitionException } from './exceptions/invalid-event-definition.exception';
+export { DomainExceptionCode } from './exceptions/domain-exception-code';

package/dist/cjs/domain/index.js

@@ -14,11 +14,23 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Specification = void 0;
+exports.DomainExceptionCode = exports.InvalidEventDefinitionException = exports.RequiredValueException = exports.TypePrimitiveException = exports.ValidationException = exports.DomainException = exports.Specification = void 0;
 __exportStar(require("./event/event-base"), exports);
 __exportStar(require("./entity/entity"), exports);
 __exportStar(require("./aggregate/aggregate-root"), exports);
-__exportStar(require("./type"), exports);
+__exportStar(require("./type/index"), exports);
 __exportStar(require("./primitive/primitive-types"), exports);
 var specification_1 = require("./specification/specification");
 Object.defineProperty(exports, "Specification", { enumerable: true, get: function () { return specification_1.Specification; } });
+var domain_exception_1 = require("./exceptions/domain.exception");
+Object.defineProperty(exports, "DomainException", { enumerable: true, get: function () { return domain_exception_1.DomainException; } });
+var validation_exception_1 = require("./exceptions/validation.exception");
+Object.defineProperty(exports, "ValidationException", { enumerable: true, get: function () { return validation_exception_1.ValidationException; } });
+var type_primitive_exception_1 = require("./exceptions/type-primitive.exception");
+Object.defineProperty(exports, "TypePrimitiveException", { enumerable: true, get: function () { return type_primitive_exception_1.TypePrimitiveException; } });
+var required_value_exception_1 = require("./exceptions/required-value.exception");
+Object.defineProperty(exports, "RequiredValueException", { enumerable: true, get: function () { return required_value_exception_1.RequiredValueException; } });
+var invalid_event_definition_exception_1 = require("./exceptions/invalid-event-definition.exception");
+Object.defineProperty(exports, "InvalidEventDefinitionException", { enumerable: true, get: function () { return invalid_event_definition_exception_1.InvalidEventDefinitionException; } });
+var domain_exception_code_1 = require("./exceptions/domain-exception-code");
+Object.defineProperty(exports, "DomainExceptionCode", { enumerable: true, get: function () { return domain_exception_code_1.DomainExceptionCode; } });

package/dist/cjs/domain/primitive/primitive-types.d.ts

@@ -1,4 +1,3 @@
-import type { AggregateRoot } from '../aggregate/aggregate-root';
 import type { AbstractType } from '../type/abstract-type';
 export type Methods<T> = {
     [P in keyof T]-?: T[P] extends Function ? P : never;
@@ -13,9 +12,8 @@ type RemoveUnderscore<S extends string> = S extends `_${infer R}` ? R : S;
 type Mutable<T> = {
     -readonly [P in keyof T]: T[P];
 };
-type AggregateBookkeeping<T> = T extends AggregateRoot<any, any> ? 'version' : never;
 export type PrimitiveTypes<T> = {
-    [key in keyof Mutable<Properties<T>> as key extends AggregateBookkeeping<T> ? never : RemoveUnderscore<string & key>]: PrimitiveType<T[key]>;
+    [key in keyof Mutable<Properties<T>> as RemoveUnderscore<string & key>]: PrimitiveType<T[key]>;
 };
 export type DataTypes<T> = Partial<PrimitiveTypes<T>>;
 export type PrimitiveType<T> = T extends (infer U)[] ? PrimitiveType<U>[] : T extends AbstractType<any> ? T['value'] : T extends null ? null : T extends Date ? never : T extends object ? PrimitiveTypes<T> : never;

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

@@ -1,7 +1,7 @@
 import type { Validatable, ValidationResult } from '@archi-code/validation';
-import type { ValueOf } from './required/required-mark';
-import type { ValidationIssue } from '../../exceptions/index';
-type JsonValue<T> = T extends Date ? string : T;
+import type { RequiredMarked } from './required/required-mark';
+import type { ValidationIssue } from '../exceptions/validation.exception';
+export type ValueOf<T, I> = I extends RequiredMarked ? T : T | null;
 export declare abstract class AbstractType<T, Input = T> implements Validatable<T | null> {
     protected readonly _value: T | null;
     static [Symbol.hasInstance](candidate: unknown): boolean;
@@ -9,12 +9,10 @@ export declare abstract class AbstractType<T, Input = T> implements Validatable<
     get value(): ValueOf<T, this>;
     get isNull(): boolean;
     toString(): string;
-    toJSON(): ValueOf<JsonValue<T>, this>;
-    equals(other: unknown): boolean;
+    equals<E extends AbstractType<any>>(other: E): boolean;
+    protected hasSameValue(other: this): boolean;
     validate(): ValidationResult<ValueOf<T, this>>;
     protected brokenRules(value: unknown): ValidationIssue[];
     protected abstract filter(value: unknown): T | null;
-    private acceptInput;
-    private static isMissingInput;
+    private runRules;
 }
-export {};

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

@@ -3,9 +3,9 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractType = void 0;
 const validation_1 = require("@archi-code/validation");
-const value_equality_1 = require("./equality/value-equality");
 const required_mark_1 = require("./required/required-mark");
-const index_1 = require("../../exceptions/index");
+const required_value_exception_1 = require("../exceptions/required-value.exception");
+const validation_exception_1 = require("../exceptions/validation.exception");
 const VALUE_OBJECT = Symbol.for('@archi-code/ddd/value-object.v1');
 class AbstractType {
     static [Symbol.hasInstance](candidate) {
@@ -16,10 +16,13 @@ class AbstractType {
                 candidate[VALUE_OBJECT] === true));
     }
     constructor(value = null) {
-        this._value = this.acceptInput(value);
+        this._value = value === null || value === undefined ? null : this.filter(value);
+        if (this._value === null && required_mark_1.RequiredMark.isMarked(this)) {
+            throw new required_value_exception_1.RequiredValueException(this.constructor.name, value);
+        }
         const brokenRules = this.brokenRules(this._value);
         if (brokenRules.length > 0) {
-            throw new index_1.ValidationException(brokenRules);
+            throw new validation_exception_1.ValidationException(brokenRules);
         }
     }
     get value() {
@@ -31,35 +34,24 @@ class AbstractType {
     toString() {
         return this.isNull ? '' : (0, validation_1.anyToString)(this._value);
     }
-    toJSON() {
-        const value = this._value;
-        return (value instanceof Date ? value.toISOString() : value);
-    }
     equals(other) {
-        return (typeof other === 'object' &&
-            other !== null &&
-            other.constructor === this.constructor &&
-            value_equality_1.ValueEquality.equals(this._value, other._value));
+        return other?.constructor === this.constructor && this.hasSameValue(other);
+    }
+    hasSameValue(other) {
+        return this._value === other._value;
     }
     validate() {
-        return (0, validation_1.runValidations)(this.constructor, this._value);
+        return this.runRules(this._value);
     }
     brokenRules(value) {
-        return (0, validation_1.runValidations)(this.constructor, value).errors.map((error) => ({
+        return this.runRules(value).errors.map((error) => ({
             field: null,
             code: 'validator' in error ? error.validator : error.custom,
             message: `${this.constructor.name}: ${error.message}`,
         }));
     }
-    acceptInput(value) {
-        const accepted = _a.isMissingInput(value) ? null : this.filter(value);
-        if (accepted === null && required_mark_1.RequiredMark.isMarked(this)) {
-            throw new index_1.RequiredValueException(this.constructor.name, value);
-        }
-        return accepted;
-    }
-    static isMissingInput(value) {
-        return (value === null || value === undefined || (typeof value === 'string' && value.trim() === ''));
+    runRules(value) {
+        return (0, validation_1.runValidations)(this.constructor, value);
     }
 }
 exports.AbstractType = AbstractType;

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

@@ -1,6 +1,6 @@
 import type { ValidationResult } from '@archi-code/validation';
 import { AbstractType } from './abstract-type';
-import type { ValueOf } from './required/required-mark';
+import type { ValueOf } from './abstract-type';
 type ItemValue<Item extends AbstractType<any>> = Item['value'];
 export declare abstract class ArrayType<Item extends AbstractType<any>> extends AbstractType<ItemValue<Item>[]> {
     protected abstract createItem(value: unknown): Item;
@@ -9,6 +9,7 @@ export declare abstract class ArrayType<Item extends AbstractType<any>> extends
     hasItem(value: ItemValue<Item>): boolean;
     withItem(value: ItemValue<Item>): this;
     withoutItem(value: ItemValue<Item>): this;
+    protected hasSameValue(other: this): boolean;
     protected filter(value: unknown): ItemValue<Item>[];
     validate(): ValidationResult<ValueOf<ItemValue<Item>[], this>>;
     private copyWith;

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

@@ -3,10 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayType = void 0;
 const validation_1 = require("@archi-code/validation");
 const abstract_type_1 = require("./abstract-type");
-const immutable_1 = require("./immutable/immutable");
-const value_equality_1 = require("./equality/value-equality");
-const value_objects_1 = require("./value-objects/value-objects");
-const index_1 = require("../../exceptions/index");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
 class ArrayType extends abstract_type_1.AbstractType {
     get items() {
         return (this._value ?? []).map((value) => this.createItem(value));
@@ -15,8 +12,8 @@ class ArrayType extends abstract_type_1.AbstractType {
         return this.items.map((item) => item.toString()).join(', ');
     }
     hasItem(value) {
-        const itemValue = this.createItem(value).value;
-        return (this._value ?? []).some((current) => value_equality_1.ValueEquality.equals(current, itemValue));
+        const item = this.createItem(value);
+        return (this._value ?? []).some((current) => this.createItem(current).equals(item));
     }
     withItem(value) {
         return this.copyWith([...(this._value ?? []), value]);
@@ -25,23 +22,25 @@ class ArrayType extends abstract_type_1.AbstractType {
         if (this._value === null) {
             return this;
         }
-        const itemValue = this.createItem(value).value;
-        return this.copyWith(this._value.filter((current) => !value_equality_1.ValueEquality.equals(current, itemValue)));
+        const item = this.createItem(value);
+        return this.copyWith(this._value.filter((current) => !this.createItem(current).equals(item)));
+    }
+    hasSameValue(other) {
+        const otherValue = other._value;
+        if (this._value === null || otherValue === null) {
+            return this._value === otherValue;
+        }
+        return (this._value.length === otherValue.length &&
+            this._value.every((value, index) => this.createItem(value).equals(this.createItem(otherValue[index]))));
     }
     filter(value) {
         const converted = (0, validation_1.toArray)(value);
         if (!converted.ok) {
-            throw new index_1.TypePrimitiveException('Array', value);
-        }
-        try {
-            return immutable_1.Immutable.freeze(value_objects_1.ValueObjects.buildList(converted.value, (item) => this.createItem(item).value));
-        }
-        catch (error) {
-            if (error instanceof index_1.ValidationException) {
-                throw new index_1.ValidationException([...this.brokenRules(converted.value), ...error.errors]);
-            }
-            throw error;
+            throw new type_primitive_exception_1.TypePrimitiveException('Array', value);
         }
+        const items = converted.value.map((item) => this.createItem(item).value);
+        Object.freeze(items);
+        return items;
     }
     validate() {
         const own = super.validate();

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

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

package/dist/cjs/domain/type/composite/composite-brand.d.ts

@@ -0,0 +1,4 @@
+export declare class CompositeBrand {
+    static mark(prototype: object): void;
+    static isComposite(value: unknown): boolean;
+}

package/dist/cjs/domain/type/composite/composite-brand.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeBrand = void 0;
+const COMPOSITE = Symbol.for('@archi-code/ddd/composite.v1');
+class CompositeBrand {
+    static mark(prototype) {
+        Object.defineProperty(prototype, COMPOSITE, { value: true });
+    }
+    static isComposite(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            value[COMPOSITE] === true);
+    }
+}
+exports.CompositeBrand = CompositeBrand;

package/dist/cjs/domain/type/composite/composite-field.d.ts

@@ -8,12 +8,11 @@ export interface CompositeClass {
 }
 export type FieldClass = ValueClass | CompositeClass;
 export type FieldSpec = FieldClass | readonly [FieldClass];
-export declare class CompositeField {
-    static brand(prototype: object): void;
-    static isComposite(value: unknown): boolean;
-    static accept(owner: string, field: string, spec: FieldSpec, value: unknown): unknown;
-    static fromPrimitive(spec: FieldSpec, primitive: unknown): unknown;
-    static equals(left: unknown, right: unknown): boolean;
-    static primitive(value: unknown): unknown;
-    private static acceptOne;
+export declare abstract class CompositeField {
+    static of(spec: FieldSpec): CompositeField;
+    abstract readonly typeName: string;
+    abstract accept(path: string, value: unknown): unknown;
+    abstract fromPrimitive(primitive: unknown): unknown;
+    abstract toPrimitive(value: unknown): unknown;
+    abstract equals(left: unknown, right: unknown): boolean;
 }

package/dist/cjs/domain/type/composite/composite-field.js

@@ -1,63 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompositeField = void 0;
-const value_objects_1 = require("../value-objects/value-objects");
-const index_1 = require("../../../exceptions/index");
-const COMPOSITE = Symbol.for('@archi-code/ddd/composite.v1');
+const composite_brand_1 = require("./composite-brand");
+const composite_issues_1 = require("./composite-issues");
+const required_value_exception_1 = require("../../exceptions/required-value.exception");
+const type_primitive_exception_1 = require("../../exceptions/type-primitive.exception");
 class CompositeField {
-    static brand(prototype) {
-        Object.defineProperty(prototype, COMPOSITE, { value: true });
+    static of(spec) {
+        if (Array.isArray(spec)) {
+            return new ListField(CompositeField.of(spec[0]));
+        }
+        const fieldClass = spec;
+        return composite_brand_1.CompositeBrand.isComposite(fieldClass.prototype)
+            ? new NestedCompositeField(fieldClass)
+            : new ValueField(fieldClass);
     }
-    static isComposite(value) {
-        return (typeof value === 'object' &&
-            value !== null &&
-            value[COMPOSITE] === true);
+}
+exports.CompositeField = CompositeField;
+class SingleField extends CompositeField {
+    constructor(fieldClass) {
+        super();
+        this.fieldClass = fieldClass;
     }
-    static accept(owner, field, spec, value) {
-        if (!Array.isArray(spec)) {
-            return CompositeField.acceptOne(owner, field, spec, value);
-        }
-        if (!Array.isArray(value)) {
-            throw new index_1.TypePrimitiveException(`list for ${owner}.${field}`, value);
-        }
-        return Object.freeze(value.map((item, index) => CompositeField.acceptOne(owner, `${field}.${index}`, spec[0], item)));
+    get typeName() {
+        return this.fieldClass.name;
     }
-    static fromPrimitive(spec, primitive) {
-        if (Array.isArray(spec)) {
-            if (!Array.isArray(primitive)) {
-                throw new index_1.TypePrimitiveException('Array', primitive);
-            }
-            return value_objects_1.ValueObjects.buildList(primitive, (item) => CompositeField.fromPrimitive(spec[0], item));
+    accept(path, value) {
+        if (value === null || value === undefined) {
+            throw new required_value_exception_1.RequiredValueException(path, value);
         }
-        const fieldClass = spec;
-        return CompositeField.isComposite(fieldClass.prototype)
-            ? fieldClass.fromPrimitives(primitive)
-            : new fieldClass(primitive);
-    }
-    static equals(left, right) {
-        if (Array.isArray(left)) {
-            return (Array.isArray(right) &&
-                left.length === right.length &&
-                left.every((item, index) => CompositeField.equals(item, right[index])));
+        if (!(value instanceof this.fieldClass)) {
+            throw new type_primitive_exception_1.TypePrimitiveException(`${this.typeName} for ${path}`, value);
         }
+        return value;
+    }
+    equals(left, right) {
         return left.equals(right);
     }
-    static primitive(value) {
-        if (Array.isArray(value)) {
-            return value.map((item) => CompositeField.primitive(item));
-        }
-        return CompositeField.isComposite(value)
-            ? value.toPrimitives()
-            : value.value;
+}
+class ValueField extends SingleField {
+    fromPrimitive(primitive) {
+        return new this.fieldClass(primitive);
     }
-    static acceptOne(owner, field, fieldClass, value) {
-        if (value === null || value === undefined) {
-            throw new index_1.RequiredValueException(`${owner}.${field}`, value);
+    toPrimitive(value) {
+        return value.value;
+    }
+}
+class NestedCompositeField extends SingleField {
+    fromPrimitive(primitive) {
+        return this.fieldClass.fromPrimitives(primitive);
+    }
+    toPrimitive(value) {
+        return value.toPrimitives();
+    }
+}
+class ListField extends CompositeField {
+    constructor(item) {
+        super();
+        this.item = item;
+    }
+    get typeName() {
+        return `list of ${this.item.typeName}`;
+    }
+    accept(path, value) {
+        if (!Array.isArray(value)) {
+            throw new type_primitive_exception_1.TypePrimitiveException(`${this.typeName} for ${path}`, value);
         }
-        if (!(value instanceof fieldClass)) {
-            throw new index_1.TypePrimitiveException(`${fieldClass.name} for ${owner}.${field}`, value);
+        return Object.freeze(value.map((item, index) => this.item.accept(`${path}.${index}`, item)));
+    }
+    fromPrimitive(primitive) {
+        if (!Array.isArray(primitive)) {
+            throw new type_primitive_exception_1.TypePrimitiveException(this.typeName, primitive);
         }
-        return value;
+        return composite_issues_1.CompositeIssues.collectItems(primitive, (item) => this.item.fromPrimitive(item));
+    }
+    toPrimitive(value) {
+        return value.map((item) => this.item.toPrimitive(item));
+    }
+    equals(left, right) {
+        const items = left;
+        return (Array.isArray(right) &&
+            items.length === right.length &&
+            items.every((item, index) => this.item.equals(item, right[index])));
     }
 }
-exports.CompositeField = CompositeField;

package/dist/cjs/domain/type/composite/composite-issues.d.ts

@@ -0,0 +1,6 @@
+export declare class CompositeIssues {
+    static collectFields(builds: Readonly<Record<string, () => unknown>>): Record<string, unknown>;
+    static collectItems<Item, Built>(items: readonly Item[], build: (item: Item, index: number) => Built): Built[];
+    private static validated;
+    private static read;
+}

package/dist/cjs/domain/type/composite/composite-issues.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeIssues = void 0;
+const index_1 = require("../../../shared/index");
+const domain_exception_1 = require("../../exceptions/domain.exception");
+const validation_exception_1 = require("../../exceptions/validation.exception");
+class CompositeIssues {
+    static collectFields(builds) {
+        return CompositeIssues.validated(() => index_1.IssueCollector.collectFields(builds, CompositeIssues.read));
+    }
+    static collectItems(items, build) {
+        return CompositeIssues.validated(() => index_1.IssueCollector.collectItems(items, build, CompositeIssues.read));
+    }
+    static validated(collect) {
+        try {
+            return collect();
+        }
+        catch (error) {
+            if (error instanceof index_1.IssueCollectionError) {
+                throw new validation_exception_1.ValidationException(error.issues);
+            }
+            throw error;
+        }
+    }
+    static read(error) {
+        if (error instanceof validation_exception_1.ValidationException) {
+            return error.errors;
+        }
+        if (error instanceof domain_exception_1.DomainException) {
+            return [{ field: null, code: error.code, message: error.message }];
+        }
+        return null;
+    }
+}
+exports.CompositeIssues = CompositeIssues;

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

@@ -2,34 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Composite = Composite;
 const validation_1 = require("@archi-code/validation");
+const composite_brand_1 = require("./composite-brand");
 const composite_field_1 = require("./composite-field");
-const value_objects_1 = require("../value-objects/value-objects");
-const index_1 = require("../../../exceptions/index");
+const composite_issues_1 = require("./composite-issues");
+const type_primitive_exception_1 = require("../../exceptions/type-primitive.exception");
+const validation_exception_1 = require("../../exceptions/validation.exception");
 function Composite(schema) {
-    const fields = Object.keys(schema);
+    const fields = Object.entries(schema).map(([name, spec]) => [name, composite_field_1.CompositeField.of(spec)]);
     class CompositeValueObject {
         static fromPrimitives(primitives) {
             if (typeof primitives !== 'object' || primitives === null || Array.isArray(primitives)) {
-                throw new index_1.TypePrimitiveException(this.name, primitives);
+                throw new type_primitive_exception_1.TypePrimitiveException(this.name, primitives);
             }
             const record = primitives;
-            const props = value_objects_1.ValueObjects.build(Object.fromEntries(fields.map((field) => [
-                field,
-                () => composite_field_1.CompositeField.fromPrimitive(schema[field], record[field]),
-            ])));
-            return new this(props);
+            const builds = Object.fromEntries(fields.map(([name, field]) => [name, () => field.fromPrimitive(record[name])]));
+            return new this(composite_issues_1.CompositeIssues.collectFields(builds));
         }
         constructor(props) {
             const owner = this.constructor.name;
-            for (const field of fields) {
-                Object.defineProperty(this, field, {
-                    value: composite_field_1.CompositeField.accept(owner, field, schema[field], props?.[field]),
+            for (const [name, field] of fields) {
+                Object.defineProperty(this, name, {
+                    value: field.accept(`${owner}.${name}`, props?.[name]),
                     enumerable: true,
                 });
             }
             const brokenRules = (0, validation_1.runValidations)(this.constructor, this).errors;
             if (brokenRules.length > 0) {
-                throw new index_1.ValidationException(brokenRules.map((error) => ({
+                throw new validation_exception_1.ValidationException(brokenRules.map((error) => ({
                     field: null,
                     code: 'custom' in error ? error.custom : error.validator,
                     message: `${owner}: ${error.message}`,
@@ -41,15 +40,12 @@ function Composite(schema) {
             return (typeof other === 'object' &&
                 other !== null &&
                 other.constructor === this.constructor &&
-                fields.every((field) => composite_field_1.CompositeField.equals(this[field], other[field])));
+                fields.every(([name, field]) => field.equals(this[name], other[name])));
         }
         toPrimitives() {
-            return Object.fromEntries(fields.map((field) => [
-                field,
-                composite_field_1.CompositeField.primitive(this[field]),
-            ]));
+            return Object.fromEntries(fields.map(([name, field]) => [name, field.toPrimitive(this[name])]));
         }
     }
-    composite_field_1.CompositeField.brand(CompositeValueObject.prototype);
+    composite_brand_1.CompositeBrand.mark(CompositeValueObject.prototype);
     return CompositeValueObject;
 }

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

@@ -2,14 +2,15 @@ import { AbstractType } from './abstract-type';
 export declare class DateType extends AbstractType<Date, Date | string> {
     protected filter(value: unknown): Date;
     toString(): string;
+    protected hasSameValue(other: this): boolean;
 }
-declare const CreatedAt_base: import("./required/required").RequiredType<typeof DateType>;
+declare const CreatedAt_base: import("./required/required-type").RequiredType<typeof DateType>;
 export declare class CreatedAt extends CreatedAt_base {
     static now(clock?: {
         now(): Date;
     }): CreatedAt;
 }
-declare const UpdatedAt_base: import("./required/required").RequiredType<typeof DateType>;
+declare const UpdatedAt_base: import("./required/required-type").RequiredType<typeof DateType>;
 export declare class UpdatedAt extends UpdatedAt_base {
     static now(clock?: {
         now(): Date;

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

@@ -3,31 +3,66 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdatedAt = exports.CreatedAt = exports.DateType = void 0;
 const validation_1 = require("@archi-code/validation");
 const abstract_type_1 = require("./abstract-type");
-const immutable_1 = require("./immutable/immutable");
-const required_1 = require("./required/required");
-const index_1 = require("../../exceptions/index");
+const required_type_1 = require("./required/required-type");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
+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`);
+            },
+        });
+    }
+})();
 const TIME_WITHOUT_ZONE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
 class DateType extends abstract_type_1.AbstractType {
     filter(value) {
         const converted = (0, validation_1.toDate)(value, { iso: true });
         if (!converted.ok || (typeof value === 'string' && TIME_WITHOUT_ZONE.test(value))) {
-            throw new index_1.TypePrimitiveException('Date', value);
+            throw new type_primitive_exception_1.TypePrimitiveException('Date', value);
         }
-        return immutable_1.Immutable.date(converted.value);
+        return new ImmutableDate(converted.value);
     }
     toString() {
         return this._value === null ? '' : this._value.toISOString();
     }
+    hasSameValue(other) {
+        return this._value?.getTime() === other._value?.getTime();
+    }
 }
 exports.DateType = DateType;
 const SYSTEM_TIME = { now: () => new Date() };
-class CreatedAt extends (0, required_1.Required)(DateType) {
+class CreatedAt extends (0, required_type_1.Required)(DateType) {
     static now(clock = SYSTEM_TIME) {
         return new CreatedAt(clock.now());
     }
 }
 exports.CreatedAt = CreatedAt;
-class UpdatedAt extends (0, required_1.Required)(DateType) {
+class UpdatedAt extends (0, required_type_1.Required)(DateType) {
     static now(clock = SYSTEM_TIME) {
         return new UpdatedAt(clock.now());
     }