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

package/dist/cjs/domain/event/event-base.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBase = void 0;
+const date_type_1 = require("../type/date-type");
+const id_type_1 = require("../type/id-type");
+const uuid_type_1 = require("../type/uuid-type");
+const index_1 = require("../../exceptions/index");
+class EventBase {
+    constructor(aggregateId, metadata = {}) {
+        const { eventName, eventVersion = 1 } = this.constructor;
+        if (typeof eventName !== 'string' || eventName.trim() === '') {
+            throw new index_1.InternalErrorException(`${this.constructor.name} must declare a static eventName`);
+        }
+        if (!Number.isSafeInteger(eventVersion) || eventVersion < 1) {
+            throw new index_1.InternalErrorException(`${this.constructor.name}.eventVersion must be a whole number from 1`);
+        }
+        if (aggregateId === null ||
+            aggregateId === undefined ||
+            (typeof aggregateId === 'string' && aggregateId.trim() === '')) {
+            throw new index_1.RequiredValueException(`${this.constructor.name}.aggregateId`, aggregateId);
+        }
+        this.aggregateId = aggregateId;
+        this.eventId = new id_type_1.IdType(metadata.eventId ?? uuid_type_1.UuidType.random()).value;
+        this.occurredOn =
+            metadata.occurredOn === undefined
+                ? date_type_1.CreatedAt.now(metadata.clock).value
+                : new date_type_1.CreatedAt(metadata.occurredOn).value;
+    }
+    eventName() {
+        return this.constructor.eventName;
+    }
+    eventVersion() {
+        return this.constructor.eventVersion ?? 1;
+    }
+    toJSON() {
+        const serialized = {
+            eventName: this.eventName(),
+            eventVersion: this.eventVersion(),
+            eventId: this.eventId,
+            aggregateId: this.aggregateId,
+            occurredOn: this.occurredOn.toISOString(),
+        };
+        for (const [key, value] of Object.entries(this)) {
+            if (!(key in serialized)) {
+                serialized[key] = value;
+            }
+        }
+        return serialized;
+    }
+}
+exports.EventBase = EventBase;

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

@@ -0,0 +1,10 @@
+export * from './event/event-base';
+export * from './entity/entity';
+export * from './aggregate/aggregate-root';
+export * from './type';
+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';

package/dist/cjs/domain/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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;
+__exportStar(require("./event/event-base"), exports);
+__exportStar(require("./entity/entity"), exports);
+__exportStar(require("./aggregate/aggregate-root"), exports);
+__exportStar(require("./type"), 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; } });

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

@@ -0,0 +1,22 @@
+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;
+}[keyof T];
+export type MethodsAndProperties<T> = {
+    [key in keyof T]: T[key];
+};
+export type Properties<T> = Omit<MethodsAndProperties<T>, Methods<T>>;
+export type MutablePropertiesData<T> = Mutable<Required<Properties<T>>>;
+export type PropertiesData<T> = Required<Properties<T>>;
+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]>;
+};
+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;
+export {};

package/dist/cjs/domain/primitive/primitive-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/domain/repository/aggregate-finder.d.ts

@@ -0,0 +1,4 @@
+import type { AggregateRoot } from '../aggregate/aggregate-root';
+export interface AggregateFinder<Aggregate extends AggregateRoot<any, any>> {
+    findById(id: Aggregate['id']): Promise<Aggregate | null>;
+}

package/dist/cjs/domain/repository/aggregate-finder.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/domain/repository/aggregate-remover.d.ts

@@ -0,0 +1,4 @@
+import type { AggregateRoot } from '../aggregate/aggregate-root';
+export interface AggregateRemover<Aggregate extends AggregateRoot<any, any>> {
+    remove(aggregate: Aggregate): Promise<void>;
+}

package/dist/cjs/domain/repository/aggregate-remover.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/domain/repository/aggregate-saver.d.ts

