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

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

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

package/dist/cjs/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/cjs/application/use-case/use-case.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseCase = void 0;
+const validation_1 = require("@archi-code/validation");
+const index_1 = require("../../shared/index");
+const unexpected_error_exception_1 = require("../exceptions/unexpected-error.exception");
+class UseCase {
+    async execute(input) {
+        try {
+            return await this.handle(this.toCommand(input));
+        }
+        catch (error) {
+            if (error instanceof index_1.AbstractException) {
+                throw error;
+            }
+            throw new unexpected_error_exception_1.UnexpectedErrorException(`${this.constructor.name}: ${UseCase.describe(error)}`, {
+                cause: error,
+            });
+        }
+    }
+    static describe(error) {
+        return error instanceof Error ? error.message : (0, validation_1.anyToString)(error);
+    }
+}
+exports.UseCase = UseCase;

package/dist/cjs/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/cjs/application/value-object-builder/value-object-builder.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObjectBuilder = void 0;
+const index_1 = require("../../domain/index");
+const index_2 = require("../../shared/index");
+const unexpected_error_exception_1 = require("../exceptions/unexpected-error.exception");
+class ValueObjectBuilder {
+    static build(factories) {
+        const builds = Object.fromEntries(Object.entries(factories).map(([field, factory]) => [
+            field,
+            () => ValueObjectBuilder.synchronous(field, factory()),
+        ]));
+        return ValueObjectBuilder.validated(() => index_2.IssueCollector.collectFields(builds, ValueObjectBuilder.read));
+    }
+    static buildList(values, factory) {
+        return ValueObjectBuilder.validated(() => index_2.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 unexpected_error_exception_1.UnexpectedErrorException(`ValueObjectBuilder: the factory of "${field}" returned a Promise; build value objects synchronously`);
+    }
+    static validated(collect) {
+        try {
+            return collect();
+        }
+        catch (error) {
+            if (error instanceof index_2.IssueCollectionError) {
+                throw new index_1.ValidationException(error.issues);
+            }
+            throw error;
+        }
+    }
+    static read(error) {
+        if (error instanceof index_1.ValidationException) {
+            return error.errors;
+        }
+        if (error instanceof index_1.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');
+    }
+}
+exports.ValueObjectBuilder = ValueObjectBuilder;

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

@@ -0,0 +1,9 @@
+import { Entity } from '../entity/entity';
+import type { EntityId } from '../entity/entity';
+import type { EventBase } from '../event/event-base';
+import type { IdType } from '../type/id-type';
+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/cjs/domain/aggregate/aggregate-root.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateRoot = void 0;
+const entity_1 = require("../entity/entity");
+class AggregateRoot extends entity_1.Entity {
+    constructor() {
+        super(...arguments);
+        this.domainEvents = [];
+    }
+    record(event) {
+        this.domainEvents.push(event);
+    }
+    pullDomainEvents() {
+        return this.domainEvents.splice(0);
+    }
+}
+exports.AggregateRoot = AggregateRoot;

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

@@ -0,0 +1,9 @@
+import type { AbstractType } from '../type/abstract-type';
+import type { IdType } from '../type/id-type';
+import type { RequiredMarked } from '../type/required/required-mark';
+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/cjs/domain/entity/entity.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const required_value_exception_1 = require("../exceptions/required-value.exception");
+class Entity {
+    constructor(id) {
+        this.id = id;
+        if (id?.isNull !== false) {
+            throw new required_value_exception_1.RequiredValueException(`${new.target.name}.id`, id?.value);
+        }
+    }
+    equals(other) {
+        return (typeof other === 'object' &&
+            other !== null &&
+            other.constructor === this.constructor &&
+            this.id.equals(other.id));
+    }
+}
+exports.Entity = Entity;

package/dist/cjs/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/cjs/domain/event/event-base.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBase = void 0;
+const date_type_1 = require("../type/date-type");
+const id_type_1 = require("../type/id-type");
+const uuid_type_1 = require("../type/uuid-type");
+const invalid_event_definition_exception_1 = require("../exceptions/invalid-event-definition.exception");
+class EventBase {
+    constructor(metadata = {}) {
+        const { eventName } = this.constructor;
+        if (typeof eventName !== 'string' || eventName.trim() === '') {
+            throw new invalid_event_definition_exception_1.InvalidEventDefinitionException(this.constructor.name);
+        }
+        this.eventName = eventName;
+        this.eventId = new id_type_1.IdType(metadata.eventId ?? uuid_type_1.UuidType.random()).value;
+        this.occurredOn = (metadata.occurredOn === undefined
+            ? date_type_1.CreatedAt.now(metadata.clock)
+            : new date_type_1.CreatedAt(metadata.occurredOn)).value.toISOString();
+    }
+}
+exports.EventBase = EventBase;

package/dist/cjs/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/cjs/domain/exceptions/domain-exception-code.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainExceptionCode = void 0;
+var DomainExceptionCode;
+(function (DomainExceptionCode) {
+    DomainExceptionCode["DomainException"] = "DOM000";
+    DomainExceptionCode["ValidationFailed"] = "DOM001";
+    DomainExceptionCode["TypeFailed"] = "DOM003";
+    DomainExceptionCode["RequiredValue"] = "DOM004";
+    DomainExceptionCode["InvalidEventDefinition"] = "DOM005";
+})(DomainExceptionCode || (exports.DomainExceptionCode = DomainExceptionCode = {}));

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainException = void 0;
+const index_1 = require("../../shared/index");
+const domain_exception_code_1 = require("./domain-exception-code");
+class DomainException extends index_1.AbstractException {
+    constructor(message, exceptionCodes = [], options = {}) {
+        super(message, [domain_exception_code_1.DomainExceptionCode.DomainException, ...exceptionCodes], options, domain_exception_code_1.DomainExceptionCode);
+    }
+}
+exports.DomainException = DomainException;
+_a = DomainException;
+(() => {
+    index_1.ExceptionBrand.brandClass(_a, domain_exception_code_1.DomainExceptionCode.DomainException);
+})();

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidEventDefinitionException = void 0;
+const index_1 = require("../../shared/index");
+const domain_exception_code_1 = require("./domain-exception-code");
+const domain_exception_1 = require("./domain.exception");
+class InvalidEventDefinitionException extends domain_exception_1.DomainException {
+    constructor(eventClassName) {
+        super(`${eventClassName} must declare a static eventName`, [
+            domain_exception_code_1.DomainExceptionCode.InvalidEventDefinition,
+        ]);
+    }
+}
+exports.InvalidEventDefinitionException = InvalidEventDefinitionException;
+_a = InvalidEventDefinitionException;
+(() => {
+    index_1.ExceptionBrand.brandClass(_a, domain_exception_code_1.DomainExceptionCode.InvalidEventDefinition);
+})();

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredValueException = void 0;
+const index_1 = require("../../shared/index");
+const domain_exception_code_1 = require("./domain-exception-code");
+const domain_exception_1 = require("./domain.exception");
+class RequiredValueException extends domain_exception_1.DomainException {
+    constructor(typeName, receivedValue) {
+        const received = index_1.ReceivedValue.describe(receivedValue);
+        super(`Validation Error: ${typeName} is required, but received ${received}.`, [
+            domain_exception_code_1.DomainExceptionCode.RequiredValue,
+        ]);
+    }
+}
+exports.RequiredValueException = RequiredValueException;
+_a = RequiredValueException;
+(() => {
+    index_1.ExceptionBrand.brandClass(_a, domain_exception_code_1.DomainExceptionCode.RequiredValue);
+})();

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypePrimitiveException = void 0;
+const index_1 = require("../../shared/index");
+const domain_exception_code_1 = require("./domain-exception-code");
+const domain_exception_1 = require("./domain.exception");
+class TypePrimitiveException extends domain_exception_1.DomainException {
+    constructor(expectedType, receivedValue, template = 'Expected a valid ') {
+        const received = index_1.ReceivedValue.describe(receivedValue);
+        super(`Validation Error: ${template}${expectedType}, but received ${received}.`, [
+            domain_exception_code_1.DomainExceptionCode.TypeFailed,
+        ]);
+    }
+}
+exports.TypePrimitiveException = TypePrimitiveException;
+_a = TypePrimitiveException;
+(() => {
+    index_1.ExceptionBrand.brandClass(_a, domain_exception_code_1.DomainExceptionCode.TypeFailed);
+})();

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

@@ -0,0 +1,14 @@
+import { DomainException } from './domain.exception';
+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/cjs/domain/exceptions/validation.exception.js

@@ -0,0 +1,23 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationException = void 0;
+const index_1 = require("../../shared/index");
+const domain_exception_code_1 = require("./domain-exception-code");
+const domain_exception_1 = require("./domain.exception");
+class ValidationException extends domain_exception_1.DomainException {
+    constructor(errors) {
+        super(`Validation failed, ${errors.map(_a.describe).join(', ')}`, [
+            domain_exception_code_1.DomainExceptionCode.ValidationFailed,
+        ]);
+        this.errors = Object.freeze(errors.map(({ field, code = domain_exception_code_1.DomainExceptionCode.ValidationFailed, message }) => Object.freeze({ field, code, message })));
+    }
+    static describe(issue) {
+        return issue.field === null ? issue.message : `${issue.field}: ${issue.message}`;
+    }
+}
+exports.ValidationException = ValidationException;
+_a = ValidationException;
+(() => {
+    index_1.ExceptionBrand.brandClass(_a, domain_exception_code_1.DomainExceptionCode.ValidationFailed);
+})();

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

@@ -0,0 +1,17 @@
+export * from './event/event-base';
+export * from './entity/entity';
+export * from './aggregate/aggregate-root';
+export * from './type/index';
+export * from './primitive/primitive-types';
+export type { AggregateFinder } from './repository/aggregate-finder';
+export type { AggregateSaver } from './repository/aggregate-saver';
+export type { AggregateRemover } from './repository/aggregate-remover';
+export { Specification } from './specification/specification';
+export type { SatisfiedBy } from './specification/specification';
+export { DomainException } from './exceptions/domain.exception';
+export { ValidationException } from './exceptions/validation.exception';
+export type { ValidationIssue, ValidationIssueInput } from './exceptions/validation.exception';
+export { TypePrimitiveException } from './exceptions/type-primitive.exception';
+export { RequiredValueException } from './exceptions/required-value.exception';
+export { InvalidEventDefinitionException } from './exceptions/invalid-event-definition.exception';
+export { DomainExceptionCode } from './exceptions/domain-exception-code';

package/dist/cjs/domain/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainExceptionCode = exports.InvalidEventDefinitionException = exports.RequiredValueException = exports.TypePrimitiveException = exports.ValidationException = exports.DomainException = exports.Specification = void 0;
+__exportStar(require("./event/event-base"), exports);
+__exportStar(require("./entity/entity"), exports);
+__exportStar(require("./aggregate/aggregate-root"), exports);
+__exportStar(require("./type/index"), exports);
+__exportStar(require("./primitive/primitive-types"), exports);
+var specification_1 = require("./specification/specification");
+Object.defineProperty(exports, "Specification", { enumerable: true, get: function () { return specification_1.Specification; } });
+var domain_exception_1 = require("./exceptions/domain.exception");
+Object.defineProperty(exports, "DomainException", { enumerable: true, get: function () { return domain_exception_1.DomainException; } });
+var validation_exception_1 = require("./exceptions/validation.exception");
+Object.defineProperty(exports, "ValidationException", { enumerable: true, get: function () { return validation_exception_1.ValidationException; } });
+var type_primitive_exception_1 = require("./exceptions/type-primitive.exception");
+Object.defineProperty(exports, "TypePrimitiveException", { enumerable: true, get: function () { return type_primitive_exception_1.TypePrimitiveException; } });
+var required_value_exception_1 = require("./exceptions/required-value.exception");
+Object.defineProperty(exports, "RequiredValueException", { enumerable: true, get: function () { return required_value_exception_1.RequiredValueException; } });
+var invalid_event_definition_exception_1 = require("./exceptions/invalid-event-definition.exception");
+Object.defineProperty(exports, "InvalidEventDefinitionException", { enumerable: true, get: function () { return invalid_event_definition_exception_1.InvalidEventDefinitionException; } });
+var domain_exception_code_1 = require("./exceptions/domain-exception-code");
+Object.defineProperty(exports, "DomainExceptionCode", { enumerable: true, get: function () { return domain_exception_code_1.DomainExceptionCode; } });

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

@@ -0,0 +1,20 @@
+import type { AbstractType } from '../type/abstract-type';
+export type Methods<T> = {
+    [P in keyof T]-?: T[P] extends Function ? P : never;
+}[keyof T];
+export type MethodsAndProperties<T> = {
+    [key in keyof T]: T[key];
+};
+export type Properties<T> = Omit<MethodsAndProperties<T>, Methods<T>>;
+export type MutablePropertiesData<T> = Mutable<Required<Properties<T>>>;
+export type PropertiesData<T> = Required<Properties<T>>;
+type RemoveUnderscore<S extends string> = S extends `_${infer R}` ? R : S;
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+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/cjs/domain/primitive/primitive-types.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+import type { Validatable, ValidationResult } from '@archi-code/validation';
+import type { RequiredMarked } from './required/required-mark';
+import type { ValidationIssue } from '../exceptions/validation.exception';
+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;
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractType = void 0;
+const validation_1 = require("@archi-code/validation");
+const required_mark_1 = require("./required/required-mark");
+const required_value_exception_1 = require("../exceptions/required-value.exception");
+const validation_exception_1 = require("../exceptions/validation.exception");
+const VALUE_OBJECT = Symbol.for('@archi-code/ddd/value-object.v1');
+class AbstractType {
+    static [Symbol.hasInstance](candidate) {
+        return (Function.prototype[Symbol.hasInstance].call(this, candidate) ||
+            (this === _a &&
+                typeof candidate === 'object' &&
+                candidate !== null &&
+                candidate[VALUE_OBJECT] === true));
+    }
+    constructor(value = null) {
+        this._value = value === null || value === undefined ? null : this.filter(value);
+        if (this._value === null && required_mark_1.RequiredMark.isMarked(this)) {
+            throw new required_value_exception_1.RequiredValueException(this.constructor.name, value);
+        }
+        const brokenRules = this.brokenRules(this._value);
+        if (brokenRules.length > 0) {
+            throw new validation_exception_1.ValidationException(brokenRules);
+        }
+    }
+    get value() {
+        return this._value;
+    }
+    get isNull() {
+        return this._value === null;
+    }
+    toString() {
+        return this.isNull ? '' : (0, validation_1.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 (0, validation_1.runValidations)(this.constructor, value);
+    }
+}
+exports.AbstractType = AbstractType;
+_a = AbstractType;
+(() => {
+    Object.defineProperty(_a.prototype, VALUE_OBJECT, { value: true });
+})();