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

package/dist/esm/domain/event/event-base.d.ts

@@ -0,0 +1,29 @@
+export interface EventMetadata {
+    eventId?: string;
+    occurredOn?: Date | string;
+    clock?: {
+        now(): Date;
+    };
+}
+export interface SerializedEvent {
+    eventName: string;
+    eventVersion: number;
+    eventId: string;
+    aggregateId: string;
+    occurredOn: string;
+    [payload: string]: unknown;
+}
+export interface EventClass<Event extends EventBase = EventBase> {
+    readonly eventName: string;
+    readonly eventVersion?: number;
+    new (...args: any[]): Event;
+}
+export declare abstract class EventBase {
+    readonly eventId: string;
+    readonly aggregateId: string;
+    readonly occurredOn: Date;
+    constructor(aggregateId: string, metadata?: EventMetadata);
+    eventName(): string;
+    eventVersion(): number;
+    toJSON(): SerializedEvent;
+}

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

@@ -0,0 +1,47 @@
+import { CreatedAt } from '../type/date-type.js';
+import { IdType } from '../type/id-type.js';
+import { UuidType } from '../type/uuid-type.js';
+import { InternalErrorException, RequiredValueException } from '../../exceptions/index.js';
+export class EventBase {
+    constructor(aggregateId, metadata = {}) {
+        const { eventName, eventVersion = 1 } = this.constructor;
+        if (typeof eventName !== 'string' || eventName.trim() === '') {
+            throw new InternalErrorException(`${this.constructor.name} must declare a static eventName`);
+        }
+        if (!Number.isSafeInteger(eventVersion) || eventVersion < 1) {
+            throw new InternalErrorException(`${this.constructor.name}.eventVersion must be a whole number from 1`);
+        }
+        if (aggregateId === null ||
+            aggregateId === undefined ||
+            (typeof aggregateId === 'string' && aggregateId.trim() === '')) {
+            throw new RequiredValueException(`${this.constructor.name}.aggregateId`, aggregateId);
+        }
+        this.aggregateId = aggregateId;
+        this.eventId = new IdType(metadata.eventId ?? UuidType.random()).value;
+        this.occurredOn =
+            metadata.occurredOn === undefined
+                ? CreatedAt.now(metadata.clock).value
+                : new 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;
+    }
+}

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

@@ -0,0 +1,10 @@
+export * from './event/event-base.js';
+export * from './entity/entity.js';
+export * from './aggregate/aggregate-root.js';
+export * from './type/index.js';
+export * from './primitive/primitive-types.js';
+export type { AggregateFinder } from './repository/aggregate-finder.js';
+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';

package/dist/esm/domain/index.js

@@ -0,0 +1,6 @@
+export * from './event/event-base.js';
+export * from './entity/entity.js';
+export * from './aggregate/aggregate-root.js';
+export * from './type/index.js';
+export * from './primitive/primitive-types.js';
+export { Specification } from './specification/specification.js';

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

@@ -0,0 +1,22 @@
+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;
+}[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/esm/domain/primitive/primitive-types.js

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/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/esm/domain/specification/specification.js

@@ -0,0 +1,40 @@
+export class Specification {
+    and(other) {
+        return new BothSpecification(this, other);
+    }
+    or(other) {
+        return new EitherSpecification(this, other);
+    }
+    not() {
+        return new NegatedSpecification(this);
+    }
+}
+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/esm/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.js';
+import type { ValidationIssue } from '../../exceptions/index.js';
+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/esm/domain/type/abstract-type.js

@@ -0,0 +1,65 @@
+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';
+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 = this.acceptInput(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);
+    }
+    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));
+    }
+    validate() {
+        return runValidations(this.constructor, this._value);
+    }
+    brokenRules(value) {
+        return 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 && 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() === ''));
+    }
+}
+_a = AbstractType;
+(() => {
+    Object.defineProperty(_a.prototype, VALUE_OBJECT, { value: true });
+})();

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

@@ -0,0 +1,16 @@
+import type { ValidationResult } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import type { ValueOf } from './required/required-mark.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 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,61 @@
+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';
+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 itemValue = this.createItem(value).value;
+        return (this._value ?? []).some((current) => 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) => !ValueEquality.equals(current, itemValue)));
+    }
+    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;
+        }
+    }
+    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/index.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-field.d.ts

@@ -0,0 +1,19 @@
+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 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/esm/domain/type/composite/composite-field.js

@@ -0,0 +1,59 @@
+import { ValueObjects } from '../value-objects/value-objects.js';
+import { RequiredValueException, TypePrimitiveException } from '../../../exceptions/index.js';
+const COMPOSITE = Symbol.for('@archi-code/ddd/composite.v1');
+export 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 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 TypePrimitiveException('Array', primitive);
+            }
+            return 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 RequiredValueException(`${owner}.${field}`, value);
+        }
+        if (!(value instanceof fieldClass)) {
+            throw new TypePrimitiveException(`${fieldClass.name} for ${owner}.${field}`, value);
+        }
+        return value;
+    }
+}

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,52 @@
+import { runValidations } from '@archi-code/validation';
+import { CompositeField } from './composite-field.js';
+import { ValueObjects } from '../value-objects/value-objects.js';
+import { TypePrimitiveException, ValidationException } from '../../../exceptions/index.js';
+export function Composite(schema) {
+    const fields = Object.keys(schema);
+    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);
+        }
+        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]),
+                    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((field) => CompositeField.equals(this[field], other[field])));
+        }
+        toPrimitives() {
+            return Object.fromEntries(fields.map((field) => [
+                field,
+                CompositeField.primitive(this[field]),
+            ]));
+        }
+    }
+    CompositeField.brand(CompositeValueObject.prototype);
+    return CompositeValueObject;
+}

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

@@ -0,0 +1,18 @@
+import { AbstractType } from './abstract-type.js';
+export declare class DateType extends AbstractType<Date, Date | string> {
+    protected filter(value: unknown): Date;
+    toString(): string;
+}
+declare const CreatedAt_base: import("./required/required.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>;
+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,29 @@
+import { toDate } from '@archi-code/validation';
+import { AbstractType } from './abstract-type.js';
+import { Immutable } from './immutable/immutable.js';
+import { Required } from './required/required.js';
+import { TypePrimitiveException } from '../../exceptions/index.js';
+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 Immutable.date(converted.value);
+    }
+    toString() {
+        return this._value === null ? '' : this._value.toISOString();
+    }
+}
+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/index.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/equality/value-equality.d.ts

@@ -0,0 +1,7 @@
+export declare class ValueEquality {
+    static equals(left: unknown, right: unknown): boolean;
+    private static sameInstant;
+    private static sameItems;
+    private static sameEntries;
+    private static isRecord;
+}