@@ -0,0 +1,4 @@
+import type { AggregateRoot } from '../aggregate/aggregate-root';
+export interface AggregateSaver<Aggregate extends AggregateRoot<any, any>> {
+    save(aggregate: Aggregate): Promise<void>;
+}

package/dist/cjs/domain/repository/aggregate-saver.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,9 @@
+export interface SatisfiedBy<Candidate> {
+    isSatisfiedBy(candidate: Candidate): boolean;
+}
+export declare abstract class Specification<Candidate> implements SatisfiedBy<Candidate> {
+    abstract isSatisfiedBy(candidate: Candidate): boolean;
+    and(other: SatisfiedBy<Candidate>): Specification<Candidate>;
+    or(other: SatisfiedBy<Candidate>): Specification<Candidate>;
+    not(): Specification<Candidate>;
+}

package/dist/cjs/domain/specification/specification.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Specification = void 0;
+class Specification {
+    and(other) {
+        return new BothSpecification(this, other);
+    }
+    or(other) {
+        return new EitherSpecification(this, other);
+    }
+    not() {
+        return new NegatedSpecification(this);
+    }
+}
+exports.Specification = Specification;
+class BothSpecification extends Specification {
+    constructor(left, right) {
+        super();
+        this.left = left;
+        this.right = right;
+    }
+    isSatisfiedBy(candidate) {
+        return this.left.isSatisfiedBy(candidate) && this.right.isSatisfiedBy(candidate);
+    }
+}
+class EitherSpecification extends Specification {
+    constructor(left, right) {
+        super();
+        this.left = left;
+        this.right = right;
+    }
+    isSatisfiedBy(candidate) {
+        return this.left.isSatisfiedBy(candidate) || this.right.isSatisfiedBy(candidate);
+    }
+}
+class NegatedSpecification extends Specification {
+    constructor(negated) {
+        super();
+        this.negated = negated;
+    }
+    isSatisfiedBy(candidate) {
+        return !this.negated.isSatisfiedBy(candidate);
+    }
+}

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

@@ -0,0 +1,20 @@
+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;
+export declare abstract class AbstractType<T, Input = T> implements Validatable<T | null> {
+    protected readonly _value: T | null;
+    static [Symbol.hasInstance](candidate: unknown): boolean;
+    constructor(value?: Input | null);
+    get value(): ValueOf<T, this>;
+    get isNull(): boolean;
+    toString(): string;
+    toJSON(): ValueOf<JsonValue<T>, this>;
+    equals(other: unknown): boolean;
+    validate(): ValidationResult<ValueOf<T, this>>;
+    protected brokenRules(value: unknown): ValidationIssue[];
+    protected abstract filter(value: unknown): T | null;
+    private acceptInput;
+    private static isMissingInput;
+}
+export {};

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

@@ -0,0 +1,69 @@
+"use strict";
+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 VALUE_OBJECT = Symbol.for('@archi-code/ddd/value-object.v1');
+class AbstractType {
+    static [Symbol.hasInstance](candidate) {
+        return (Function.prototype[Symbol.hasInstance].call(this, candidate) ||
+            (this === _a &&
+                typeof candidate === 'object' &&
+                candidate !== null &&
+                candidate[VALUE_OBJECT] === true));
+    }
+    constructor(value = null) {
+        this._value = this.acceptInput(value);
+        const brokenRules = this.brokenRules(this._value);
+        if (brokenRules.length > 0) {
+            throw new index_1.ValidationException(brokenRules);
+        }
+    }
+    get value() {
+        return this._value;
+    }
+    get isNull() {
+        return this._value === null;
+    }
+    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));
+    }
+    validate() {
+        return (0, validation_1.runValidations)(this.constructor, this._value);
+    }
+    brokenRules(value) {
+        return (0, validation_1.runValidations)(this.constructor, 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() === ''));
+    }
+}
+exports.AbstractType = AbstractType;
+_a = AbstractType;
+(() => {
+    Object.defineProperty(_a.prototype, VALUE_OBJECT, { value: true });
+})();

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

