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

package/dist/cjs/infrastructure/event/in-memory/emitter.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = void 0;
+const index_1 = require("../../../exceptions/index");
+class Emitter {
+    constructor() {
+        this.events = new Map();
+    }
+    on(eventName, listener) {
+        const listeners = this.events.get(eventName) ?? new Set();
+        listeners.add(listener);
+        this.events.set(eventName, listeners);
+        return () => this.off(eventName, listener);
+    }
+    off(eventName, listener) {
+        const listeners = this.events.get(eventName);
+        if (listeners === undefined) {
+            return;
+        }
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+            this.events.delete(eventName);
+        }
+    }
+    async emit(eventName, data) {
+        const listeners = this.listenersOf(eventName);
+        const snapshot = Array.from(listeners);
+        await Emitter.resolved;
+        const results = await Promise.allSettled(snapshot.map(async (listener) => {
+            if (listeners.has(listener)) {
+                await listener(data);
+            }
+        }));
+        const errors = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
+        if (errors.length > 0) {
+            throw new index_1.EventDeliveryException(eventName, errors, snapshot.length);
+        }
+    }
+    async emitSerial(eventName, data) {
+        const listeners = this.listenersOf(eventName);
+        const snapshot = Array.from(listeners);
+        await Emitter.resolved;
+        for (const listener of snapshot) {
+            if (listeners.has(listener)) {
+                await listener(data);
+            }
+        }
+    }
+    listenersOf(eventName) {
+        return this.events.get(eventName) ?? new Set();
+    }
+}
+exports.Emitter = Emitter;
+Emitter.resolved = Promise.resolve();

package/dist/cjs/infrastructure/event/in-memory/in-memory-event-channel.d.ts

@@ -0,0 +1,16 @@
+import type { ChannelHandler, ChannelSubscription, EventChannel } from '../event-channel';
+import type { SerializedEvent } from '../../../domain/index';
+export interface InMemoryEventChannelOptions {
+    readonly delivery?: 'serial' | 'parallel';
+}
+export declare class InMemoryEventChannel implements EventChannel {
+    private readonly emitter;
+    private readonly receivers;
+    private readonly sentEvents;
+    private readonly delivery;
+    constructor({ delivery }?: InMemoryEventChannelOptions);
+    get sent(): readonly SerializedEvent[];
+    send(events: readonly SerializedEvent[]): Promise<void>;
+    receive(eventName: string, consumer: string, handler: ChannelHandler): Promise<ChannelSubscription>;
+    private static frozenCopy;
+}

package/dist/cjs/infrastructure/event/in-memory/in-memory-event-channel.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryEventChannel = void 0;
+const index_1 = require("../../../domain/index");
+const index_2 = require("../../../exceptions/index");
+const emitter_1 = require("./emitter");
+class InMemoryEventChannel {
+    constructor({ delivery = 'serial' } = {}) {
+        this.emitter = new emitter_1.Emitter();
+        this.receivers = new Set();
+        this.sentEvents = [];
+        this.delivery = delivery;
+    }
+    get sent() {
+        return [...this.sentEvents];
+    }
+    async send(events) {
+        for (const event of events) {
+            const copy = InMemoryEventChannel.frozenCopy(event);
+            this.sentEvents.push(copy);
+            if (this.delivery === 'parallel') {
+                await this.emitter.emit(copy.eventName, copy);
+            }
+            else {
+                await this.emitter.emitSerial(copy.eventName, copy);
+            }
+        }
+    }
+    async receive(eventName, consumer, handler) {
+        const receiver = JSON.stringify([eventName, consumer]);
+        if (this.receivers.has(receiver)) {
+            throw new index_2.InfrastructureException(`${consumer} already receives "${eventName}": close its subscription first.`);
+        }
+        this.receivers.add(receiver);
+        const off = this.emitter.on(eventName, (event) => handler(event));
+        let open = true;
+        return {
+            close: async () => {
+                if (open) {
+                    open = false;
+                    off();
+                    this.receivers.delete(receiver);
+                }
+            },
+        };
+    }
+    static frozenCopy(event) {
+        return index_1.Immutable.freeze(JSON.parse(JSON.stringify(event)));
+    }
+}
+exports.InMemoryEventChannel = InMemoryEventChannel;

