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

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

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

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

@@ -0,0 +1,15 @@
+var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { DomainExceptionCode } from './domain-exception-code.js';
+import { DomainException } from './domain.exception.js';
+export class InvalidEventDefinitionException extends DomainException {
+    constructor(eventClassName) {
+        super(`${eventClassName} must declare a static eventName`, [
+            DomainExceptionCode.InvalidEventDefinition,
+        ]);
+    }
+}
+_a = InvalidEventDefinitionException;
+(() => {
+    ExceptionBrand.brandClass(_a, DomainExceptionCode.InvalidEventDefinition);
+})();

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

@@ -1,17 +1,16 @@
 var _a;
+import { ExceptionBrand, ReceivedValue } from '../../shared/index.js';
+import { DomainExceptionCode } from './domain-exception-code.js';
 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,
+            DomainExceptionCode.RequiredValue,
         ]);
     }
 }
 _a = RequiredValueException;
 (() => {
-    ExceptionBrand.brandClass(_a, ExceptionCode.RequiredValue);
+    ExceptionBrand.brandClass(_a, DomainExceptionCode.RequiredValue);
 })();

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

@@ -1,17 +1,16 @@
 var _a;
+import { ExceptionBrand, ReceivedValue } from '../../shared/index.js';
+import { DomainExceptionCode } from './domain-exception-code.js';
 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 TypePrimitiveException extends DomainException {
     constructor(expectedType, receivedValue, template = 'Expected a valid ') {
         const received = ReceivedValue.describe(receivedValue);
         super(`Validation Error: ${template}${expectedType}, but received ${received}.`, [
-            ExceptionCode.TypeFailed,
+            DomainExceptionCode.TypeFailed,
         ]);
     }
 }
 _a = TypePrimitiveException;
 (() => {
-    ExceptionBrand.brandClass(_a, ExceptionCode.TypeFailed);
+    ExceptionBrand.brandClass(_a, DomainExceptionCode.TypeFailed);
 })();

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

@@ -1,13 +1,13 @@
 var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { DomainExceptionCode } from './domain-exception-code.js';
 import { DomainException } from './domain.exception.js';
