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

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

@@ -0,0 +1,17 @@
+var _a;
+import { DomainException } from './domain.exception.js';
+import { ExceptionBrand } from '../brand/exception-brand.js';
+import { ExceptionCode } from '../exception-code.js';
+import { ReceivedValue } from '../received/received-value.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}.`, [
+            ExceptionCode.TypeFailed,
+        ]);
+    }
+}
+_a = TypePrimitiveException;
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionCode.TypeFailed);
+})();

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

@@ -0,0 +1,19 @@
+var _a;
+import { DomainException } from './domain.exception.js';
+import { ExceptionBrand } from '../brand/exception-brand.js';
+import { ExceptionCode } from '../exception-code.js';
+export class ValidationException extends DomainException {
+    constructor(errors) {
+        super(`Validation failed, ${errors.map(_a.describe).join(', ')}`, [
+            ExceptionCode.ValidationFailed,
+        ]);
+        this.errors = Object.freeze(errors.map(({ field, code = ExceptionCode.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, ExceptionCode.ValidationFailed);
+})();

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

@@ -0,0 +1,15 @@
+export declare enum ExceptionCode {
+    DomainException = "DOM000",
+    ValidationFailed = "DOM001",
+    TypeFailed = "DOM003",
+    RequiredValue = "DOM004",
+    ApplicationException = "APP000",
+    ConcurrencyConflict = "APP001",
+    AggregateNotFound = "APP002",
+    NotAllowed = "APP003",
+    InfrastructureException = "INF000",
+    InternalError = "INF001",
+    UnknownEvent = "INF002",
+    EventDelivery = "INF003",
+    ErrorException = "E000"
+}

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

@@ -0,0 +1,16 @@
+export var ExceptionCode;
+(function (ExceptionCode) {
+    ExceptionCode["DomainException"] = "DOM000";
+    ExceptionCode["ValidationFailed"] = "DOM001";
+    ExceptionCode["TypeFailed"] = "DOM003";
+    ExceptionCode["RequiredValue"] = "DOM004";
+    ExceptionCode["ApplicationException"] = "APP000";
+    ExceptionCode["ConcurrencyConflict"] = "APP001";
+    ExceptionCode["AggregateNotFound"] = "APP002";
+    ExceptionCode["NotAllowed"] = "APP003";
+    ExceptionCode["InfrastructureException"] = "INF000";
+    ExceptionCode["InternalError"] = "INF001";
+    ExceptionCode["UnknownEvent"] = "INF002";
+    ExceptionCode["EventDelivery"] = "INF003";
+    ExceptionCode["ErrorException"] = "E000";
+})(ExceptionCode || (ExceptionCode = {}));

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

@@ -0,0 +1,14 @@
+export * from './abstract.exception.js';
+export * from './exception-code.js';
+export * from './application/application.exception.js';
+export * from './application/concurrency.exception.js';
+export * from './application/aggregate-not-found.exception.js';
+export * from './application/not-allowed.exception.js';
+export * from './infrastructure/infrastructure.exception.js';
+export * from './infrastructure/internal-error.exception.js';
+export * from './infrastructure/unknown-event.exception.js';
+export * from './infrastructure/event-delivery.exception.js';
+export * from './domain/validation.exception.js';
+export * from './domain/domain.exception.js';
+export * from './domain/required-value.exception.js';
+export * from './domain/type-primitive.exception.js';

package/dist/esm/exceptions/index.js

@@ -0,0 +1,14 @@
+export * from './abstract.exception.js';
+export * from './exception-code.js';
+export * from './application/application.exception.js';
+export * from './application/concurrency.exception.js';
+export * from './application/aggregate-not-found.exception.js';
+export * from './application/not-allowed.exception.js';
+export * from './infrastructure/infrastructure.exception.js';
+export * from './infrastructure/internal-error.exception.js';
+export * from './infrastructure/unknown-event.exception.js';
+export * from './infrastructure/event-delivery.exception.js';
+export * from './domain/validation.exception.js';
+export * from './domain/domain.exception.js';
+export * from './domain/required-value.exception.js';
+export * from './domain/type-primitive.exception.js';

package/dist/esm/exceptions/infrastructure/event-delivery.exception.d.ts

@@ -0,0 +1,5 @@
+import { InfrastructureException } from './infrastructure.exception.js';
+export declare class EventDeliveryException extends InfrastructureException {
+    readonly errors: readonly unknown[];
+    constructor(eventName: string, errors: readonly unknown[], consumers: number);
+}

package/dist/esm/exceptions/infrastructure/event-delivery.exception.js

@@ -0,0 +1,16 @@
+var _a;
+import { InfrastructureException } from './infrastructure.exception.js';
+import { ExceptionBrand } from '../brand/exception-brand.js';
+import { ExceptionCode } from '../exception-code.js';
+export class EventDeliveryException extends InfrastructureException {
+    constructor(eventName, errors, consumers) {
+        super(`${errors.length} of ${consumers} consumers of "${eventName}" failed.`, [
+            ExceptionCode.EventDelivery,
+        ]);
+        this.errors = Object.freeze([...errors]);
+    }
+}
+_a = EventDeliveryException;
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionCode.EventDelivery);
+})();

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

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

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