package/dist/cjs/infrastructure/http/http-error-mapper.d.ts

@@ -0,0 +1,23 @@
+import type { ValidationIssue } from '../../exceptions';
+import type { Logger } from '../../application/index';
+export interface HttpErrorBody {
+    code: string;
+    message: string;
+    errors?: readonly ValidationIssue[];
+}
+export interface HttpError {
+    status: number;
+    body: HttpErrorBody;
+}
+export interface HttpErrorMapperOptions {
+    readonly statusByCode?: Readonly<Record<string, number>>;
+    readonly logger?: Logger;
+}
+export declare class HttpErrorMapper {
+    private readonly statusByCode;
+    private readonly logger;
+    constructor({ statusByCode, logger }?: HttpErrorMapperOptions);
+    map(error: unknown): HttpError;
+    private toHttpError;
+    private static defaultStatus;
+}

package/dist/cjs/infrastructure/http/http-error-mapper.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpErrorMapper = void 0;
+const exceptions_1 = require("../../exceptions");
+const silent_logger_1 = require("../logging/silent-logger");
+const INTERNAL_MESSAGE = 'Internal server error';
+class HttpErrorMapper {
+    constructor({ statusByCode = {}, logger = new silent_logger_1.SilentLogger() } = {}) {
+        this.statusByCode = statusByCode;
+        this.logger = logger;
+    }
+    map(error) {
+        const mapped = this.toHttpError(error);
+        const { status, body } = mapped;
+        if (status >= 500) {
+            this.logger.error('http_request_failed', { status, code: body.code, error });
+        }
+        else {
+            this.logger.debug('http_request_rejected', { status, code: body.code });
+        }
+        return mapped;
+    }
+    toHttpError(error) {
+        if (!(error instanceof exceptions_1.AbstractException)) {
+            return {
+                status: 500,
+                body: { code: exceptions_1.ExceptionCode.ErrorException, message: INTERNAL_MESSAGE },
+            };
+        }
+        const status = Object.prototype.hasOwnProperty.call(this.statusByCode, error.code)
+            ? this.statusByCode[error.code]
+            : HttpErrorMapper.defaultStatus(error);
+        if (status >= 500) {
+            return { status, body: { code: error.code, message: INTERNAL_MESSAGE } };
+        }
+        if (error instanceof exceptions_1.ValidationException) {
+            return { status, body: { code: error.code, message: error.message, errors: error.errors } };
+        }
+        return { status, body: { code: error.code, message: error.message } };
+    }
+    static defaultStatus(error) {
+        if (error instanceof exceptions_1.AggregateNotFoundException) {
+            return 404;
+        }
+        if (error instanceof exceptions_1.NotAllowedException) {
+            return 403;
+        }
+        if (error instanceof exceptions_1.ConcurrencyException) {
+            return 409;
+        }
+        if (error instanceof exceptions_1.TypePrimitiveException || error instanceof exceptions_1.RequiredValueException) {
+            return 400;
+        }
+        if (error instanceof exceptions_1.DomainException) {
+            return 422;
+        }
+        if (error instanceof exceptions_1.ApplicationException) {
+            return 400;
+        }
+        return 500;
+    }
+}
+exports.HttpErrorMapper = HttpErrorMapper;

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

@@ -0,0 +1,16 @@
+export { SystemClock } from './clock/system-clock';
+export { FixedClock } from './clock/fixed-clock';
+export { DomainEventBus } from './event/domain-event-bus';
+export type { Subscription } from './event/domain-event-bus';
+export { EventRegistry } from './event/event-registry';
+export type { EventFactory } from './event/event-registry';
+export type { ChannelHandler, ChannelSubscription, EventChannel } from './event/event-channel';
+export { InMemoryEventChannel } from './event/in-memory/in-memory-event-channel';
+export type { InMemoryEventChannelOptions } from './event/in-memory/in-memory-event-channel';
+export { HttpErrorMapper } from './http/http-error-mapper';
+export type { HttpError, HttpErrorBody, HttpErrorMapperOptions } from './http/http-error-mapper';
+export { ConsoleLogger } from './logging/console-logger';
+export type { ConsoleLoggerOptions } from './logging/console-logger';
+export { InMemoryLogger } from './logging/in-memory-logger';
+export type { LogEntry } from './logging/in-memory-logger';
+export { SilentLogger } from './logging/silent-logger';

