node-cqrs 0.17.0 → 1.0.0-beta.0

package/dist/esm/workers/WorkerProxyProjection.js

@@ -0,0 +1,105 @@
+import { MessageChannel } from 'node:worker_threads';
+import * as Comlink from 'comlink';
+import { nodeEndpoint, createWorker } from "./utils/index.js";
+import { assertStringArray, assertString, extractErrorDetails, subscribe } from "../utils/index.js";
+import { describe } from "../Event.js";
+import { InMemoryLock } from "../in-memory/InMemoryLock.js";
+/**
+ * Projection being automatically created in the main thread to proxy events
+ * and view calls to AbstractWorkerThreadProjection instance
+ */
+export class WorkerProxyProjection {
+    #worker;
+    #workerInit;
+    #remoteProjection;
+    #remoteView;
+    #logger;
+    #messageTypes;
+    #viewLocker = new InMemoryLock();
+    get remoteProjection() {
+        return this.#remoteProjection;
+    }
+    get view() {
+        return this.#remoteView;
+    }
+    constructor({ workerModulePath, messageTypes, logger }) {
+        assertString(workerModulePath, 'workerModulePath');
+        assertStringArray(messageTypes, 'messageTypes');
+        this.#messageTypes = messageTypes;
+        this.#logger = logger && 'child' in logger ? logger.child({ service: new.target.name }) : logger;
+        const { port1: projectionPortMain, port2: projectionPort } = new MessageChannel();
+        const { port1: viewPortMain, port2: viewPort } = new MessageChannel();
+        this.#workerInit = createWorker(workerModulePath, {
+            projectionPort,
+            viewPort
+        }).then(worker => {
+            this.#worker = worker;
+            worker.once('error', this._onWorkerError);
+            worker.once('exit', this._onWorkerExit);
+            return worker;
+        });
+        this.#workerInit.catch(() => { });
+        this.#remoteProjection = Comlink.wrap(nodeEndpoint(projectionPortMain));
+        this.#remoteView = Comlink.wrap(nodeEndpoint(viewPortMain));
+    }
+    subscribe(eventStore) {
+        subscribe(eventStore, this, {
+            masterHandler: this.project,
+            messageTypes: this.#messageTypes
+        });
+    }
+    async restore(eventStore) {
+        if (this.#viewLocker)
+            await this.#viewLocker.lock();
+        await this._restore(eventStore);
+        if (this.#viewLocker)
+            this.#viewLocker.unlock();
+    }
+    /** Restore view state from not-yet-projected events */
+    async _restore(eventStore) {
+        if (!this.#worker)
+            await this.#workerInit;
+        this.#logger?.debug('retrieving last event projected');
+        const lastEvent = await this.#remoteProjection.getLastProjectedEvent();
+        this.#logger?.debug(`retrieving ${lastEvent ? `events after ${describe(lastEvent)}` : 'all events'}...`);
+        const eventsIterable = eventStore.getEventsByTypes(this.#messageTypes, { afterEvent: lastEvent });
+        let eventsCount = 0;
+        const startTs = Date.now();
+        for await (const event of eventsIterable) {
+            await this._project(event);
+            eventsCount += 1;
+        }
+        this.#logger?.info(`view restored from ${eventsCount} event(s) in ${Date.now() - startTs} ms`);
+    }
+    _onWorkerError = (error) => {
+        this.#logger?.error('worker error', {
+            error: extractErrorDetails(error)
+        });
+    };
+    _onWorkerExit = (exitCode) => {
+        if (exitCode !== 0)
+            this.#logger?.error(`worker exited with code ${exitCode}`);
+    };
+    async ensureWorkerReady() {
+        await this.#workerInit;
+    }
+    async project(event) {
+        if (!this.#worker)
+            await this.#workerInit;
+        if (!this.#viewLocker.ready) {
+            this.#logger?.debug(`view is locked, awaiting until it is ready to process ${describe(event)}`);
+            await this.#viewLocker.once('ready');
+            this.#logger?.debug(`view is ready, processing ${describe(event)}`);
+        }
+        return this.#remoteProjection.project(event);
+    }
+    async _project(event) {
+        await this.#remoteProjection._project(event);
+    }
+    dispose() {
+        this.#remoteProjection[Comlink.releaseProxy]();
+        this.#remoteView[Comlink.releaseProxy]();
+        this.#worker?.terminate();
+    }
+}
+//# sourceMappingURL=WorkerProxyProjection.js.map

package/dist/esm/workers/WorkerProxyProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerProxyProjection.js","sourceRoot":"","sources":["../../../src/workers/WorkerProxyProjection.ts"],"names":[],"mappings":"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"}

package/dist/esm/workers/index.js

@@ -0,0 +1,4 @@
+export * from "./AbstractWorkerProjection.js";
+export * from "./utils/index.js";
+export * from "./WorkerProxyProjection.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/workers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/workers/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC"}

package/dist/esm/workers/interfaces/IProxyProjection.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IProxyProjection.js.map

package/dist/esm/workers/interfaces/IProxyProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IProxyProjection.js","sourceRoot":"","sources":["../../../../src/workers/interfaces/IProxyProjection.ts"],"names":[],"mappings":""}

package/dist/esm/workers/interfaces/IWorkerProjection.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IWorkerProjection.js.map

package/dist/esm/workers/interfaces/IWorkerProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IWorkerProjection.js","sourceRoot":"","sources":["../../../../src/workers/interfaces/IWorkerProjection.ts"],"names":[],"mappings":""}

package/dist/esm/workers/interfaces/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/esm/workers/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/workers/interfaces/index.ts"],"names":[],"mappings":""}

package/dist/esm/workers/protocol.js

@@ -0,0 +1,11 @@
+export const isWorkerData = (obj) => typeof obj === 'object'
+    && obj !== null
+    && 'projectionPort' in obj
+    && !!obj.projectionPort
+    && 'viewPort' in obj
+    && !!obj.viewPort;
+export const isWorkerInitMessage = (msg) => typeof msg === 'object'
+    && msg !== null
+    && 'type' in msg
+    && msg.type === 'ready';
+//# sourceMappingURL=protocol.js.map

package/dist/esm/workers/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../src/workers/protocol.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,GAAY,EAAsB,EAAE,CAChE,OAAO,GAAG,KAAK,QAAQ;OACpB,GAAG,KAAK,IAAI;OACZ,gBAAgB,IAAI,GAAG;OACvB,CAAC,CAAC,GAAG,CAAC,cAAc;OACpB,UAAU,IAAI,GAAG;OACjB,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC;AAInB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,GAAY,EAA4B,EAAE,CAC7E,OAAO,GAAG,KAAK,QAAQ;OACpB,GAAG,KAAK,IAAI;OACZ,MAAM,IAAI,GAAG;OACb,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC"}

package/dist/esm/workers/utils/ProjectionView.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ProjectionView.js.map

package/dist/esm/workers/utils/ProjectionView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectionView.js","sourceRoot":"","sources":["../../../../src/workers/utils/ProjectionView.ts"],"names":[],"mappings":""}

package/dist/esm/workers/utils/createWorker.js

@@ -0,0 +1,51 @@
+import { Worker } from 'node:worker_threads';
+import * as path from 'node:path';
+import { isWorkerInitMessage } from "../protocol.js";
+/**
+ * Create a worker instance, await a handshake or a failure
+ *
+ * @param workerModulePath - Path to worker module
+ * @param ports - Container with MessagePorts for communication with worker projection and view instances
+ * @returns Worker instance
+ */
+export async function createWorker(workerModulePath, ports) {
+    const workerEntrypoint = path.isAbsolute(workerModulePath) ?
+        workerModulePath :
+        path.resolve(process.cwd(), workerModulePath);
+    const worker = new Worker(workerEntrypoint, {
+        workerData: ports,
+        transferList: [
+            ports.projectionPort,
+            ports.viewPort
+        ]
+    });
+    await new Promise((resolve, reject) => {
+        const cleanup = () => {
+            // eslint-disable-next-line no-use-before-define
+            worker.off('error', onError);
+            // eslint-disable-next-line no-use-before-define
+            worker.off('message', onMessage);
+            // eslint-disable-next-line no-use-before-define
+            worker.off('exit', onExit);
+        };
+        const onMessage = (msg) => {
+            if (!isWorkerInitMessage(msg))
+                return;
+            cleanup();
+            resolve(undefined);
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const onExit = (exitCode) => {
+            cleanup();
+            reject(new Error(`Worker exited prematurely with exit code ${exitCode}`));
+        };
+        worker.on('message', onMessage);
+        worker.once('error', onError);
+        worker.once('exit', onExit);
+    });
+    return worker;
+}
+//# sourceMappingURL=createWorker.js.map

package/dist/esm/workers/utils/createWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWorker.js","sourceRoot":"","sources":["../../../../src/workers/utils/createWorker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,mBAAmB,EAAoB,MAAM,gBAAgB,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,gBAAwB,EAAE,KAAkB;IAE9E,MAAM,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAC3D,gBAAgB,CAAC,CAAC;QAClB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAE/C,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,gBAAgB,EAAE;QAC3C,UAAU,EAAE,KAAK;QACjB,YAAY,EAAE;YACb,KAAK,CAAC,cAAc;YACpB,KAAK,CAAC,QAAQ;SACd;KACD,CAAC,CAAC;IAEH,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAErC,MAAM,OAAO,GAAG,GAAG,EAAE;YACpB,gDAAgD;YAChD,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC7B,gDAAgD;YAChD,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YACjC,gDAAgD;YAChD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC5B,CAAC,CAAC;QAEF,MAAM,SAAS,GAAG,CAAC,GAAY,EAAE,EAAE;YAClC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC;gBAC5B,OAAO;YAER,OAAO,EAAE,CAAC;YACV,OAAO,CAAC,SAAS,CAAC,CAAC;QACpB,CAAC,CAAC;QAEF,MAAM,OAAO,GAAG,CAAC,GAAY,EAAE,EAAE;YAChC,OAAO,EAAE,CAAC;YACV,MAAM,CAAC,GAAG,CAAC,CAAC;QACb,CAAC,CAAC;QAEF,MAAM,MAAM,GAAG,CAAC,QAAgB,EAAE,EAAE;YACnC,OAAO,EAAE,CAAC;YACV,MAAM,CAAC,IAAI,KAAK,CAAC,4CAA4C,QAAQ,EAAE,CAAC,CAAC,CAAC;QAC3E,CAAC,CAAC;QAEF,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC9B,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/esm/workers/utils/createWorkerInstance.js

@@ -0,0 +1,23 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import * as Comlink from 'comlink';
+import { assertFunction, getMessageHandlerNames, isClass } from "../../utils/index.js";
+import { isWorkerData } from "../protocol.js";
+import { nodeEndpoint } from "./index.js";
+export function createWorkerInstance(ProjectionFactoryOrType, projectionMethodsToWire) {
+    if (!parentPort)
+        throw new Error('createWorkerInstance can only be called from a Worker thread');
+    if (!isWorkerData(workerData))
+        throw new Error('workerData does not contain projectionPort and viewPort');
+    const projection = isClass(ProjectionFactoryOrType) ? new ProjectionFactoryOrType() : ProjectionFactoryOrType();
+    const methodsToWire = projectionMethodsToWire ?? getMessageHandlerNames(projection);
+    const projectionApi = Object.fromEntries(methodsToWire.map(methodName => {
+        const method = projection[methodName];
+        assertFunction(method, methodName);
+        return [methodName, method.bind(projection)];
+    }));
+    Comlink.expose(projectionApi, nodeEndpoint(workerData.projectionPort));
+    Comlink.expose(projection.view, nodeEndpoint(workerData.viewPort));
+    parentPort.postMessage({ type: 'ready' });
+    return projection;
+}
+//# sourceMappingURL=createWorkerInstance.js.map

package/dist/esm/workers/utils/createWorkerInstance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWorkerInstance.js","sourceRoot":"","sources":["../../../../src/workers/utils/createWorkerInstance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAEnC,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACvF,OAAO,EAA0B,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAoB1C,MAAM,UAAU,oBAAoB,CACnC,uBAAsE,EACtE,uBAAuE;IAEvE,IAAI,CAAC,UAAU;QACd,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;IACjF,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;IAE5E,MAAM,UAAU,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,IAAI,uBAAuB,EAAE,CAAC,CAAC,CAAC,uBAAuB,EAAE,CAAC;IAChH,MAAM,aAAa,GAAG,uBAAuB,IAAI,sBAAsB,CAAC,UAAU,CAAC,CAAC;IACpF,MAAM,aAAa,GAAG,MAAM,CAAC,WAAW,CACvC,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;QAC9B,MAAM,MAAM,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;QACtC,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAEnC,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAC9C,CAAC,CAAC,CACF,CAAC;IAEF,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC;IACvE,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEnE,UAAU,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAA8B,CAAC,CAAC;IAEtE,OAAO,UAAU,CAAC;AACnB,CAAC"}

package/dist/esm/workers/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./createWorker.js";
+export * from "./createWorkerInstance.js";
+export * from "./nodeEndpoint.js";
+export * from "./workerProxyFactory.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/workers/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/workers/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC"}

package/dist/esm/workers/utils/nodeEndpoint.js

@@ -0,0 +1,5 @@
+// Jest (CJS) cannot import the ESM adapter;
+// the UMD build is CJS/UMD but the default export shape varies by loader
+const nodeEndpointModule = require('comlink/dist/umd/node-adapter');
+export const nodeEndpoint = (nodeEndpointModule?.default ?? nodeEndpointModule);
+//# sourceMappingURL=nodeEndpoint.js.map

package/dist/esm/workers/utils/nodeEndpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeEndpoint.js","sourceRoot":"","sources":["../../../../src/workers/utils/nodeEndpoint.ts"],"names":[],"mappings":"AAEA,4CAA4C;AAC5C,yEAAyE;AACzE,MAAM,kBAAkB,GAAG,OAAO,CAAC,+BAA+B,CAAC,CAAC;AACpE,MAAM,CAAC,MAAM,YAAY,GACxB,CAAC,kBAAkB,EAAE,OAAO,IAAI,kBAAkB,CAAQ,CAAC"}

package/dist/esm/workers/utils/workerProxyFactory.js

@@ -0,0 +1,18 @@
+import { assertClass, assertString, assertStringArray } from "../../utils/assert.js";
+import { WorkerProxyProjection } from "../WorkerProxyProjection.js";
+export function workerProxyFactory(WorkerProjectionType, ProxyProjectionType = WorkerProxyProjection) {
+    assertClass(WorkerProjectionType, 'WorkerProjectionType');
+    assertString(WorkerProjectionType.workerModulePath, 'WorkerProjectionType.workerModulePath');
+    assertStringArray(WorkerProjectionType.handles, 'WorkerProjectionType.handles');
+    assertClass(ProxyProjectionType, 'ProxyProjectionType');
+    return (container) => {
+        const proxyParams = {
+            workerModulePath: WorkerProjectionType.workerModulePath,
+            messageTypes: WorkerProjectionType.handles
+        };
+        if (container?.createInstance)
+            return container.createInstance(ProxyProjectionType, proxyParams);
+        return new ProxyProjectionType(proxyParams);
+    };
+}
+//# sourceMappingURL=workerProxyFactory.js.map

package/dist/esm/workers/utils/workerProxyFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerProxyFactory.js","sourceRoot":"","sources":["../../../../src/workers/utils/workerProxyFactory.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AA6BpE,MAAM,UAAU,kBAAkB,CAKjC,oBAA+D,EAC/D,sBAAwD,qBAAqB;IAE7E,WAAW,CAAC,oBAAoB,EAAE,sBAAsB,CAAC,CAAC;IAC1D,YAAY,CAAC,oBAAoB,CAAC,gBAAgB,EAAE,uCAAuC,CAAC,CAAC;IAC7F,iBAAiB,CAAC,oBAAoB,CAAC,OAAO,EAAE,8BAA8B,CAAC,CAAC;IAChF,WAAW,CAAC,mBAAmB,EAAE,qBAAqB,CAAC,CAAC;IAExD,OAAO,CAAC,SAAsB,EAAE,EAAE;QACjC,MAAM,WAAW,GAA0B;YAC1C,gBAAgB,EAAE,oBAAoB,CAAC,gBAAgB;YACvD,YAAY,EAAE,oBAAoB,CAAC,OAAO;SAC1C,CAAC;QAEF,IAAI,SAAS,EAAE,cAAc;YAC5B,OAAO,SAAS,CAAC,cAAc,CAAC,mBAAmB,EAAE,WAAW,CAAC,CAAC;QAEnE,OAAO,IAAI,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC7C,CAAC,CAAC;AACH,CAAC"}

package/dist/types/AbstractAggregate.d.ts

@@ -0,0 +1,80 @@
+import { AggregateCommandHandler } from './AggregateCommandHandler.ts';
+import { type IAggregate, type IMutableState, type ICommand, type Identifier, type IEvent, type IEventSet, type IAggregateConstructorParams, type ISnapshotEvent, type IAggregateConstructor, type IEventStore, type ICommandBus, type RetryOnConcurrencyErrorOptions } from './interfaces/index.ts';
+/**
+ * Base class for Aggregate definition
+ */
+export declare abstract class AbstractAggregate<TState extends IMutableState | object | void = void> implements IAggregate {
+    #private;
+    /**
+     * List of command names handled by the Aggregate.
+     *
+     * Can be overridden in the Aggregate implementation to explicitly define supported commands.
+     * If not overridden, all public methods will be treated as command handlers by default.
+     *
+     * @example ['createUser', 'changePassword'];
+     */
+    static get handles(): string[];
+    /**
+     * Optional list of event types that are required to restore the aggregate state.
+     *
+     * @see IAggregateConstructor
+     */
+    static get restoresFrom(): Readonly<string[]> | undefined;
+    /**
+     * Defines retry behavior when a ConcurrencyError is thrown during event dispatch.
+     *
+     * @see IAggregateConstructor
+     */
+    static get retryOnConcurrencyError(): RetryOnConcurrencyErrorOptions | undefined;
+    /**
+     * Convenience helper to create an `AggregateCommandHandler` for this aggregate type and
+     * subscribe it to the provided `commandBus`.
+     */
+    static register<T extends AbstractAggregate, S extends IMutableState | object | void>(this: IAggregateConstructor<T, S> & (new (options: IAggregateConstructorParams<S>) => T), eventStore: IEventStore, commandBus: ICommandBus): AggregateCommandHandler<T>;
+    /** List of emitted events */
+    protected changes: IEvent[];
+    /** Internal aggregate state */
+    protected state: TState | undefined;
+    /** Command being handled by aggregate */
+    protected command?: ICommand;
+    /** Unique aggregate instance identifier */
+    get id(): Identifier;
+    /** Aggregate instance version */
+    get version(): number;
+    /** Restored snapshot version */
+    get snapshotVersion(): number | undefined;
+    /**
+     * Override to define whether an aggregate state snapshot should be taken
+     *
+     * @example
+     *   // create snapshot every 50 events if new events were emitted
+     *   return !!this.changes.length
+     *     && this.version - (this.snapshotVersion ?? 0) > 50;
+     */
+    protected get shouldTakeSnapshot(): boolean;
+    constructor(options: IAggregateConstructorParams<TState>);
+    /** Mutate aggregate state and increment aggregate version */
+    mutate(event: IEvent): void;
+    /** Pass command to command handler */
+    handle(command: ICommand): Promise<IEventSet>;
+    /**
+     * Get the events emitted during commands processing.
+     * If a snapshot should be taken, the snapshot event is added to the end.
+     */
+    protected getUncommittedEvents(offset?: number): IEventSet;
+    /** Format and register aggregate event and mutate aggregate state */
+    protected emit(type: string): IEvent<void>;
+    protected emit<TPayload>(type: string, payload: TPayload): IEvent<TPayload>;
+    /** Format event based on a current aggregate state and a command being executed */
+    protected makeEvent<TPayload>(type: string, payload: TPayload, sourceCommand?: ICommand): IEvent<TPayload>;
+    /** Register aggregate event and mutate aggregate state */
+    protected emitRaw<TPayload>(event: IEvent<TPayload>): void;
+    /** Create an aggregate state snapshot */
+    protected makeSnapshot(): any;
+    /** Add snapshot event to the collection of emitted events */
+    protected takeSnapshot(): void;
+    /** Restore aggregate state from a snapshot */
+    protected restoreSnapshot(snapshotEvent: ISnapshotEvent<TState>): void;
+    /** Get human-readable aggregate identifier */
+    toString(): string;
+}

package/dist/types/AbstractProjection.d.ts

@@ -0,0 +1,77 @@
+import { type IViewLocker, type IEventLocker, type IProjection, type ILogger, type IExtendableLogger, type IEvent, type IObservable, type IEventStorageReader } from './interfaces/index.ts';
+export type AbstractProjectionParams<T> = {
+    /**
+     * The default view associated with the projection.
+     * Can optionally implement IViewLocker and/or IEventLocker.
+     */
+    view?: T;
+    /**
+     * Manages view restoration state to prevent early access to an inconsistent view
+     * or conflicts from concurrent restoration by other processes.
+     */
+    viewLocker?: IViewLocker;
+    /**
+     * Tracks event processing state to prevent concurrent handling by multiple processes.
+     */
+    eventLocker?: IEventLocker;
+    logger?: ILogger | IExtendableLogger;
+};
+/**
+ * Base class for Projection definition
+ */
+export declare abstract class AbstractProjection<TView = any> implements IProjection<TView> {
+    #private;
+    /**
+     * List of event types handled by the projection. Can be overridden in the projection implementation.
+     * If not overridden, event types will be inferred from handler methods defined on the Projection class.
+     */
+    static get handles(): string[];
+    protected _logger?: ILogger;
+    /**
+     * The default view associated with the projection.
+     * Can optionally implement IViewLocker and/or IEventLocker.
+     */
+    get view(): TView;
+    protected set view(value: TView);
+    /**
+     * Manages view restoration state to prevent early access to an inconsistent view
+     * or conflicts from concurrent restoration by other processes.
+     */
+    protected get _viewLocker(): IViewLocker | null;
+    protected set _viewLocker(value: IViewLocker | undefined | null);
+    /**
+     * Tracks event processing state to prevent concurrent handling by multiple processes.
+     */
+    protected get _eventLocker(): IEventLocker | null;
+    protected set _eventLocker(value: IEventLocker | undefined | null);
+    constructor({ view, viewLocker, eventLocker, logger }?: AbstractProjectionParams<TView>);
+    /**
+     * Subscribe to event store
+     * and restore view state from not yet projected events
+     */
+    subscribe(eventStore: IObservable): void;
+    /** Pass event to projection event handler */
+    project(event: IEvent, meta?: Record<string, any>): Promise<void>;
+    /**
+     * Determines whether an event should be recorded as the last projected event (restore checkpoint).
+     * Override in derived classes to control checkpoint behavior based on event metadata.
+     */
+    protected shouldRecordLastEvent(_event: IEvent, _meta?: Record<string, any>): boolean;
+    /** Pass event to projection event handler, without awaiting for restore operation to complete */
+    protected _project(event: IEvent, meta?: Record<string, any>): Promise<void>;
+    /**
+     * Restore view state from not-yet-projected events.
+     *
+     * Lock the view to ensure same restoring procedure
+     * won't be performed by another projection instance.
+     * */
+    restore(eventStore: IEventStorageReader): Promise<void>;
+    /** Restore view state from not-yet-projected events */
+    protected _restore(eventStore: IEventStorageReader): Promise<void>;
+    /**
+     * Handle error on restoring.
+     *
+     * Logs and throws error by default
+     */
+    protected _onRestoringError(error: unknown, event: IEvent): void;
+}

package/dist/types/AbstractSaga.d.ts

@@ -0,0 +1,42 @@
+import type { ICommand, ICommandBus, Identifier, IEvent, IEventStore, IMutableState, ISaga, ISagaConstructor, ISagaConstructorParams } from './interfaces/index.ts';
+import { SagaEventHandler } from './SagaEventHandler.ts';
+/**
+ * Base class for Saga definition
+ */
+export declare abstract class AbstractSaga implements ISaga {
+    #private;
+    /**
+     * Optional list of events that start new saga.
+     *
+     * When not defined, saga start is inferred by the absence of `message.sagaOrigins[sagaDescriptor]`.
+     */
+    static get startsWith(): string[] | undefined;
+    /** List of event types being handled by Saga, can be overridden in Saga implementation */
+    static get handles(): string[];
+    /**
+     * Convenience helper to create a `SagaEventHandler` for this saga type and subscribe it to
+     * the provided `eventStore`.
+     */
+    static register<T extends AbstractSaga>(this: ISagaConstructor & (new (options: ISagaConstructorParams) => T), eventStore: IEventStore, commandBus: ICommandBus): SagaEventHandler;
+    /** Saga ID */
+    get id(): Identifier;
+    /** Saga version */
+    get version(): number;
+    protected state?: IMutableState | object;
+    /**
+     * Creates an instance of AbstractSaga
+     */
+    constructor(options: ISagaConstructorParams);
+    /** Modify saga state by applying an event */
+    mutate(event: IEvent): void;
+    /** Process saga event and return produced commands */
+    handle(event: IEvent): Promise<ReadonlyArray<ICommand>>;
+    /** Format a command and put it to the execution queue */
+    protected enqueue(commandType: string): void;
+    protected enqueue(commandType: string, aggregateId: Identifier): void;
+    protected enqueue<T>(commandType: string, aggregateId: Identifier | undefined, payload: T): void;
+    /** Put a command to the execution queue */
+    protected enqueueRaw(command: ICommand): void;
+    /** Get human-readable Saga name */
+    toString(): string;
+}

package/dist/types/AggregateCommandHandler.d.ts

@@ -0,0 +1,22 @@
+import type { IAggregate, IAggregateConstructor, IAggregateFactory, ICommand, ICommandHandler, IContainer, IEventSet, IObservable, RetryOnConcurrencyErrorOptions } from './interfaces/index.ts';
+/**
+ * Aggregate command handler.
+ *
+ * Subscribes to event store and awaits aggregate commands.
+ * Upon command receiving creates an instance of aggregate,
+ * restores its state, passes command and commits emitted events to event store.
+ */
+export declare class AggregateCommandHandler<TAggregate extends IAggregate> implements ICommandHandler {
+    #private;
+    constructor({ eventStore, aggregateType, aggregateFactory, handles, executionLocker, restoresFrom, retryOnConcurrencyError, logger }: Pick<IContainer, 'eventStore' | 'executionLocker' | 'logger'> & {
+        aggregateType?: IAggregateConstructor<TAggregate, any>;
+        aggregateFactory?: IAggregateFactory<TAggregate, any>;
+        handles?: Readonly<string[]>;
+        restoresFrom?: Readonly<string[]>;
+        retryOnConcurrencyError?: RetryOnConcurrencyErrorOptions;
+    });
+    /** Subscribe to all command types handled by aggregateType */
+    subscribe(commandBus: IObservable): void;
+    /** Pass a command to corresponding aggregate */
+    execute(cmd: ICommand): Promise<IEventSet>;
+}

package/dist/types/CommandBus.d.ts

@@ -0,0 +1,4 @@
+import { InMemoryMessageBus } from './in-memory/index.ts';
+/** @deprecated Use {@link InMemoryMessageBus} directly or a transport-specific implementation. */
+export declare class CommandBus extends InMemoryMessageBus {
+}

package/dist/types/CqrsContainerBuilder.d.ts

@@ -0,0 +1,21 @@
+import { ContainerBuilder, type TypeConfig, type ClassOrFactory } from 'di0';
+import { type IAggregateConstructor, type ICommandHandler, type IContainer, type IEventReceptor, type IProjection, type ISagaConstructor } from './interfaces/index.ts';
+export declare class CqrsContainerBuilder<TContainerInterface extends IContainer = IContainer> extends ContainerBuilder<TContainerInterface> {
+    constructor(options?: {
+        types: Readonly<TypeConfig<any>[]>;
+        singletones: object;
+    });
+    /** Register command handler, which will be subscribed to commandBus upon instance creation */
+    registerCommandHandler(typeOrFactory: ClassOrFactory<ICommandHandler, TContainerInterface>): TypeConfig<ICommandHandler, TContainerInterface>;
+    /** Register event receptor, which will be subscribed to eventStore upon instance creation */
+    registerEventReceptor(typeOrFactory: ClassOrFactory<IEventReceptor, TContainerInterface>): TypeConfig<IEventReceptor, TContainerInterface>;
+    /**
+     * Register projection, which will expose view and will be subscribed
+     * to eventStore and will restore its state upon instance creation
+     */
+    registerProjection(typeOrFactory: ClassOrFactory<IProjection<any>, TContainerInterface>, exposedViewAlias?: keyof TContainerInterface): TypeConfig<IProjection<any>, TContainerInterface>;
+    /** Register aggregate type in the container */
+    registerAggregate(AggregateType: IAggregateConstructor<any, any>): TypeConfig<ICommandHandler, TContainerInterface>;
+    /** Register saga type in the container */
+    registerSaga(SagaType: ISagaConstructor): TypeConfig<IEventReceptor, TContainerInterface>;
+}

package/dist/types/Event.d.ts

@@ -0,0 +1,9 @@
+import type { IEvent } from './interfaces/IEvent.ts';
+/**
+ * Get text description of an event for logging purposes
+ */
+export declare function describe(event: IEvent): string;
+/**
+ * Get text description of a set of events for logging purposes
+ */
+export declare function describeMultiple(events: ReadonlyArray<IEvent>): string;

package/dist/types/EventDispatchPipeline.d.ts

@@ -0,0 +1,16 @@
+import { type DispatchPipelineBatch, type IEvent, type IDispatchPipelineProcessor, type IEventBus } from './interfaces/index.ts';
+export type EventBatchEnvelope = {
+    data: DispatchPipelineBatch<{
+        event?: IEvent;
+    }>;
+    error?: Error;
+    resolve: (event: IEvent[]) => void;
+    reject: (error: Error) => void;
+};
+export declare class EventDispatchPipeline {
+    #private;
+    constructor(eventBus: IEventBus, concurrentLimit: number);
+    addProcessor(preprocessor: IDispatchPipelineProcessor): void;
+    revert(batch: DispatchPipelineBatch): Promise<void>;
+    push(envelope: EventBatchEnvelope): void;
+}

package/dist/types/EventDispatcher.d.ts

@@ -0,0 +1,39 @@
+import { type IEventDispatcher, type IDispatchPipelineProcessor, type IEventSet, type IEventBus, type IContainer } from './interfaces/index.ts';
+import { EventDispatchPipeline } from './EventDispatchPipeline.ts';
+export declare class EventDispatcher implements IEventDispatcher {
+    #private;
+    /** Default pipeline name */
+    static DEFAULT_PIPELINE: string;
+    /** Default maximum number of parallel batches for newly created pipelines */
+    static DEFAULT_CONCURRENT_LIMIT: number;
+    /** Default router that uses `meta.origin` as the pipeline name */
+    static DEFAULT_ROUTER: (_e: IEventSet, meta?: Record<string, any>) => any;
+    /**
+     * Event bus where dispatched messages are delivered after processing.
+     * If not provided in the constructor, defaults to an instance of `InMemoryMessageBus`.
+     */
+    eventBus: IEventBus;
+    /**
+     * Default maximum number of parallel batches for newly created pipelines.
+     */
+    concurrentLimit: number;
+    /** Router that selects a pipeline name given events and meta */
+    eventDispatchRouter?: (events: IEventSet, meta?: Record<string, any>) => string | undefined;
+    constructor(o?: Pick<IContainer, 'eventBus' | 'eventDispatchPipeline'> & {
+        eventDispatcherConfig?: {
+            concurrentLimit?: number;
+        };
+        eventDispatchPipelines?: Record<string, IDispatchPipelineProcessor[]>;
+        eventDispatchRouter?: (events: IEventSet, meta?: Record<string, any>) => string | undefined;
+    });
+    /** Add or create the default pipeline processors */
+    addPipelineProcessors(eventDispatchPipeline: IDispatchPipelineProcessor[], pipelineName?: string): void;
+    /** Adds a single processor to the default pipeline */
+    addPipelineProcessor(preprocessor: IDispatchPipelineProcessor, pipelineName?: string): void;
+    /** Create a named pipeline with processors and optional concurrency limit */
+    addPipeline(name: string, processors?: IDispatchPipelineProcessor[], options?: {
+        concurrentLimit?: number;
+    }): EventDispatchPipeline;
+    /** Dispatch events through a routed pipeline and publish to the shared eventBus */
+    dispatch(events: IEventSet, meta?: Record<string, any>): Promise<IEventSet>;
+}