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

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

@@ -0,0 +1,57 @@
+var _a;
+import { anyToString, runValidations } from '@archi-code/validation';
+import { RequiredMark } from './required/required-mark.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) {
+        return (Function.prototype[Symbol.hasInstance].call(this, candidate) ||
+            (this === _a &&
+                typeof candidate === 'object' &&
+                candidate !== null &&
+                candidate[VALUE_OBJECT] === true));
+    }
+    constructor(value = null) {
+        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);
+        }
+    }
+    get value() {
+        return this._value;
+    }
+    get isNull() {
+        return this._value === null;
+    }
+    toString() {
+        return this.isNull ? '' : anyToString(this._value);
+    }
+    equals(other) {
+        return other?.constructor === this.constructor && this.hasSameValue(other);
+    }
+    hasSameValue(other) {
+        return this._value === other._value;
+    }
+    validate() {
+        return this.runRules(this._value);
+    }
+    brokenRules(value) {
+        return this.runRules(value).errors.map((error) => ({
+            field: null,
+            code: 'validator' in error ? error.validator : error.custom,
+            message: `${this.constructor.name}: ${error.message}`,
+        }));
+    }
+    runRules(value) {
+        return runValidations(this.constructor, value);
+    }
+}
+_a = AbstractType;
+(() => {
+    Object.defineProperty(_a.prototype, VALUE_OBJECT, { value: true });
+})();

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

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

@@ -0,0 +1,60 @@
+import { toArray } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
+export class ArrayType extends 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 = toArray(value);
+        if (!converted.ok) {
+            throw new 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);
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+import { toBoolean } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
+export class BooleanType extends AbstractType {
+    filter(value) {
+        const converted = toBoolean(value);
+        if (!converted.ok) {
+            throw new TypePrimitiveException('Boolean', value);
+        }
+        return converted.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

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

@@ -0,0 +1,82 @@
+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 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);
+    }
+}
+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 RequiredValueException(path, value);
+        }
+        if (!(value instanceof this.fieldClass)) {
+            throw new 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 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 TypePrimitiveException(this.typeName, primitive);
+        }
+        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.d.ts

@@ -0,0 +1,26 @@
+import type { FieldSpec } from './composite-field.js';
+import type { PrimitiveType } from '../../primitive/primitive-types.js';
+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/esm/domain/type/composite/composite.js

@@ -0,0 +1,48 @@
+import { runValidations } from '@archi-code/validation';
+import { CompositeBrand } from './composite-brand.js';
+import { CompositeField } from './composite-field.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.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 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 [name, field] of fields) {
+                Object.defineProperty(this, name, {
+                    value: field.accept(`${owner}.${name}`, props?.[name]),
+                    enumerable: true,
+                });
+            }
+            const brokenRules = runValidations(this.constructor, this).errors;
+            if (brokenRules.length > 0) {
+                throw new 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])]));
+        }
+    }
+    CompositeBrand.mark(CompositeValueObject.prototype);
+    return CompositeValueObject;
+}

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

@@ -0,0 +1,19 @@
+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-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-type.js").RequiredType<typeof DateType>;
+export declare class UpdatedAt extends UpdatedAt_base {
+    static now(clock?: {
+        now(): Date;
+    }): UpdatedAt;
+}
+export {};

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

@@ -0,0 +1,64 @@
+import { toDate } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { Required } from './required/required-type.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
+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+)?$/;
+export class DateType extends AbstractType {
+    filter(value) {
+        const converted = toDate(value, { iso: true });
+        if (!converted.ok || (typeof value === 'string' && TIME_WITHOUT_ZONE.test(value))) {
+            throw new 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();
+    }
+}
+const SYSTEM_TIME = { now: () => new Date() };
+export class CreatedAt extends Required(DateType) {
+    static now(clock = SYSTEM_TIME) {
+        return new CreatedAt(clock.now());
+    }
+}
+export class UpdatedAt extends Required(DateType) {
+    static now(clock = SYSTEM_TIME) {
+        return new UpdatedAt(clock.now());
+    }
+}

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

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

@@ -0,0 +1,26 @@
+import { AbstractType } from './abstract-type.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
+const NUMERIC_TEXT = /^-?\d+(?:\.\d+)?$/;
+export class EnumType extends AbstractType {
+    filter(value) {
+        const options = this.options();
+        const option = options.find((candidate) => EnumType.matches(candidate, value));
+        if (option === undefined) {
+            throw new 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);
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+import { toJson } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { TypePrimitiveException } from '../exceptions/type-primitive.exception.js';
+export class JsonType extends AbstractType {
+    filter(value) {
+        const converted = toJson(value);
+        if (!converted.ok) {
+            throw new 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;
+    }
+}

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

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

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

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

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

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

package/dist/esm/domain/type/required/required-mark.js

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