package/dist/cjs/infrastructure/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SilentLogger = exports.InMemoryLogger = exports.ConsoleLogger = exports.HttpErrorMapper = exports.InMemoryEventChannel = exports.EventRegistry = exports.DomainEventBus = exports.FixedClock = exports.SystemClock = void 0;
+var system_clock_1 = require("./clock/system-clock");
+Object.defineProperty(exports, "SystemClock", { enumerable: true, get: function () { return system_clock_1.SystemClock; } });
+var fixed_clock_1 = require("./clock/fixed-clock");
+Object.defineProperty(exports, "FixedClock", { enumerable: true, get: function () { return fixed_clock_1.FixedClock; } });
+var domain_event_bus_1 = require("./event/domain-event-bus");
+Object.defineProperty(exports, "DomainEventBus", { enumerable: true, get: function () { return domain_event_bus_1.DomainEventBus; } });
+var event_registry_1 = require("./event/event-registry");
+Object.defineProperty(exports, "EventRegistry", { enumerable: true, get: function () { return event_registry_1.EventRegistry; } });
+var in_memory_event_channel_1 = require("./event/in-memory/in-memory-event-channel");
+Object.defineProperty(exports, "InMemoryEventChannel", { enumerable: true, get: function () { return in_memory_event_channel_1.InMemoryEventChannel; } });
+var http_error_mapper_1 = require("./http/http-error-mapper");
+Object.defineProperty(exports, "HttpErrorMapper", { enumerable: true, get: function () { return http_error_mapper_1.HttpErrorMapper; } });
+var console_logger_1 = require("./logging/console-logger");
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return console_logger_1.ConsoleLogger; } });
+var in_memory_logger_1 = require("./logging/in-memory-logger");
+Object.defineProperty(exports, "InMemoryLogger", { enumerable: true, get: function () { return in_memory_logger_1.InMemoryLogger; } });
+var silent_logger_1 = require("./logging/silent-logger");
+Object.defineProperty(exports, "SilentLogger", { enumerable: true, get: function () { return silent_logger_1.SilentLogger; } });

package/dist/cjs/infrastructure/logging/console-logger.d.ts

@@ -0,0 +1,17 @@
+import type { Clock, LogContext, Logger, LogLevel } from '../../application/index';
+export interface ConsoleLoggerOptions {
+    readonly level?: LogLevel;
+    readonly clock?: Clock;
+}
+export declare class ConsoleLogger implements Logger {
+    private static readonly levels;
+    private readonly output;
+    private readonly minimum;
+    private readonly clock;
+    constructor({ level, clock }?: ConsoleLoggerOptions);
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+    private write;
+}

