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

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

@@ -0,0 +1,17 @@
+import type { ValidationResult } from '@archi-code/validation';
+import { AbstractType } from './abstract-type';
+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;
+    get items(): Item[];
+    toString(): string;
+    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;
+}
+export {};

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

@@ -0,0 +1,64 @@
+"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 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));
+    }
+    toString() {
+        return this.items.map((item) => item.toString()).join(', ');
+    }
+    hasItem(value) {
+        const item = this.createItem(value);
+        return (this._value ?? []).some((current) => this.createItem(current).equals(item));
+    }
+    withItem(value) {
+        return this.copyWith([...(this._value ?? []), value]);
+    }
+    withoutItem(value) {
+        if (this._value === null) {
+            return this;
+        }
+        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 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();
+        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 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 type_primitive_exception_1.TypePrimitiveException('Boolean', value);
+        }
+        return converted.value;
+    }
+}
+exports.BooleanType = BooleanType;

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

@@ -0,0 +1,18 @@
+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 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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeField = void 0;
+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 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);
+    }
+}
+exports.CompositeField = CompositeField;
+class SingleField extends CompositeField {
+    constructor(fieldClass) {
+        super();
+        this.fieldClass = fieldClass;
+    }
+    get typeName() {
+        return this.fieldClass.name;
+    }
+    accept(path, value) {
+        if (value === null || value === undefined) {
+            throw new required_value_exception_1.RequiredValueException(path, value);
+        }
+        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);
+    }
+}
+class ValueField extends SingleField {
+    fromPrimitive(primitive) {
+        return new this.fieldClass(primitive);
+    }
+    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);
+        }
+        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 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])));
+    }
+}

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.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,51 @@
+"use strict";
+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 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.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 type_primitive_exception_1.TypePrimitiveException(this.name, primitives);
+            }
+            const record = primitives;
+            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 [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 validation_exception_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(([name, field]) => field.equals(this[name], other[name])));
+        }
+        toPrimitives() {
+            return Object.fromEntries(fields.map(([name, field]) => [name, field.toPrimitive(this[name])]));
+        }
+    }
+    composite_brand_1.CompositeBrand.mark(CompositeValueObject.prototype);
+    return CompositeValueObject;
+}

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

@@ -0,0 +1,19 @@
+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-type").RequiredType<typeof DateType>;
+export declare class CreatedAt extends CreatedAt_base {
+    static now(clock?: {
+        now(): Date;
+    }): CreatedAt;
+}
+declare const UpdatedAt_base: import("./required/required-type").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,70 @@
+"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 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 type_primitive_exception_1.TypePrimitiveException('Date', 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_type_1.Required)(DateType) {
+    static now(clock = SYSTEM_TIME) {
+        return new CreatedAt(clock.now());
+    }
+}
+exports.CreatedAt = CreatedAt;
+class UpdatedAt extends (0, required_type_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;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumType = void 0;
+const abstract_type_1 = require("./abstract-type");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
+const NUMERIC_TEXT = /^-?\d+(?:\.\d+)?$/;
+class EnumType extends abstract_type_1.AbstractType {
+    filter(value) {
+        const options = this.options();
+        const option = options.find((candidate) => EnumType.matches(candidate, value));
+        if (option === undefined) {
+            throw new type_primitive_exception_1.TypePrimitiveException(`Expected one of [${options.join(', ')}]`, value, '');
+        }
+        return option;
+    }
+    static matches(option, value) {
+        return (option === value ||
+            (typeof option === 'number' &&
+                typeof value === 'string' &&
+                NUMERIC_TEXT.test(value) &&
+                Number(value) === option));
+    }
+    options() {
+        const enumObject = this.getEnum();
+        return Object.entries(enumObject)
+            .filter(([, option]) => typeof enumObject[option] !== 'number')
+            .map(([, option]) => option);
+    }
+}
+exports.EnumType = EnumType;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdType = void 0;
+const required_type_1 = require("./required/required-type");
+const uuid_type_1 = require("./uuid-type");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
+const NIL_OR_MAX_UUID = /^(?:0{8}-0{4}-0{4}-0{4}-0{12}|f{8}-f{4}-f{4}-f{4}-f{12})$/i;
+class IdType extends (0, required_type_1.Required)(uuid_type_1.UuidType) {
+    filter(value) {
+        const id = super.filter(value);
+        if (NIL_OR_MAX_UUID.test(id)) {
+            throw new type_primitive_exception_1.TypePrimitiveException('Id', value);
+        }
+        return id;
+    }
+}
+exports.IdType = IdType;

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Composite = exports.UuidType = exports.IdType = exports.StringType = exports.NumberType = exports.JsonType = exports.EnumType = exports.UpdatedAt = exports.DateType = exports.CreatedAt = exports.BooleanType = exports.ArrayType = exports.Required = exports.AbstractType = void 0;
+var abstract_type_1 = require("./abstract-type");
+Object.defineProperty(exports, "AbstractType", { enumerable: true, get: function () { return abstract_type_1.AbstractType; } });
+var required_type_1 = require("./required/required-type");
+Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return required_type_1.Required; } });
+var array_type_1 = require("./array-type");
+Object.defineProperty(exports, "ArrayType", { enumerable: true, get: function () { return array_type_1.ArrayType; } });
+var boolean_type_1 = require("./boolean-type");
+Object.defineProperty(exports, "BooleanType", { enumerable: true, get: function () { return boolean_type_1.BooleanType; } });
+var date_type_1 = require("./date-type");
+Object.defineProperty(exports, "CreatedAt", { enumerable: true, get: function () { return date_type_1.CreatedAt; } });
+Object.defineProperty(exports, "DateType", { enumerable: true, get: function () { return date_type_1.DateType; } });
+Object.defineProperty(exports, "UpdatedAt", { enumerable: true, get: function () { return date_type_1.UpdatedAt; } });
+var enum_type_1 = require("./enum-type");
+Object.defineProperty(exports, "EnumType", { enumerable: true, get: function () { return enum_type_1.EnumType; } });
+var json_type_1 = require("./json-type");
+Object.defineProperty(exports, "JsonType", { enumerable: true, get: function () { return json_type_1.JsonType; } });
+var number_type_1 = require("./number-type");
+Object.defineProperty(exports, "NumberType", { enumerable: true, get: function () { return number_type_1.NumberType; } });
+var string_type_1 = require("./string-type");
+Object.defineProperty(exports, "StringType", { enumerable: true, get: function () { return string_type_1.StringType; } });
+var id_type_1 = require("./id-type");
+Object.defineProperty(exports, "IdType", { enumerable: true, get: function () { return id_type_1.IdType; } });
+var uuid_type_1 = require("./uuid-type");
+Object.defineProperty(exports, "UuidType", { enumerable: true, get: function () { return uuid_type_1.UuidType; } });
+var composite_1 = require("./composite/composite");
+Object.defineProperty(exports, "Composite", { enumerable: true, get: function () { return composite_1.Composite; } });

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