-import { ExceptionBrand } from '../brand/exception-brand.js';
-import { ExceptionCode } from '../exception-code.js';
 export class ValidationException extends DomainException {
     constructor(errors) {
         super(`Validation failed, ${errors.map(_a.describe).join(', ')}`, [
-            ExceptionCode.ValidationFailed,
+            DomainExceptionCode.ValidationFailed,
         ]);
-        this.errors = Object.freeze(errors.map(({ field, code = ExceptionCode.ValidationFailed, message }) => Object.freeze({ field, code, message })));
+        this.errors = Object.freeze(errors.map(({ field, code = DomainExceptionCode.ValidationFailed, message }) => Object.freeze({ field, code, message })));
     }
     static describe(issue) {
         return issue.field === null ? issue.message : `${issue.field}: ${issue.message}`;
@@ -15,5 +15,5 @@ export class ValidationException extends DomainException {
 }
 _a = ValidationException;
 (() => {
-    ExceptionBrand.brandClass(_a, ExceptionCode.ValidationFailed);
+    ExceptionBrand.brandClass(_a, DomainExceptionCode.ValidationFailed);
 })();

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

@@ -8,3 +8,10 @@ export type { AggregateSaver } from './repository/aggregate-saver.js';
 export type { AggregateRemover } from './repository/aggregate-remover.js';
 export { Specification } from './specification/specification.js';
 export type { SatisfiedBy } from './specification/specification.js';
+export { DomainException } from './exceptions/domain.exception.js';
+export { ValidationException } from './exceptions/validation.exception.js';
+export type { ValidationIssue, ValidationIssueInput } from './exceptions/validation.exception.js';
+export { TypePrimitiveException } from './exceptions/type-primitive.exception.js';
+export { RequiredValueException } from './exceptions/required-value.exception.js';
+export { InvalidEventDefinitionException } from './exceptions/invalid-event-definition.exception.js';
+export { DomainExceptionCode } from './exceptions/domain-exception-code.js';

package/dist/esm/domain/index.js

@@ -4,3 +4,9 @@ export * from './aggregate/aggregate-root.js';
 export * from './type/index.js';
 export * from './primitive/primitive-types.js';
 export { Specification } from './specification/specification.js';
+export { DomainException } from './exceptions/domain.exception.js';
+export { ValidationException } from './exceptions/validation.exception.js';
+export { TypePrimitiveException } from './exceptions/type-primitive.exception.js';
+export { RequiredValueException } from './exceptions/required-value.exception.js';
+export { InvalidEventDefinitionException } from './exceptions/invalid-event-definition.exception.js';
+export { DomainExceptionCode } from './exceptions/domain-exception-code.js';

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

@@ -1,4 +1,3 @@
-import type { AggregateRoot } from '../aggregate/aggregate-root.js';
 import type { AbstractType } from '../type/abstract-type.js';
 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/esm/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.js';
-import type { ValidationIssue } from '../../exceptions/index.js';
-type JsonValue<T> = T extends Date ? string : T;
+import type { RequiredMarked } from './required/required-mark.js';
+import type { ValidationIssue } from '../exceptions/validation.exception.js';
+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/esm/domain/type/abstract-type.js

@@ -1,8 +1,8 @@
 var _a;
 import { anyToString, runValidations } from '@archi-code/validation';
-import { ValueEquality } from './equality/value-equality.js';
 import { RequiredMark } from './required/required-mark.js';
-import { RequiredValueException, ValidationException } from '../../exceptions/index.js';
+import { RequiredValueException } from '../exceptions/required-value.exception.js';
+import { ValidationException } from '../exceptions/validation.exception.js';
 const VALUE_OBJECT = Symbol.for('@archi-code/ddd/value-object.v1');
 export class AbstractType {
     static [Symbol.hasInstance](candidate) {
@@ -13,7 +13,10 @@ export 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 && RequiredMark.isMarked(this)) {
+            throw new RequiredValueException(this.constructor.name, value);
+        }
         const brokenRules = this.brokenRules(this._value);
         if (brokenRules.length > 0) {
             throw new ValidationException(brokenRules);
@@ -28,35 +31,24 @@ export class AbstractType {
     toString() {
         return this.isNull ? '' : 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 &&
-            ValueEquality.equals(this._value, other._value));
+        return other?.constructor === this.constructor && this.hasSameValue(other);
+    }
+    hasSameValue(other) {
+        return this._value === other._value;
     }
     validate() {
-        return runValidations(this.constructor, this._value);
+        return this.runRules(this._value);
     }
     brokenRules(value) {
-        return 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 && RequiredMark.isMarked(this)) {
-            throw new RequiredValueException(this.constructor.name, value);
-        }
-        return accepted;
-    }
-    static isMissingInput(value) {
-        return (value === null || value === undefined || (typeof value === 'string' && value.trim() === ''));
+    runRules(value) {
+        return runValidations(this.constructor, value);
     }
 }
 _a = AbstractType;

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

@@ -1,6 +1,6 @@
 import type { ValidationResult } from '@archi-code/validation';
 import { AbstractType } from './abstract-type.js';
-import type { ValueOf } from './required/required-mark.js';
+import type { ValueOf } from './abstract-type.js';
 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/esm/domain/type/array-type.js

@@ -1,9 +1,6 @@
 import { toArray } from '@archi-code/validation';
 import { AbstractType } from './abstract-type.js';
-import { Immutable } from './immutable/immutable.js';
-import { ValueEquality } from './equality/value-equality.js';
-import { ValueObjects } from './value-objects/value-objects.js';
-import { TypePrimitiveException, ValidationException } from '../../exceptions/index.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
 export class ArrayType extends AbstractType {
     get items() {
         return (this._value ?? []).map((value) => this.createItem(value));
@@ -12,8 +9,8 @@ export class ArrayType extends AbstractType {
         return this.items.map((item) => item.toString()).join(', ');
     }
     hasItem(value) {
-        const itemValue = this.createItem(value).value;
-        return (this._value ?? []).some((current) => 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]);
@@ -22,23 +19,25 @@ export class ArrayType extends AbstractType {
         if (this._value === null) {
             return this;
         }
-        const itemValue = this.createItem(value).value;
-        return this.copyWith(this._value.filter((current) => !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 = toArray(value);
         if (!converted.ok) {
             throw new TypePrimitiveException('Array', value);
         }
-        try {
-            return Immutable.freeze(ValueObjects.buildList(converted.value, (item) => this.createItem(item).value));
-        }
-        catch (error) {
-            if (error instanceof ValidationException) {
-                throw new ValidationException([...this.brokenRules(converted.value), ...error.errors]);
-            }
-            throw error;
-        }
+        const items = converted.value.map((item) => this.createItem(item).value);
+        Object.freeze(items);
+        return items;
     }
     validate() {
         const own = super.validate();

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

@@ -1,6 +1,6 @@
 import { toBoolean } from '@archi-code/validation';
 import { AbstractType } from './abstract-type.js';
-import { TypePrimitiveException } from '../../exceptions/index.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
 export class BooleanType extends AbstractType {
     filter(value) {
         const converted = toBoolean(value);

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

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

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

@@ -1,59 +1,82 @@
-import { ValueObjects } from '../value-objects/value-objects.js';
-import { RequiredValueException, TypePrimitiveException } from '../../../exceptions/index.js';
-const COMPOSITE = Symbol.for('@archi-code/ddd/composite.v1');
+import { CompositeBrand } from './composite-brand.js';
+import { CompositeIssues } from './composite-issues.js';
+import { RequiredValueException } from '../../exceptions/required-value.exception.js';
+import { TypePrimitiveException } from '../../exceptions/type-primitive.exception.js';
 export 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 CompositeBrand.isComposite(fieldClass.prototype)
+            ? new NestedCompositeField(fieldClass)
+            : new ValueField(fieldClass);
     }
-    static isComposite(value) {
-        return (typeof value === 'object' &&
-            value !== null &&
-            value[COMPOSITE] === true);
+}
+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 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 TypePrimitiveException('Array', primitive);
-            }
-            return ValueObjects.buildList(primitive, (item) => CompositeField.fromPrimitive(spec[0], item));
+    accept(path, value) {
+        if (value === null || value === undefined) {
+            throw new 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 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 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 TypePrimitiveException(`${this.typeName} for ${path}`, value);
         }
-        if (!(value instanceof fieldClass)) {
-            throw new 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 TypePrimitiveException(this.typeName, primitive);
         }
-        return value;
+        return 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])));
     }
 }

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

@@ -0,0 +1,31 @@
+import { IssueCollectionError, IssueCollector } from '../../../shared/index.js';
+import { DomainException } from '../../exceptions/domain.exception.js';
+import { ValidationException } from '../../exceptions/validation.exception.js';
+export class CompositeIssues {
+    static collectFields(builds) {
+        return CompositeIssues.validated(() => IssueCollector.collectFields(builds, CompositeIssues.read));
+    }
+    static collectItems(items, build) {
+        return CompositeIssues.validated(() => IssueCollector.collectItems(items, build, CompositeIssues.read));
+    }
+    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;
+    }
+}

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

@@ -1,26 +1,25 @@
 import { runValidations } from '@archi-code/validation';
+import { CompositeBrand } from './composite-brand.js';
 import { CompositeField } from './composite-field.js';
-import { ValueObjects } from '../value-objects/value-objects.js';
-import { TypePrimitiveException, ValidationException } from '../../../exceptions/index.js';
+import { CompositeIssues } from './composite-issues.js';
+import { TypePrimitiveException } from '../../exceptions/type-primitive.exception.js';
+import { ValidationException } from '../../exceptions/validation.exception.js';
 export function Composite(schema) {
-    const fields = Object.keys(schema);
+    const fields = Object.entries(schema).map(([name, spec]) => [name, CompositeField.of(spec)]);
     class CompositeValueObject {
         static fromPrimitives(primitives) {
             if (typeof primitives !== 'object' || primitives === null || Array.isArray(primitives)) {
                 throw new TypePrimitiveException(this.name, primitives);
             }
             const record = primitives;
-            const props = ValueObjects.build(Object.fromEntries(fields.map((field) => [
-                field,
-                () => 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(CompositeIssues.collectFields(builds));
         }
         constructor(props) {
             const owner = this.constructor.name;
-            for (const field of fields) {
-                Object.defineProperty(this, field, {
-                    value: 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,
                 });
             }
@@ -38,15 +37,12 @@ export function Composite(schema) {
             return (typeof other === 'object' &&
                 other !== null &&
                 other.constructor === this.constructor &&
-                fields.every((field) => CompositeField.equals(this[field], other[field])));
+                fields.every(([name, field]) => field.equals(this[name], other[name])));
         }
         toPrimitives() {
-            return Object.fromEntries(fields.map((field) => [
-                field,
-                CompositeField.primitive(this[field]),
-            ]));
+            return Object.fromEntries(fields.map(([name, field]) => [name, field.toPrimitive(this[name])]));
         }
     }
-    CompositeField.brand(CompositeValueObject.prototype);
+    CompositeBrand.mark(CompositeValueObject.prototype);
     return CompositeValueObject;
 }

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

@@ -2,14 +2,15 @@ import { AbstractType } from './abstract-type.js';
 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.js").RequiredType<typeof DateType>;
+declare const CreatedAt_base: import("./required/required-type.js").RequiredType<typeof DateType>;
 export declare class CreatedAt extends CreatedAt_base {
     static now(clock?: {
         now(): Date;
     }): CreatedAt;
 }
-declare const UpdatedAt_base: import("./required/required.js").RequiredType<typeof DateType>;
+declare const UpdatedAt_base: import("./required/required-type.js").RequiredType<typeof DateType>;
 export declare class UpdatedAt extends UpdatedAt_base {
     static now(clock?: {
         now(): Date;