package/dist/cjs/infrastructure/logging/console-logger.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const index_1 = require("../../exceptions/index");
+const system_clock_1 = require("../clock/system-clock");
+const log_serializer_1 = require("./log-serializer");
+class ConsoleLogger {
+    constructor({ level = 'info', clock = new system_clock_1.SystemClock() } = {}) {
+        this.output = console;
+        this.minimum = ConsoleLogger.levels.indexOf(level);
+        if (this.minimum === -1) {
+            throw new index_1.InternalErrorException(`unknown log level "${String(level)}": use ${ConsoleLogger.levels.join(', ')}`);
+        }
+        this.clock = clock;
+    }
+    debug(message, context) {
+        this.write('debug', message, context);
+    }
+    info(message, context) {
+        this.write('info', message, context);
+    }
+    warn(message, context) {
+        this.write('warn', message, context);
+    }
+    error(message, context) {
+        this.write('error', message, context);
+    }
+    write(level, message, context) {
+        if (ConsoleLogger.levels.indexOf(level) < this.minimum) {
+            return;
+        }
+        const entry = { time: this.clock.now().toISOString(), level, message };
+        this.output[level](log_serializer_1.LogSerializer.line(entry, context));
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+ConsoleLogger.levels = ['debug', 'info', 'warn', 'error'];

package/dist/cjs/infrastructure/logging/in-memory-logger.d.ts

@@ -0,0 +1,15 @@
+import type { LogContext, Logger, LogLevel } from '../../application/index';
+export interface LogEntry {
+    readonly level: LogLevel;
+    readonly message: string;
+    readonly context?: LogContext;
+}
+export declare class InMemoryLogger implements Logger {
+    private readonly recorded;
+    get entries(): readonly LogEntry[];
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+    private record;
+}

package/dist/cjs/infrastructure/logging/in-memory-logger.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryLogger = void 0;
+class InMemoryLogger {
+    constructor() {
+        this.recorded = [];
+    }
+    get entries() {
+        return [...this.recorded];
+    }
+    debug(message, context) {
+        this.record('debug', message, context);
+    }
+    info(message, context) {
+        this.record('info', message, context);
+    }
+    warn(message, context) {
+        this.record('warn', message, context);
+    }
+    error(message, context) {
+        this.record('error', message, context);
+    }
+    record(level, message, context) {
+        this.recorded.push(context === undefined ? { level, message } : { level, message, context });
+    }
+}
+exports.InMemoryLogger = InMemoryLogger;

package/dist/cjs/infrastructure/logging/log-serializer.d.ts

@@ -0,0 +1,7 @@
+import type { LogContext } from '../../application/index';
+export declare class LogSerializer {
+    static line(entry: Readonly<Record<string, string>>, context: LogContext | undefined): string;
+    private static plain;
+    private static plainObject;
+    private static plainError;
+}

package/dist/cjs/infrastructure/logging/log-serializer.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogSerializer = void 0;
+class LogSerializer {
+    static line(entry, context) {
+        if (context === undefined) {
+            return JSON.stringify(entry);
+        }
+        try {
+            return JSON.stringify({ ...entry, context: LogSerializer.plain(context, new Set()) });
+        }
+        catch {
+            return JSON.stringify({ ...entry, context: '[Unserializable]' });
+        }
+    }
+    static plain(value, ancestors) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value !== 'object' || value === null) {
+            return value;
+        }
+        if (ancestors.has(value)) {
+            return '[Circular]';
+        }
+        ancestors.add(value);
+        try {
+            return LogSerializer.plainObject(value, ancestors);
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    }
+    static plainObject(value, ancestors) {
+        if (value instanceof Error) {
+            return LogSerializer.plainError(value, ancestors);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => LogSerializer.plain(item, ancestors));
+        }
+        const { toJSON } = value;
+        if (typeof toJSON === 'function') {
+            return LogSerializer.plain(toJSON.call(value), ancestors);
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, LogSerializer.plain(item, ancestors)]));
+    }
+    static plainError(error, ancestors) {
+        const { code, errors, cause } = error;
+        return {
+            name: error.name,
+            message: error.message,
+            ...(typeof code === 'string' ? { code } : {}),
+            ...(Array.isArray(errors) ? { errors: LogSerializer.plain(errors, ancestors) } : {}),
+            ...(error.stack === undefined ? {} : { stack: error.stack }),
+            ...(cause === undefined ? {} : { cause: LogSerializer.plain(cause, ancestors) }),
+        };
+    }
+}
+exports.LogSerializer = LogSerializer;

package/dist/cjs/infrastructure/logging/silent-logger.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from '../../application/index';
+export declare class SilentLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/dist/cjs/infrastructure/logging/silent-logger.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SilentLogger = void 0;
+class SilentLogger {
+    debug() {
+        return undefined;
+    }
+    info() {
+        return undefined;
+    }
+    warn() {
+        return undefined;
+    }
+    error() {
+        return undefined;
+    }
+}
+exports.SilentLogger = SilentLogger;

package/dist/esm/application/event/event-bus.d.ts

@@ -0,0 +1,4 @@
+import type { EventBase } from '../../domain/index.js';
+export interface EventBus<Event extends EventBase = EventBase> {
+    publish(events: readonly Event[]): Promise<void>;
+}

package/dist/esm/application/event/event-bus.js

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

package/dist/esm/application/event/event-listener.d.ts

@@ -0,0 +1,4 @@
+import type { EventBase } from '../../domain/index.js';
+export declare abstract class EventListener<Event extends EventBase = EventBase> {
+    abstract handle(event: Event): Promise<void> | void;
+}

package/dist/esm/application/event/event-listener.js

@@ -0,0 +1,2 @@
+export class EventListener {
+}