@@ -0,0 +1,9 @@
+import { AbstractType } from './abstract-type';
+export type JsonTypeValue = Record<string, any>;
+export declare class JsonType<T extends JsonTypeValue = JsonTypeValue> extends AbstractType<T> {
+    protected filter(value: unknown): T;
+    protected hasSameValue(other: this): boolean;
+    private static sameJson;
+    private static deepFreeze;
+    private static isObject;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonType = void 0;
+const validation_1 = require("@archi-code/validation");
+const abstract_type_1 = require("./abstract-type");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
+class JsonType extends abstract_type_1.AbstractType {
+    filter(value) {
+        const converted = (0, validation_1.toJson)(value);
+        if (!converted.ok) {
+            throw new type_primitive_exception_1.TypePrimitiveException('Json', value);
+        }
+        return JsonType.deepFreeze(JSON.parse(JSON.stringify(converted.value)));
+    }
+    hasSameValue(other) {
+        return JsonType.sameJson(this._value, other._value);
+    }
+    static sameJson(left, right) {
+        if (Array.isArray(left) || Array.isArray(right)) {
+            return (Array.isArray(left) &&
+                Array.isArray(right) &&
+                left.length === right.length &&
+                left.every((item, index) => JsonType.sameJson(item, right[index])));
+        }
+        if (JsonType.isObject(left) && JsonType.isObject(right)) {
+            const keys = Object.keys(left);
+            return (keys.length === Object.keys(right).length &&
+                keys.every((key) => Object.prototype.hasOwnProperty.call(right, key) &&
+                    JsonType.sameJson(left[key], right[key])));
+        }
+        return left === right;
+    }
+    static deepFreeze(value) {
+        if (JsonType.isObject(value)) {
+            Object.freeze(value);
+            for (const child of Object.values(value)) {
+                JsonType.deepFreeze(child);
+            }
+        }
+        return value;
+    }
+    static isObject(value) {
+        return typeof value === 'object' && value !== null;
+    }
+}
+exports.JsonType = JsonType;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberType = void 0;
+const validation_1 = require("@archi-code/validation");
+const abstract_type_1 = require("./abstract-type");
+const type_primitive_exception_1 = require("../exceptions/type-primitive.exception");
+class NumberType extends abstract_type_1.AbstractType {
+    filter(value) {
+        const converted = (0, validation_1.toFloat)(value);
+        if (!converted.ok) {
+            throw new type_primitive_exception_1.TypePrimitiveException('Number', value);
+        }
+        return converted.value;
+    }
+}
+exports.NumberType = NumberType;

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

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