@@ -0,0 +1,16 @@
+import type { ValidationResult } from '@archi-code/validation';
+import { AbstractType } from './abstract-type';
+import type { ValueOf } from './required/required-mark';
+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;
+    get items(): Item[];
+    toString(): string;
+    hasItem(value: ItemValue<Item>): boolean;
+    withItem(value: ItemValue<Item>): this;
+    withoutItem(value: ItemValue<Item>): this;
+    protected filter(value: unknown): ItemValue<Item>[];
+    validate(): ValidationResult<ValueOf<ItemValue<Item>[], this>>;
+    private copyWith;
+}
+export {};

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

@@ -0,0 +1,65 @@
+"use strict";
+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");
+class ArrayType extends abstract_type_1.AbstractType {
+    get items() {
+        return (this._value ?? []).map((value) => this.createItem(value));
+    }
+    toString() {
+        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));
+    }
+    withItem(value) {
+        return this.copyWith([...(this._value ?? []), value]);
+    }
+    withoutItem(value) {
+        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)));
+    }
+    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;
+        }
+    }
+    validate() {
+        const own = super.validate();
+        const itemErrors = (this._value ?? []).flatMap((itemValue, index) => this.createItem(itemValue)
+            .validate()
+            .errors.map((error) => Object.freeze({ ...error, message: `Item ${index + 1}: ${error.message}` })));
+        if (itemErrors.length === 0) {
+            return own;
+        }
+        return Object.freeze({
+            ok: false,
+            value: own.value,
+            errors: Object.freeze([...own.errors, ...itemErrors]),
+        });
+    }
+    copyWith(values) {
+        const SameType = this.constructor;
+        return new SameType(values);
+    }
+}
+exports.ArrayType = ArrayType;

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

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

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

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

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

@@ -0,0 +1,19 @@
+import type { AbstractType } from '../abstract-type';
+export type ValueClass = new (value: any) => AbstractType<any>;
+export interface CompositeClass {
+    readonly name: string;
+    readonly prototype: object;
+    new (props: any): object;
+    fromPrimitives(primitives: any): object;
+}
+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;
+}

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

@@ -0,0 +1,63 @@
+"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');
+class CompositeField {
+    static brand(prototype) {
+        Object.defineProperty(prototype, COMPOSITE, { value: true });
+    }
+    static isComposite(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            value[COMPOSITE] === true);
+    }
+    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)));
+    }
+    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));
+        }
+        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])));
+        }
+        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;
+    }
+    static acceptOne(owner, field, fieldClass, value) {
+        if (value === null || value === undefined) {
+            throw new index_1.RequiredValueException(`${owner}.${field}`, value);
+        }
+        if (!(value instanceof fieldClass)) {
+            throw new index_1.TypePrimitiveException(`${fieldClass.name} for ${owner}.${field}`, value);
+        }
+        return value;
+    }
+}
+exports.CompositeField = CompositeField;

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