package/dist/esm/application/event/listens-to.d.ts

@@ -0,0 +1,15 @@
+import type { EventBase, EventClass } from '../../domain/index.js';
+import type { EventListener } from './event-listener.js';
+type ListenerClass<Event extends EventBase> = abstract new (...args: any[]) => EventListener<Event>;
+export interface ListensToOptions {
+    readonly consumer: string;
+}
+export interface ListenerSubscription {
+    readonly eventName: string;
+    readonly consumer: string;
+}
+export declare function ListensTo<Event extends EventBase>(event: EventClass<Event>, options: ListensToOptions): (listener: ListenerClass<Event>) => void;
+export declare namespace ListensTo {
+    var subscriptionOf: (listener: EventListener<any>) => ListenerSubscription;
+}
+export {};

package/dist/esm/application/event/listens-to.js

@@ -0,0 +1,25 @@
+import { ApplicationException } from '../../exceptions/index.js';
+const LISTENED_EVENT = Symbol.for('@archi-code/ddd/listens-to.v1');
+export function ListensTo(event, options) {
+    return (listener) => {
+        if (Object.prototype.hasOwnProperty.call(listener, LISTENED_EVENT)) {
+            throw new ApplicationException(`${listener.name} already listens to an event`);
+        }
+        const consumer = options?.consumer;
+        if (typeof consumer !== 'string' || consumer.trim() === '') {
+            throw new ApplicationException(`${listener.name} needs a consumer name: @ListensTo(<event class>, { consumer: '<name>' })`);
+        }
+        const subscription = Object.freeze({
+            eventName: event.eventName,
+            consumer,
+        });
+        Object.defineProperty(listener, LISTENED_EVENT, { value: subscription });
+    };
+}
+ListensTo.subscriptionOf = (listener) => {
+    const listenerClass = listener.constructor;
+    if (!Object.prototype.hasOwnProperty.call(listenerClass, LISTENED_EVENT)) {
+        throw new ApplicationException(`${listenerClass.name} needs @ListensTo(<event class>, { consumer: '<name>' })`);
+    }
+    return listenerClass[LISTENED_EVENT];
+};

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

@@ -0,0 +1,7 @@
+export { UseCase } from './use-case/use-case.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';

package/dist/esm/application/index.js

@@ -0,0 +1,3 @@
+export { UseCase } from './use-case/use-case.js';
+export { EventListener } from './event/event-listener.js';
+export { ListensTo } from './event/listens-to.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,20 @@
+import { anyToString } from '@archi-code/validation';
+import { AbstractException, InternalErrorException } from '../../exceptions/index.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 InternalErrorException(`${this.constructor.name}: ${UseCase.describe(error)}`, {
+                cause: error,
+            });
+        }
+    }
+    static describe(error) {
+        return error instanceof Error ? error.message : anyToString(error);
+    }
+}

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

@@ -0,0 +1,14 @@
+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;
+    private persistedVersion;
+    constructor(id: Id);
+    get version(): number;
+    protected record(event: Event): void;
+    pullDomainEvents(): Event[];
+    restoreVersion(version: number): this;
+    markPersisted(): void;
+}

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

@@ -0,0 +1,29 @@
+import { Entity } from '../entity/entity.js';
+import { Immutable } from '../type/immutable/immutable.js';
+import { InternalErrorException } from '../../exceptions/index.js';
+export class AggregateRoot extends Entity {
+    constructor(id) {
+        super(id);
+        Object.defineProperty(this, 'domainEvents', { value: [] });
+        Object.defineProperty(this, 'persistedVersion', { value: 0, writable: true });
+    }
+    get version() {
+        return this.persistedVersion;
+    }
+    record(event) {
+        this.domainEvents.push(Immutable.freeze(event));
+    }
+    pullDomainEvents() {
+        return this.domainEvents.splice(0);
+    }
+    restoreVersion(version) {
+        if (!Number.isSafeInteger(version) || version < 0) {
+            throw new InternalErrorException(`${this.constructor.name} cannot be restored with version ${String(version)}`);
+        }
+        this.persistedVersion = version;
+        return this;
+    }
+    markPersisted() {
+        this.persistedVersion += 1;
+    }
+}

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/index.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));
+    }
+}