@@ -0,0 +1,13 @@
+var _a;
+import { AbstractException } from '../abstract.exception.js';
+import { ExceptionBrand } from '../brand/exception-brand.js';
+import { ExceptionCode } from '../exception-code.js';
+export class InfrastructureException extends AbstractException {
+    constructor(message, exceptionCodes = [], options = {}) {
+        super(message, [ExceptionCode.InfrastructureException, ...exceptionCodes], options);
+    }
+}
+_a = InfrastructureException;
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionCode.InfrastructureException);
+})();

package/dist/esm/exceptions/infrastructure/internal-error.exception.d.ts

@@ -0,0 +1,5 @@
+import { InfrastructureException } from './infrastructure.exception.js';
+import type { ExceptionOptions } from '../abstract.exception.js';
+export declare class InternalErrorException extends InfrastructureException {
+    constructor(message: string, options?: ExceptionOptions);
+}

package/dist/esm/exceptions/infrastructure/internal-error.exception.js

@@ -0,0 +1,13 @@
+var _a;
+import { InfrastructureException } from './infrastructure.exception.js';
+import { ExceptionBrand } from '../brand/exception-brand.js';
+import { ExceptionCode } from '../exception-code.js';
+export class InternalErrorException extends InfrastructureException {
+    constructor(message, options = {}) {
+        super(`Failed, internal error: ${message}`, [ExceptionCode.InternalError], options);
+    }
+}
+_a = InternalErrorException;
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionCode.InternalError);
+})();

package/dist/esm/exceptions/infrastructure/unknown-event.exception.d.ts

@@ -0,0 +1,4 @@
+import { InfrastructureException } from './infrastructure.exception.js';
+export declare class UnknownEventException extends InfrastructureException {
+    constructor(eventName: string);
+}

package/dist/esm/exceptions/infrastructure/unknown-event.exception.js

@@ -0,0 +1,15 @@
+var _a;
+import { InfrastructureException } from './infrastructure.exception.js';
+import { ExceptionBrand } from '../brand/exception-brand.js';
+import { ExceptionCode } from '../exception-code.js';
+export class UnknownEventException extends InfrastructureException {
+    constructor(eventName) {
+        super(`Unknown event "${eventName}": register it before reading it.`, [
+            ExceptionCode.UnknownEvent,
+        ]);
+    }
+}
+_a = UnknownEventException;
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionCode.UnknownEvent);
+})();

package/dist/esm/exceptions/received/received-value.d.ts

@@ -0,0 +1,4 @@
+export declare class ReceivedValue {
+    static readonly maxLength = 64;
+    static describe(value: unknown): string;
+}

package/dist/esm/exceptions/received/received-value.js

@@ -0,0 +1,9 @@
+import { anyToString } from '@archi-code/validation';
+export class ReceivedValue {
+    static describe(value) {
+        const text = typeof value === 'string' ? value : anyToString(value);
+        const shown = text.length > ReceivedValue.maxLength ? `${text.slice(0, ReceivedValue.maxLength)}…` : text;
+        return typeof value === 'string' ? `"${shown}"` : shown;
+    }
+}
+ReceivedValue.maxLength = 64;

package/dist/esm/infrastructure/clock/fixed-clock.d.ts

@@ -0,0 +1,8 @@
+import type { Clock } from '../../application/index.js';
+export declare class FixedClock implements Clock {
+    private current;
+    constructor(at: Date | string);
+    now(): Date;
+    set(at: Date | string): void;
+    advance(milliseconds: number): void;
+}

package/dist/esm/infrastructure/clock/fixed-clock.js

@@ -0,0 +1,15 @@
+import { CreatedAt } from '../../domain/index.js';
+export class FixedClock {
+    constructor(at) {
+        this.current = new CreatedAt(at).value;
+    }
+    now() {
+        return new Date(this.current.getTime());
+    }
+    set(at) {
+        this.current = new CreatedAt(at).value;
+    }
+    advance(milliseconds) {
+        this.current = new CreatedAt(new Date(this.current.getTime() + milliseconds)).value;
+    }
+}

package/dist/esm/infrastructure/clock/system-clock.d.ts