@@ -0,0 +1,26 @@
+import type { FieldSpec } from './composite-field';
+import type { PrimitiveType } from '../../primitive/primitive-types';
+export type CompositeSchema = Record<string, FieldSpec>;
+type FieldOf<Spec> = Spec extends readonly [infer Item] ? FieldOf<Item>[] : Spec extends abstract new (...args: any[]) => infer Instance ? Instance : never;
+export type CompositeProps<Schema extends CompositeSchema> = {
+    readonly [Field in keyof Schema]: FieldOf<Schema[Field]>;
+};
+export type CompositePrimitives<Schema extends CompositeSchema> = {
+    [Field in keyof Schema]: PrimitiveType<FieldOf<Schema[Field]>>;
+};
+type InputOf<Spec> = Spec extends readonly [infer Item] ? InputOf<Item>[] : Spec extends {
+    fromPrimitives(this: any, primitives: infer Primitives): unknown;
+} ? Primitives : Spec extends abstract new (value: infer Value) => unknown ? Exclude<Value, undefined> : never;
+export type CompositeInput<Schema extends CompositeSchema> = {
+    [Field in keyof Schema]: InputOf<Schema[Field]>;
+};
+export interface CompositeValue<Schema extends CompositeSchema> {
+    equals(other: unknown): boolean;
+    toPrimitives(): CompositePrimitives<Schema>;
+}
+export interface CompositeType<Schema extends CompositeSchema> {
+    new (props: CompositeProps<Schema>): CompositeProps<Schema> & CompositeValue<Schema>;
+    fromPrimitives<Composed>(this: new (props: CompositeProps<Schema>) => Composed, primitives: CompositeInput<Schema>): Composed;
+}
+export declare function Composite<Schema extends CompositeSchema>(schema: Schema): CompositeType<Schema>;
+export {};

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Composite = Composite;
+const validation_1 = require("@archi-code/validation");
+const composite_field_1 = require("./composite-field");
+const value_objects_1 = require("../value-objects/value-objects");
+const index_1 = require("../../../exceptions/index");
+function Composite(schema) {
+    const fields = Object.keys(schema);
+    class CompositeValueObject {
+        static fromPrimitives(primitives) {
+            if (typeof primitives !== 'object' || primitives === null || Array.isArray(primitives)) {
+                throw new index_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);
+        }
+        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]),
+                    enumerable: true,
+                });
+            }
+            const brokenRules = (0, validation_1.runValidations)(this.constructor, this).errors;
+            if (brokenRules.length > 0) {
+                throw new index_1.ValidationException(brokenRules.map((error) => ({
+                    field: null,
+                    code: 'custom' in error ? error.custom : error.validator,
+                    message: `${owner}: ${error.message}`,
+                })));
+            }
+            Object.freeze(this);
+        }
+        equals(other) {
+            return (typeof other === 'object' &&
+                other !== null &&
+                other.constructor === this.constructor &&
+                fields.every((field) => composite_field_1.CompositeField.equals(this[field], other[field])));
+        }
+        toPrimitives() {
+            return Object.fromEntries(fields.map((field) => [
+                field,
+                composite_field_1.CompositeField.primitive(this[field]),
+            ]));
+        }
+    }
+    composite_field_1.CompositeField.brand(CompositeValueObject.prototype);
+    return CompositeValueObject;
+}

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

@@ -0,0 +1,18 @@
+import { AbstractType } from './abstract-type';
+export declare class DateType extends AbstractType<Date, Date | string> {
+    protected filter(value: unknown): Date;
+    toString(): string;
+}
+declare const CreatedAt_base: import("./required/required").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>;
+export declare class UpdatedAt extends UpdatedAt_base {
+    static now(clock?: {
+        now(): Date;
+    }): UpdatedAt;
+}
+export {};

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

@@ -0,0 +1,35 @@
+"use strict";
+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 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);
+        }
+        return immutable_1.Immutable.date(converted.value);
+    }
+    toString() {
+        return this._value === null ? '' : this._value.toISOString();
+    }
+}
+exports.DateType = DateType;
+const SYSTEM_TIME = { now: () => new Date() };
+class CreatedAt extends (0, required_1.Required)(DateType) {
+    static now(clock = SYSTEM_TIME) {
+        return new CreatedAt(clock.now());
+    }
+}
+exports.CreatedAt = CreatedAt;
+class UpdatedAt extends (0, required_1.Required)(DateType) {
+    static now(clock = SYSTEM_TIME) {
+        return new UpdatedAt(clock.now());
+    }
+}
+exports.UpdatedAt = UpdatedAt;

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

@@ -0,0 +1,7 @@
+import { AbstractType } from './abstract-type';
+export declare abstract class EnumType<T extends string | number> extends AbstractType<T> {
+    protected abstract getEnum(): Record<string, string | number>;
+    protected filter(value: unknown): T;
+    private static matches;
+    private options;
+}