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

package/dist/esm/application/exceptions/concurrency.exception.js

@@ -0,0 +1,13 @@
+var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { ApplicationExceptionCode } from './application-exception-code.js';
+import { ApplicationException } from './application.exception.js';
+export class ConcurrencyException extends ApplicationException {
+    constructor(aggregateName, id, expectedVersion, options = {}) {
+        super(`${aggregateName} with ID ${id} was changed by someone else: expected version ${expectedVersion}.`, [ApplicationExceptionCode.ConcurrencyConflict], options);
+    }
+}
+_a = ConcurrencyException;
+(() => {
+    ExceptionBrand.brandClass(_a, ApplicationExceptionCode.ConcurrencyConflict);
+})();

package/dist/esm/application/exceptions/not-allowed.exception.d.ts

@@ -0,0 +1,5 @@
+import type { ExceptionOptions } from '../../shared/index.js';
+import { ApplicationException } from './application.exception.js';
+export declare class NotAllowedException extends ApplicationException {
+    constructor(message: string, options?: ExceptionOptions);
+}

package/dist/esm/application/exceptions/not-allowed.exception.js

@@ -0,0 +1,13 @@
+var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { ApplicationExceptionCode } from './application-exception-code.js';
+import { ApplicationException } from './application.exception.js';
+export class NotAllowedException extends ApplicationException {
+    constructor(message, options = {}) {
+        super(message, [ApplicationExceptionCode.NotAllowed], options);
+    }
+}
+_a = NotAllowedException;
+(() => {
+    ExceptionBrand.brandClass(_a, ApplicationExceptionCode.NotAllowed);
+})();

package/dist/esm/application/exceptions/unexpected-error.exception.d.ts

@@ -0,0 +1,5 @@
+import type { ExceptionOptions } from '../../shared/index.js';
+import { ApplicationException } from './application.exception.js';
+export declare class UnexpectedErrorException extends ApplicationException {
+    constructor(message: string, options?: ExceptionOptions);
+}

package/dist/esm/application/exceptions/unexpected-error.exception.js

@@ -0,0 +1,13 @@
+var _a;
+import { ExceptionBrand } from '../../shared/index.js';
+import { ApplicationExceptionCode } from './application-exception-code.js';
+import { ApplicationException } from './application.exception.js';
+export class UnexpectedErrorException extends ApplicationException {
+    constructor(message, options = {}) {
+        super(`Failed, unexpected error: ${message}`, [ApplicationExceptionCode.UnexpectedError], options);
+    }
+}
+_a = UnexpectedErrorException;
+(() => {
+    ExceptionBrand.brandClass(_a, ApplicationExceptionCode.UnexpectedError);
+})();

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

@@ -0,0 +1,14 @@
+export { UseCase } from './use-case/use-case.js';
+export { ValueObjectBuilder } from './value-object-builder/value-object-builder.js';
+export { EventListener } from './event/event-listener.js';
+export { ListensTo } from './event/listens-to.js';
+export type { ListenerSubscription, ListensToOptions } from './event/listens-to.js';
+export type { EventBus } from './event/event-bus.js';
+export type { Clock } from './ports/clock.js';
+export type { LogContext, Logger, LogLevel } from './ports/logger.js';
+export { ApplicationException } from './exceptions/application.exception.js';
+export { ConcurrencyException } from './exceptions/concurrency.exception.js';
+export { AggregateNotFoundException } from './exceptions/aggregate-not-found.exception.js';
+export { NotAllowedException } from './exceptions/not-allowed.exception.js';
+export { UnexpectedErrorException } from './exceptions/unexpected-error.exception.js';
+export { ApplicationExceptionCode } from './exceptions/application-exception-code.js';

package/dist/esm/application/index.js

@@ -0,0 +1,10 @@
+export { UseCase } from './use-case/use-case.js';
+export { ValueObjectBuilder } from './value-object-builder/value-object-builder.js';
+export { EventListener } from './event/event-listener.js';
+export { ListensTo } from './event/listens-to.js';
+export { ApplicationException } from './exceptions/application.exception.js';
+export { ConcurrencyException } from './exceptions/concurrency.exception.js';
+export { AggregateNotFoundException } from './exceptions/aggregate-not-found.exception.js';
+export { NotAllowedException } from './exceptions/not-allowed.exception.js';
+export { UnexpectedErrorException } from './exceptions/unexpected-error.exception.js';
+export { ApplicationExceptionCode } from './exceptions/application-exception-code.js';