@@ -0,0 +1,4 @@
+import type { Clock } from '../../application/index.js';
+export declare class SystemClock implements Clock {
+    now(): Date;
+}

package/dist/esm/infrastructure/clock/system-clock.js

@@ -0,0 +1,5 @@
+export class SystemClock {
+    now() {
+        return new Date();
+    }
+}

package/dist/esm/infrastructure/event/domain-event-bus.d.ts

@@ -0,0 +1,16 @@
+import type { EventBase } from '../../domain/index.js';
+import type { EventBus, EventListener, Logger } from '../../application/index.js';
+import type { EventChannel } from './event-channel.js';
+import type { EventRegistry } from './event-registry.js';
+export interface Subscription {
+    unsubscribe(): Promise<void>;
+}
+export declare class DomainEventBus<Event extends EventBase = EventBase> implements EventBus<Event> {
+    private readonly channel;
+    private readonly registry;
+    private readonly logger;
+    constructor(channel: EventChannel, registry: EventRegistry<Event>, logger?: Logger);
+    publish(events: readonly Event[]): Promise<void>;
+    subscribe(listener: EventListener<Event>): Promise<Subscription>;
+    private deliver;
+}

package/dist/esm/infrastructure/event/domain-event-bus.js

@@ -0,0 +1,56 @@
+import { ApplicationException, DomainException, UnknownEventException, } from '../../exceptions/index.js';
+import { ListensTo } from '../../application/index.js';
+import { SilentLogger } from '../logging/silent-logger.js';
+export class DomainEventBus {
+    constructor(channel, registry, logger = new SilentLogger()) {
+        this.channel = channel;
+        this.registry = registry;
+        this.logger = logger;
+    }
+    async publish(events) {
+        await this.channel.send(events.map((event) => event.toJSON()));
+        this.logger.debug('domain_events_published', {
+            events: events.map((event) => ({
+                eventName: event.eventName(),
+                eventId: event.eventId,
+                aggregateId: event.aggregateId,
+            })),
+        });
+    }
+    async subscribe(listener) {
+        const subscription = ListensTo.subscriptionOf(listener);
+        const { eventName, consumer } = subscription;
+        if (!this.registry.has(eventName)) {
+            throw new UnknownEventException(eventName);
+        }
+        const channelSubscription = await this.channel.receive(eventName, consumer, (serialized) => this.deliver(listener, subscription, serialized));
+        this.logger.info('event_listener_subscribed', { eventName, consumer });
+        return {
+            unsubscribe: async () => {
+                await channelSubscription.close();
+                this.logger.info('event_listener_unsubscribed', { eventName, consumer });
+            },
+        };
+    }
+    async deliver(listener, { eventName, consumer }, serialized) {
+        try {
+            await listener.handle(this.registry.fromJSON(serialized));
+        }
+        catch (error) {
+            const context = {
+                eventName,
+                consumer,
+                eventId: serialized.eventId,
+                aggregateId: serialized.aggregateId,
+                error,
+            };
+            if (error instanceof DomainException || error instanceof ApplicationException) {
+                this.logger.warn('event_listener_rejected', context);
+            }
+            else {
+                this.logger.error('event_listener_failed', context);
+            }
+            throw error;
+        }
+    }
+}

package/dist/esm/infrastructure/event/event-channel.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedEvent } from '../../domain/index.js';
+export type ChannelHandler = (event: SerializedEvent) => Promise<void>;
+export interface ChannelSubscription {
+    close(): Promise<void>;
+}
+export interface EventChannel {
+    send(events: readonly SerializedEvent[]): Promise<void>;
+    receive(eventName: string, consumer: string, handler: ChannelHandler): Promise<ChannelSubscription>;
+}

package/dist/esm/infrastructure/event/event-channel.js

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

package/dist/esm/infrastructure/event/event-registry.d.ts

@@ -0,0 +1,9 @@
+import type { EventBase, EventClass, SerializedEvent } from '../../domain/index.js';
+export type EventFactory<Event extends EventBase> = (serialized: SerializedEvent) => Event;
+export declare class EventRegistry<Event extends EventBase = EventBase> {
+    private readonly factories;
+    register<Registered extends Event>(event: EventClass<Registered>, factory: EventFactory<Registered>): this;
+    has(eventName: string): boolean;
+    fromJSON(event: SerializedEvent): Event;
+    private static assertSameIdentity;
+}

package/dist/esm/infrastructure/event/event-registry.js