package/dist/esm/application/ports/clock.d.ts

@@ -0,0 +1,3 @@
+export interface Clock {
+    now(): Date;
+}

package/dist/esm/application/ports/clock.js

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

package/dist/esm/application/ports/logger.d.ts

@@ -0,0 +1,8 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type LogContext = Readonly<Record<string, unknown>>;
+export interface Logger {
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}

package/dist/esm/application/ports/logger.js

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

package/dist/esm/application/use-case/use-case.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class UseCase<Input, Command, Output> {
+    execute(input: Input): Promise<Output>;
+    protected abstract toCommand(input: Input): Command;
+    protected abstract handle(command: Command): Promise<Output> | Output;
+    private static describe;
+}

package/dist/esm/application/use-case/use-case.js

@@ -0,0 +1,21 @@
+import { anyToString } from '@archi-code/validation';
+import { AbstractException } from '../../shared/index.js';
+import { UnexpectedErrorException } from '../exceptions/unexpected-error.exception.js';
+export class UseCase {
+    async execute(input) {
+        try {
+            return await this.handle(this.toCommand(input));
+        }
+        catch (error) {
+            if (error instanceof AbstractException) {
+                throw error;
+            }
+            throw new UnexpectedErrorException(`${this.constructor.name}: ${UseCase.describe(error)}`, {
+                cause: error,
+            });
+        }
+    }
+    static describe(error) {
+        return error instanceof Error ? error.message : anyToString(error);
+    }
+}

package/dist/esm/application/value-object-builder/value-object-builder.d.ts

@@ -0,0 +1,16 @@
+type Factories = Record<string, () => unknown>;
+type Built<F extends Factories> = {
+    [Field in keyof F]: ReturnType<F[Field]>;
+};
+type Synchronous<F extends Factories> = {
+    [Field in keyof F]: [ReturnType<F[Field]>] extends [never] ? F[Field] : [ReturnType<F[Field]>] extends [PromiseLike<unknown>] ? never : F[Field];
+};
+export declare class ValueObjectBuilder {
+    static build<F extends Factories>(factories: F & Synchronous<F>): Built<F>;
+    static buildList<Value, Item>(values: readonly Value[], factory: (value: Value, index: number) => Item): Item[];
+    private static synchronous;
+    private static validated;
+    private static read;
+    private static isThenable;
+}
+export {};

package/dist/esm/application/value-object-builder/value-object-builder.js

@@ -0,0 +1,47 @@
+import { DomainException, ValidationException } from '../../domain/index.js';
+import { IssueCollectionError, IssueCollector } from '../../shared/index.js';
+import { UnexpectedErrorException } from '../exceptions/unexpected-error.exception.js';
+export class ValueObjectBuilder {
+    static build(factories) {
+        const builds = Object.fromEntries(Object.entries(factories).map(([field, factory]) => [
+            field,
+            () => ValueObjectBuilder.synchronous(field, factory()),
+        ]));
+        return ValueObjectBuilder.validated(() => IssueCollector.collectFields(builds, ValueObjectBuilder.read));
+    }
+    static buildList(values, factory) {
+        return ValueObjectBuilder.validated(() => IssueCollector.collectItems(values, (value, index) => ValueObjectBuilder.synchronous(String(index), factory(value, index)), ValueObjectBuilder.read));
+    }
+    static synchronous(field, result) {
+        if (!ValueObjectBuilder.isThenable(result)) {
+            return result;
+        }
+        result.then(undefined, () => undefined);
+        throw new UnexpectedErrorException(`ValueObjectBuilder: the factory of "${field}" returned a Promise; build value objects synchronously`);
+    }
+    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;
+    }
+    static isThenable(result) {
+        return ((typeof result === 'object' || typeof result === 'function') &&
+            result !== null &&
+            typeof result.then === 'function');
+    }
+}

package/dist/esm/domain/aggregate/aggregate-root.d.ts

@@ -0,0 +1,9 @@
+import { Entity } from '../entity/entity.js';
+import type { EntityId } from '../entity/entity.js';
+import type { EventBase } from '../event/event-base.js';
+import type { IdType } from '../type/id-type.js';
+export declare abstract class AggregateRoot<Id extends EntityId = IdType, Event extends EventBase = EventBase> extends Entity<Id> {
+    private readonly domainEvents;
+    protected record(event: Event): void;
+    pullDomainEvents(): Event[];
+}