@@ -0,0 +1,39 @@
+import { InternalErrorException, UnknownEventException } from '../../exceptions/index.js';
+import { Immutable } from '../../domain/index.js';
+export class EventRegistry {
+    constructor() {
+        this.factories = new Map();
+    }
+    register(event, factory) {
+        const { eventName } = event;
+        if (this.factories.has(eventName)) {
+            throw new InternalErrorException(`event "${eventName}" is already registered`);
+        }
+        this.factories.set(eventName, factory);
+        return this;
+    }
+    has(eventName) {
+        return this.factories.has(eventName);
+    }
+    fromJSON(event) {
+        if (typeof event !== 'object' || event === null) {
+            throw new InternalErrorException('a serialized event must be a JSON object');
+        }
+        if (typeof event.eventName !== 'string') {
+            throw new InternalErrorException('a serialized event needs its eventName');
+        }
+        const factory = this.factories.get(event.eventName);
+        if (factory === undefined) {
+            throw new UnknownEventException(event.eventName);
+        }
+        const rebuilt = factory(event);
+        EventRegistry.assertSameIdentity(event, rebuilt);
+        return Immutable.freeze(rebuilt);
+    }
+    static assertSameIdentity(serialized, rebuilt) {
+        if (rebuilt.eventId !== String(serialized.eventId).toLowerCase() ||
+            rebuilt.occurredOn.getTime() !== new Date(serialized.occurredOn).getTime()) {
+            throw new InternalErrorException(`the factory of "${serialized.eventName}" must pass the serialized event as metadata, so it keeps its eventId and occurredOn`);
+        }
+    }
+}

package/dist/esm/infrastructure/event/in-memory/emitter.d.ts

@@ -0,0 +1,11 @@
+type EmitterListener<Data> = (data: Data) => Promise<void> | void;
+export declare class Emitter<Data> {
+    private static readonly resolved;
+    private readonly events;
+    on(eventName: string, listener: EmitterListener<Data>): () => void;
+    private off;
+    emit(eventName: string, data: Data): Promise<void>;
+    emitSerial(eventName: string, data: Data): Promise<void>;
+    private listenersOf;
+}
+export {};

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

@@ -0,0 +1,50 @@
+import { EventDeliveryException } from '../../../exceptions/index.js';
+export 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 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();
+    }
+}
+Emitter.resolved = Promise.resolve();

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

@@ -0,0 +1,16 @@
+import type { ChannelHandler, ChannelSubscription, EventChannel } from '../event-channel.js';
+import type { SerializedEvent } from '../../../domain/index.js';
+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/esm/infrastructure/event/in-memory/in-memory-event-channel.js

@@ -0,0 +1,47 @@
+import { Immutable } from '../../../domain/index.js';
+import { InfrastructureException } from '../../../exceptions/index.js';
+import { Emitter } from './emitter.js';
+export class InMemoryEventChannel {
+    constructor({ delivery = 'serial' } = {}) {
+        this.emitter = new 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 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 Immutable.freeze(JSON.parse(JSON.stringify(event)));
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { ValidationIssue } from '../../exceptions/index.js';
+import type { Logger } from '../../application/index.js';
+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/esm/infrastructure/http/http-error-mapper.js

@@ -0,0 +1,59 @@
+import { AbstractException, AggregateNotFoundException, ApplicationException, ConcurrencyException, DomainException, ExceptionCode, NotAllowedException, RequiredValueException, TypePrimitiveException, ValidationException, } from '../../exceptions/index.js';
+import { SilentLogger } from '../logging/silent-logger.js';
+const INTERNAL_MESSAGE = 'Internal server error';
+export class HttpErrorMapper {
+    constructor({ statusByCode = {}, logger = new 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 AbstractException)) {
+            return {
+                status: 500,
+                body: { code: 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 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 AggregateNotFoundException) {
+            return 404;
+        }
+        if (error instanceof NotAllowedException) {
+            return 403;
+        }
+        if (error instanceof ConcurrencyException) {
+            return 409;
+        }
+        if (error instanceof TypePrimitiveException || error instanceof RequiredValueException) {
+            return 400;
+        }
+        if (error instanceof DomainException) {
+            return 422;
+        }
+        if (error instanceof ApplicationException) {
+            return 400;
+        }
+        return 500;
+    }
+}

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

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

package/dist/esm/infrastructure/index.js

@@ -0,0 +1,9 @@
+export { SystemClock } from './clock/system-clock.js';
+export { FixedClock } from './clock/fixed-clock.js';
+export { DomainEventBus } from './event/domain-event-bus.js';
+export { EventRegistry } from './event/event-registry.js';
+export { InMemoryEventChannel } from './event/in-memory/in-memory-event-channel.js';
+export { HttpErrorMapper } from './http/http-error-mapper.js';
+export { ConsoleLogger } from './logging/console-logger.js';
+export { InMemoryLogger } from './logging/in-memory-logger.js';
+export { SilentLogger } from './logging/silent-logger.js';