package/dist/esm/domain/aggregate/aggregate-root.js

@@ -0,0 +1,13 @@
+import { Entity } from '../entity/entity.js';
+export class AggregateRoot extends Entity {
+    constructor() {
+        super(...arguments);
+        this.domainEvents = [];
+    }
+    record(event) {
+        this.domainEvents.push(event);
+    }
+    pullDomainEvents() {
+        return this.domainEvents.splice(0);
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { AbstractType } from '../type/abstract-type.js';
+import type { IdType } from '../type/id-type.js';
+import type { RequiredMarked } from '../type/required/required-mark.js';
+export type EntityId = AbstractType<any> & RequiredMarked;
+export declare abstract class Entity<Id extends EntityId = IdType> {
+    readonly id: Id;
+    constructor(id: Id);
+    equals(other: unknown): boolean;
+}

package/dist/esm/domain/entity/entity.js

@@ -0,0 +1,15 @@
+import { RequiredValueException } from '../exceptions/required-value.exception.js';
+export class Entity {
+    constructor(id) {
+        this.id = id;
+        if (id?.isNull !== false) {
+            throw new RequiredValueException(`${new.target.name}.id`, id?.value);
+        }
+    }
+    equals(other) {
+        return (typeof other === 'object' &&
+            other !== null &&
+            other.constructor === this.constructor &&
+            this.id.equals(other.id));
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import { CreatedAt } from '../type/date-type.js';
+import { IdType } from '../type/id-type.js';
+import { UuidType } from '../type/uuid-type.js';
+import { InvalidEventDefinitionException } from '../exceptions/invalid-event-definition.exception.js';
+export class EventBase {
+    constructor(metadata = {}) {
+        const { eventName } = this.constructor;
+        if (typeof eventName !== 'string' || eventName.trim() === '') {
+            throw new InvalidEventDefinitionException(this.constructor.name);
+        }
+        this.eventName = eventName;
+        this.eventId = new IdType(metadata.eventId ?? UuidType.random()).value;
+        this.occurredOn = (metadata.occurredOn === undefined
+            ? CreatedAt.now(metadata.clock)
+            : new CreatedAt(metadata.occurredOn)).value.toISOString();
+    }
+}

package/dist/esm/domain/exceptions/domain-exception-code.d.ts

@@ -0,0 +1,7 @@
+export declare enum DomainExceptionCode {
+    DomainException = "DOM000",
+    ValidationFailed = "DOM001",
+    TypeFailed = "DOM003",
+    RequiredValue = "DOM004",
+    InvalidEventDefinition = "DOM005"
+}

package/dist/esm/domain/exceptions/domain-exception-code.js

@@ -0,0 +1,8 @@
+export var DomainExceptionCode;
+(function (DomainExceptionCode) {
+    DomainExceptionCode["DomainException"] = "DOM000";
+    DomainExceptionCode["ValidationFailed"] = "DOM001";
+    DomainExceptionCode["TypeFailed"] = "DOM003";
+    DomainExceptionCode["RequiredValue"] = "DOM004";
+    DomainExceptionCode["InvalidEventDefinition"] = "DOM005";
+})(DomainExceptionCode || (DomainExceptionCode = {}));

package/dist/esm/domain/exceptions/domain.exception.d.ts

@@ -0,0 +1,6 @@
+import { AbstractException } from '../../shared/index.js';
+import type { ExceptionOptions } from '../../shared/index.js';
+import { DomainExceptionCode } from './domain-exception-code.js';
+export declare class DomainException extends AbstractException {
+    constructor(message: string, exceptionCodes?: (DomainExceptionCode | string)[], options?: ExceptionOptions);
+}

package/dist/esm/domain/exceptions/domain.exception.js

@@ -0,0 +1,12 @@
+var _a;
+import { AbstractException, ExceptionBrand } from '../../shared/index.js';
+import { DomainExceptionCode } from './domain-exception-code.js';
+export class DomainException extends AbstractException {
+    constructor(message, exceptionCodes = [], options = {}) {
+        super(message, [DomainExceptionCode.DomainException, ...exceptionCodes], options, DomainExceptionCode);
+    }
+}
+_a = DomainException;
+(() => {
+    ExceptionBrand.brandClass(_a, DomainExceptionCode.DomainException);
+})();

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

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

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

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

package/dist/esm/domain/exceptions/required-value.exception.d.ts

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

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

@@ -0,0 +1,16 @@
+var _a;
+import { ExceptionBrand, ReceivedValue } from '../../shared/index.js';
+import { DomainExceptionCode } from './domain-exception-code.js';
+import { DomainException } from './domain.exception.js';
+export class RequiredValueException extends DomainException {
+    constructor(typeName, receivedValue) {
+        const received = ReceivedValue.describe(receivedValue);
+        super(`Validation Error: ${typeName} is required, but received ${received}.`, [
+            DomainExceptionCode.RequiredValue,
+        ]);
+    }
+}
+_a = RequiredValueException;
+(() => {
+    ExceptionBrand.brandClass(_a, DomainExceptionCode.RequiredValue);
+})();

package/dist/esm/domain/exceptions/type-primitive.exception.d.ts

@@ -0,0 +1,4 @@
+import { DomainException } from './domain.exception.js';
+export declare class TypePrimitiveException extends DomainException {
+    constructor(expectedType: string, receivedValue: unknown, template?: string);
+}

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

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

package/dist/esm/domain/exceptions/validation.exception.d.ts

@@ -0,0 +1,14 @@
+import { DomainException } from './domain.exception.js';
+export interface ValidationIssue {
+    readonly field: string | null;
+    readonly code: string;
+    readonly message: string;
+}
+export type ValidationIssueInput = Omit<ValidationIssue, 'code'> & {
+    readonly code?: string;
+};
+export declare class ValidationException extends DomainException {
+    readonly errors: readonly ValidationIssue[];
+    constructor(errors: readonly ValidationIssueInput[]);
+    private static describe;
+}

package/dist/esm/domain/exceptions/validation.exception.js

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

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

@@ -0,0 +1,17 @@
+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';
+export { DomainException } from './exceptions/domain.exception.js';
+export { ValidationException } from './exceptions/validation.exception.js';
+export type { ValidationIssue, ValidationIssueInput } from './exceptions/validation.exception.js';
+export { TypePrimitiveException } from './exceptions/type-primitive.exception.js';
+export { RequiredValueException } from './exceptions/required-value.exception.js';
+export { InvalidEventDefinitionException } from './exceptions/invalid-event-definition.exception.js';
+export { DomainExceptionCode } from './exceptions/domain-exception-code.js';

package/dist/esm/domain/index.js

@@ -0,0 +1,12 @@
+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';
+export { DomainException } from './exceptions/domain.exception.js';
+export { ValidationException } from './exceptions/validation.exception.js';
+export { TypePrimitiveException } from './exceptions/type-primitive.exception.js';
+export { RequiredValueException } from './exceptions/required-value.exception.js';
+export { InvalidEventDefinitionException } from './exceptions/invalid-event-definition.exception.js';
+export { DomainExceptionCode } from './exceptions/domain-exception-code.js';

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

@@ -0,0 +1,20 @@
+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];
+};
+export type PrimitiveTypes<T> = {
+    [key in keyof Mutable<Properties<T>> as RemoveUnderscore<string & key>]: PrimitiveType<T[key]>;
+};
+export type DataTypes<T> = Partial<PrimitiveTypes<T>>;
+export type PrimitiveType<T> = T extends (infer U)[] ? PrimitiveType<U>[] : T extends AbstractType<any> ? T['value'] : T extends null ? null : T extends Date ? never : T extends object ? PrimitiveTypes<T> : never;
+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,18 @@
+import type { Validatable, ValidationResult } from '@archi-code/validation';
+import type { RequiredMarked } from './required/required-mark.js';
+import type { ValidationIssue } from '../exceptions/validation.exception.js';
+export type ValueOf<T, I> = I extends RequiredMarked ? T : T | null;
+export declare abstract class AbstractType<T, Input = T> implements Validatable<T | null> {
+    protected readonly _value: T | null;
+    static [Symbol.hasInstance](candidate: unknown): boolean;
+    constructor(value?: Input | null);
+    get value(): ValueOf<T, this>;
+    get isNull(): boolean;
+    toString(): string;
+    equals<E extends AbstractType<any>>(other: E): boolean;
+    protected hasSameValue(other: this): boolean;
+    validate(): ValidationResult<ValueOf<T, this>>;
+    protected brokenRules(value: unknown): ValidationIssue[];
+    protected abstract filter(value: unknown): T | null;
+    private runRules;
+}