node-cqrs 0.16.4 → 1.0.0-beta.0

package/dist/types/sqlite/SqliteProjectionDataParams.d.ts

@@ -0,0 +1,14 @@
+export type SqliteProjectionDataParams = {
+    /**
+     * Unique identifier for the projection, used with the schema version to distinguish data ownership.
+     */
+    projectionName: string;
+    /**
+     * The version of the schema used for data produced by the projection.
+     * When the projection's output format changes, this version should be incremented.
+     * A version change indicates that previously stored data is obsolete and must be rebuilt.
+     *
+     * @example "20250519", "1.0.0"
+     */
+    schemaVersion: string;
+};

package/dist/types/sqlite/SqliteViewLocker.d.ts

@@ -0,0 +1,31 @@
+import type { Database } from 'better-sqlite3';
+import type { IContainer } from 'node-cqrs';
+import type { IViewLocker } from '../interfaces/index.ts';
+import type { SqliteProjectionDataParams } from './SqliteProjectionDataParams.ts';
+import { AbstractSqliteAccessor } from './AbstractSqliteAccessor.ts';
+export type SqliteViewLockerParams = SqliteProjectionDataParams & {
+    /**
+     * (Optional) SQLite table name where event locks along with the latest event are stored
+     *
+     * @default "tbl_view_lock"
+     */
+    viewLockTableName?: string;
+    /**
+     * (Optional) Time-to-live (TTL) duration (in milliseconds) for which a view remains locked
+     *
+     * @default 120_000
+     */
+    viewLockTtl?: number;
+};
+export declare class SqliteViewLocker extends AbstractSqliteAccessor implements IViewLocker {
+    #private;
+    constructor(o: Partial<Pick<IContainer, 'viewModelSqliteDb' | 'viewModelSqliteDbFactory' | 'logger'>> & SqliteViewLockerParams);
+    protected initialize(db: Database): void;
+    get ready(): boolean;
+    lock(): Promise<boolean>;
+    private scheduleLockProlongation;
+    private cancelLockProlongation;
+    private prolongLock;
+    unlock(): Promise<void>;
+    once(event: 'ready'): Promise<void>;
+}

package/dist/types/sqlite/index.d.ts

@@ -0,0 +1,9 @@
+import './IContainer.ts';
+export * from './AbstractSqliteAccessor.ts';
+export * from './AbstractSqliteObjectProjection.ts';
+export * from './AbstractSqliteView.ts';
+export * from './SqliteEventLocker.ts';
+export * from './SqliteObjectStorage.ts';
+export * from './SqliteObjectView.ts';
+export * from './SqliteViewLocker.ts';
+export * from './utils/index.ts';

package/dist/types/sqlite/queries/eventLockTableInit.d.ts

@@ -0,0 +1 @@
+export declare const eventLockTableInit: (eventLockTableName: string) => string;

package/dist/types/sqlite/queries/index.d.ts

@@ -0,0 +1,2 @@
+export * from './eventLockTableInit.ts';
+export * from './viewLockTableInit.ts';

package/dist/types/sqlite/queries/viewLockTableInit.d.ts

@@ -0,0 +1 @@
+export declare const viewLockTableInit: (viewLockTableName: string) => string;

package/dist/types/sqlite/utils/getEventId.d.ts

@@ -0,0 +1,5 @@
+import { IEvent } from '../../interfaces/index.ts';
+/**
+ * Get assigned or generate new event ID from event content
+ */
+export declare const getEventId: (event: IEvent) => Buffer;

package/dist/types/sqlite/utils/guid.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Convert Guid to Buffer for storing in Sqlite BLOB
+ */
+export declare const guid: (str: string) => Buffer<ArrayBuffer>;

package/dist/types/sqlite/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './guid.ts';
+export * from './getEventId.ts';

package/dist/types/utils/Deferred.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deferred promise that must be resolved from outside
+ */
+export declare class Deferred<TDeferredValue> {
+    #private;
+    readonly promise: Promise<TDeferredValue | void>;
+    get resolved(): boolean;
+    get rejected(): boolean;
+    get settled(): boolean;
+    constructor();
+    resolve(value?: TDeferredValue): void;
+    reject(reason?: any): void;
+}

package/dist/types/utils/Lock.d.ts

@@ -0,0 +1,30 @@
+import type { ILocker, ILockerLease } from '../interfaces/ILocker.ts';
+export declare class LockLease implements ILockerLease {
+    readonly lock: Lock;
+    readonly name?: string;
+    constructor(lock: Lock, name?: string);
+    release(): void;
+    [Symbol.dispose](): void;
+}
+export declare class Lock implements ILocker {
+    #private;
+    isLocked(name?: string): boolean;
+    /**
+     * Acquire named or global lock
+     *
+     * @returns Promise that resolves once lock is acquired
+     */
+    acquire(name?: string): Promise<LockLease>;
+    /**
+     * @returns Promise that resolves once lock is released
+     */
+    waitForUnlock(name?: string): Promise<void>;
+    /**
+     * Release named or global lock
+     */
+    release(name?: string): void;
+    /**
+     * Execute callback with lock acquired, then release lock
+     */
+    runExclusively<T>(name: string | undefined, callback: () => Promise<T> | T): Promise<T>;
+}

package/dist/types/utils/MapAssertable.d.ts

@@ -0,0 +1,11 @@
+export declare class MapAssertable<K, V> extends Map<K, V> {
+    #private;
+    /**
+     * Ensures the key exists in the map, creating it with the factory if needed, and increments its usage counter.
+     */
+    assert(key: K, factory: () => V): V;
+    /**
+     * Decrements the usage counter for the key and removes it from the map if no longer used.
+     */
+    release(key: K): void;
+}

package/dist/types/utils/assert.d.ts

@@ -0,0 +1,20 @@
+import { type IMessage } from '../interfaces/IMessage.ts';
+import { type IEvent } from '../interfaces/IEvent.ts';
+import { type ISnapshotEvent } from '../interfaces/ISnapshotEvent.ts';
+import { type IObservable } from '../interfaces/IObservable.ts';
+export declare function assertDefined<T>(value: T, argName: string): asserts value is NonNullable<T>;
+export declare function assertString(value: unknown, argName: string): asserts value is string;
+export declare function assertFunction(value: unknown, argName: string): asserts value is Function;
+export declare function assertObject(value: unknown, argName: string): asserts value is object;
+export declare function assertArray(value: unknown, argName: string): asserts value is unknown[];
+export declare function assertStringArray(value: unknown, argName: string): asserts value is string[];
+export declare function assertOptionalArray(value: unknown, argName: string): asserts value is unknown[];
+export declare function assertMessage(value: unknown, argName: string): asserts value is IMessage;
+export declare function assertEvent(value: unknown, argName: string): asserts value is IEvent;
+export declare function assertSnapshotEvent(value: unknown, argName: string): asserts value is ISnapshotEvent;
+export declare function assertObservable(value: unknown, argName: string): asserts value is IObservable;
+export declare function assertNumber(value: unknown, argName: string): asserts value is number;
+export declare function assertClass(value: unknown, argName: string): asserts value is new (...args: any[]) => any;
+export declare function assertNonNegativeInteger(value: unknown, argName: string): asserts value is number;
+export declare function assertBoolean(value: unknown, argName: string): asserts value is boolean;
+export declare function assertNotDefined(value: unknown, argName: string): asserts value is undefined;

package/dist/types/utils/clone.d.ts

@@ -0,0 +1 @@
+export declare function clone<T>(value: T): T;

package/dist/types/utils/extractErrorDetails.d.ts

@@ -0,0 +1,8 @@
+export type ErrorDetails = {
+    name?: string;
+    message: string;
+    code?: any;
+    stack?: string;
+    cause?: ErrorDetails;
+};
+export declare const extractErrorDetails: (err: unknown) => ErrorDetails;

package/dist/types/utils/getClassName.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get instance class name
+ */
+export declare function getClassName(instance: object): string;

package/dist/types/utils/getHandler.d.ts

@@ -0,0 +1,7 @@
+import type { IMessageHandler } from '../interfaces/index.ts';
+/**
+ * Gets a handler for a specific message type, prefers a public (w\o _ prefix) method, if available
+ */
+export declare function getHandler(context: {
+    [key: string]: any;
+}, messageType: string): IMessageHandler | null;

package/dist/types/utils/getMessageHandlerNames.d.ts

@@ -0,0 +1,12 @@
+type ObserverConstructor<T extends object> = abstract new (...args: any[]) => T;
+/**
+ * Get message handler names from an observer instance.
+ * Assumes private method names start with underscore (`_`).
+ */
+export declare function getMessageHandlerNames<T extends object>(observerInstance: T): Extract<keyof T, string>[];
+/**
+ * Get message handler names from an observer class constructor.
+ * Assumes private method names start with underscore (`_`).
+ */
+export declare function getMessageHandlerNames<T extends object>(observerClass: ObserverConstructor<T>): Extract<keyof T, string>[];
+export {};

package/dist/types/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './assert.ts';
+export * from './clone.ts';
+export * from './Deferred.ts';
+export * from './extractErrorDetails.ts';
+export * from './getClassName.ts';
+export * from './getHandler.ts';
+export * from './getMessageHandlerNames.ts';
+export * from './isClass.ts';
+export * from './Lock.ts';
+export * from './MapAssertable.ts';
+export * from './setupOneTimeEmitterSubscription.ts';
+export * from './sagaId.ts';
+export * from './subscribe.ts';
+export * from './validateHandlers.ts';

package/dist/types/utils/isClass.d.ts

@@ -0,0 +1 @@
+export declare function isClass(func: unknown): func is new (...args: any[]) => any;

package/dist/types/utils/sagaId.d.ts

@@ -0,0 +1,6 @@
+import type { Identifier } from '../interfaces/Identifier.ts';
+export declare const makeSagaId: (sagaDescriptor: string, originEventId: string) => string;
+export declare const parseSagaId: (sagaId: Identifier) => {
+    sagaDescriptor: string;
+    originEventId: string;
+};

package/dist/types/utils/setupOneTimeEmitterSubscription.d.ts

@@ -0,0 +1,12 @@
+import type { IEvent, ILogger, IObservable } from '../interfaces/index.ts';
+/**
+ * Create one-time eventEmitter subscription for one or multiple events that match a filter
+ *
+ * @param {IObservable} emitter
+ * @param {string[]} messageTypes Array of event type to subscribe to
+ * @param {function(IEvent):any} [handler] Optional handler to execute for a first event received
+ * @param {function(IEvent):boolean} [filter] Optional filter to apply before executing a handler
+ * @param {ILogger} logger
+ * @return {Promise<IEvent>} Resolves to first event that passes filter
+ */
+export declare function setupOneTimeEmitterSubscription(emitter: IObservable, messageTypes: string[], filter?: (e: IEvent) => boolean, handler?: (e: IEvent) => void, logger?: ILogger): Promise<IEvent>;

package/dist/types/utils/subscribe.d.ts

@@ -0,0 +1,9 @@
+import { type IMessageHandler, type IObservable } from '../interfaces/index.ts';
+/**
+ * Subscribe observer to observable
+ */
+export declare function subscribe(observable: IObservable, observer: object, options?: {
+    messageTypes?: string[];
+    masterHandler?: IMessageHandler;
+    queueName?: string;
+}): void;

package/dist/types/utils/validateHandlers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Ensure instance has handlers declared for all handled message types
+ */
+export declare function validateHandlers(instance: object, handlesFieldName?: string): void;

package/dist/types/workers/AbstractWorkerProjection.d.ts

@@ -0,0 +1,25 @@
+import { AbstractProjection } from '../AbstractProjection.ts';
+import { type ProjectionView } from './utils/index.ts';
+import type { IWorkerProjection, IWorkerProjectionType } from './interfaces/index.ts';
+import type { IContainer, IEvent } from '../interfaces/index.ts';
+/**
+ * Projection base class that can run projection handlers and the associated view in a worker thread
+ * to isolate CPU-heavy work and keep the main thread responsive
+ */
+export declare abstract class AbstractWorkerProjection<TView> extends AbstractProjection<TView> implements IWorkerProjection<TView> {
+    /**
+     * In a worker thread, creates and exposes the projection singleton.
+     */
+    static createInstanceInWorkerThread<V, T extends AbstractWorkerProjection<V>>(this: new () => T, factory?: () => T): T | undefined;
+    /**
+     * Creates a factory that returns a `WorkerProxyProjection` for this projection type.
+     * Use it in the main thread (for example, `builder.registerProjection(MyProjection.workerProxyFactory)`),
+     * so events are proxied to the worker instance while exposing the remote view API.
+     */
+    static workerProxyFactory<TProjection extends IWorkerProjection<any>, TContainer extends IContainer = IContainer, TView = ProjectionView<TProjection>>(this: IWorkerProjectionType<TView, TProjection>, container?: TContainer): import("./WorkerProxyProjection.ts").WorkerProxyProjection<TView, TProjection>;
+    static get workerModulePath(): string;
+    /**
+     * Returns the last projected event if the view implements IEventLocker, otherwise undefined.
+     */
+    getLastProjectedEvent(): Promise<IEvent | undefined>;
+}

package/dist/types/workers/WorkerProxyProjection.d.ts

@@ -0,0 +1,25 @@
+import type { IEvent, IEventStorageReader, IEventStore, IExtendableLogger, ILogger } from '../interfaces/index.ts';
+import type { IProxyProjection, IWorkerProjection, ProxyProjectionParams } from './interfaces/index.ts';
+import * as Comlink from 'comlink';
+/**
+ * Projection being automatically created in the main thread to proxy events
+ * and view calls to AbstractWorkerThreadProjection instance
+ */
+export declare class WorkerProxyProjection<TView, TProjection extends IWorkerProjection<TView> = IWorkerProjection<TView>> implements IProxyProjection<TView> {
+    #private;
+    get remoteProjection(): Comlink.Remote<TProjection>;
+    get view(): Comlink.Remote<TView>;
+    constructor({ workerModulePath, messageTypes, logger }: ProxyProjectionParams & {
+        logger?: IExtendableLogger | ILogger;
+    });
+    subscribe(eventStore: IEventStore): void;
+    restore(eventStore: IEventStorageReader): Promise<void>;
+    /** Restore view state from not-yet-projected events */
+    protected _restore(eventStore: IEventStorageReader): Promise<void>;
+    protected _onWorkerError: (error: unknown) => void;
+    protected _onWorkerExit: (exitCode: number) => void;
+    ensureWorkerReady(): Promise<void>;
+    project(event: IEvent): Promise<void>;
+    protected _project(event: IEvent): Promise<void>;
+    dispose(): void;
+}

package/dist/types/workers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AbstractWorkerProjection.ts';
+export * from './utils/index.ts';
+export * from './WorkerProxyProjection.ts';

package/dist/types/workers/interfaces/IProxyProjection.d.ts

@@ -0,0 +1,15 @@
+import type * as Comlink from 'comlink';
+import type { IProjection } from '../../interfaces/index.js';
+export type ProxyProjectionParams = {
+    /**
+     * Required in the main thread to spawn a worker (derived projection module path).
+     * Not used in the worker thread.
+     */
+    workerModulePath: string;
+    messageTypes: string[];
+};
+export interface IProxyProjection<TView> extends IProjection<Comlink.Remote<TView>> {
+}
+export interface IProxyProjectionType<TView, TProxyProjection extends IProxyProjection<TView> = IProxyProjection<TView>> {
+    new (params: ProxyProjectionParams): TProxyProjection;
+}

package/dist/types/workers/interfaces/IWorkerProjection.d.ts

@@ -0,0 +1,19 @@
+import type { IEvent, IProjection } from '../../interfaces/index.js';
+export interface IWorkerProjection<TView> extends IProjection<TView> {
+    /**
+     * Returns the last projected event, if event-locking state is available.
+     */
+    getLastProjectedEvent(): Promise<IEvent | undefined>;
+    /**
+     * Projects an event without waiting for view lock readiness.
+     *
+     * Implemented by AbstractWorkerProjection and used by worker RPC wiring
+     * for restore and direct projection paths.
+     */
+    _project(event: IEvent): Promise<void>;
+}
+export interface IWorkerProjectionType<TView, TProjection extends IWorkerProjection<TView> = IWorkerProjection<TView>> {
+    new (): TProjection;
+    readonly workerModulePath: string;
+    readonly handles: string[];
+}

package/dist/types/workers/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './IProxyProjection.js';
+export type * from './IWorkerProjection.js';

package/dist/types/workers/protocol.d.ts

@@ -0,0 +1,10 @@
+import type { MessagePort } from 'node:worker_threads';
+export interface IWorkerData {
+    projectionPort: MessagePort;
+    viewPort: MessagePort;
+}
+export declare const isWorkerData: (obj: unknown) => obj is IWorkerData;
+export type WorkerInitMessage = {
+    type: 'ready';
+};
+export declare const isWorkerInitMessage: (msg: unknown) => msg is WorkerInitMessage;

package/dist/types/workers/utils/ProjectionView.d.ts

@@ -0,0 +1,2 @@
+import type { IProjection } from '../../interfaces/index.js';
+export type ProjectionView<P extends IProjection<any>> = P extends IProjection<infer V> ? V : never;

package/dist/types/workers/utils/createWorker.d.ts

@@ -0,0 +1,10 @@
+import { Worker } from 'node:worker_threads';
+import { type IWorkerData } from '../protocol.ts';
+/**
+ * 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 declare function createWorker(workerModulePath: string, ports: IWorkerData): Promise<Worker>;

package/dist/types/workers/utils/createWorkerInstance.d.ts

@@ -0,0 +1,11 @@
+import type { IProjection } from '../../interfaces/index.ts';
+/**
+ * Create and expose a worker-thread projection from a projection class type.
+ * The class is instantiated inside the worker with `new ProjectionType()`.
+ */
+export declare function createWorkerInstance<TProjection extends IProjection<any>>(ProjectionType: new () => TProjection, projectionMethodsToWire?: readonly Extract<keyof TProjection, string>[]): TProjection;
+/**
+ * Create and expose a worker-thread projection from a projection factory.
+ * The factory is executed inside the worker and should return the projection instance.
+ */
+export declare function createWorkerInstance<TProjection extends IProjection<any>>(projectionFactory: () => TProjection, projectionMethodsToWire?: readonly Extract<keyof TProjection, string>[]): TProjection;

package/dist/types/workers/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './createWorker.ts';
+export * from './createWorkerInstance.ts';
+export * from './nodeEndpoint.ts';
+export * from './workerProxyFactory.ts';
+export type * from './ProjectionView.ts';

package/dist/types/workers/utils/nodeEndpoint.d.ts

@@ -0,0 +1,2 @@
+import * as Comlink from 'comlink';
+export declare const nodeEndpoint: (arg: any) => Comlink.Endpoint;

package/dist/types/workers/utils/workerProxyFactory.d.ts

@@ -0,0 +1,14 @@
+import type { IContainer } from '../../interfaces/index.ts';
+import type { IProxyProjectionType, IWorkerProjectionType, IWorkerProjection } from '../interfaces/index.ts';
+import { WorkerProxyProjection } from '../WorkerProxyProjection.ts';
+import type { ProjectionView } from './ProjectionView.ts';
+/**
+ * Create a main-thread proxy factory for a worker projection type.
+ * Uses the default `WorkerProxyProjection` class for the proxy instance.
+ */
+export declare function workerProxyFactory<TProjection extends IWorkerProjection<any>, TContainer extends IContainer = IContainer, TView = ProjectionView<TProjection>>(WorkerProjectionType: IWorkerProjectionType<TView, TProjection>): (container?: TContainer) => WorkerProxyProjection<TView, TProjection>;
+/**
+ * Create a main-thread proxy factory for a worker projection type using
+ * a custom proxy projection class.
+ */
+export declare function workerProxyFactory<TProjection extends IWorkerProjection<any>, TContainer extends IContainer = IContainer, TView = ProjectionView<TProjection>, TProxyProjectionType extends IProxyProjectionType<TView, any> = IProxyProjectionType<TView, any>>(WorkerProjectionType: IWorkerProjectionType<TView, TProjection>, ProxyProjectionType: TProxyProjectionType): (container?: TContainer) => InstanceType<TProxyProjectionType>;

package/package.json

@@ -1,51 +1,151 @@
 {
   "name": "node-cqrs",
-  "version": "0.16.4",
-  "description": "Basic ES6 backbone for CQRS app development",
+  "version": "1.0.0-beta.0",
+  "description": "TypeScript CQRS/Event Sourcing toolkit for Node.js with DI, sagas, projections, and optional Worker, RabbitMQ, and SQLite adapters",
+  "type": "module",
+  "keywords": [
+    "cqrs",
+    "event-sourcing",
+    "eventsourcing",
+    "ddd",
+    "domain-driven-design",
+    "event-store",
+    "command-bus",
+    "event-bus",
+    "projection",
+    "saga",
+    "typescript",
+    "nodejs",
+    "worker-threads",
+    "rabbitmq",
+    "sqlite"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/snatalenko/node-cqrs.git"
   },
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js"
+    },
+    "./workers": {
+      "types": "./dist/types/workers/index.d.ts",
+      "require": "./dist/cjs/workers/index.js",
+      "import": "./dist/esm/workers/index.js"
+    },
+    "./rabbitmq": {
+      "types": "./dist/types/rabbitmq/index.d.ts",
+      "require": "./dist/cjs/rabbitmq/index.js",
+      "import": "./dist/esm/rabbitmq/index.js"
+    },
+    "./sqlite": {
+      "types": "./dist/types/sqlite/index.d.ts",
+      "require": "./dist/cjs/sqlite/index.js",
+      "import": "./dist/esm/sqlite/index.js"
+    }
+  },
   "directories": {
     "doc": "docs",
     "example": "examples",
     "test": "tests"
   },
-  "keywords": [
-    "cqrs",
-    "eventsourcing",
-    "ddd",
-    "domain",
-    "eventstore"
-  ],
-  "main": "src/index.js",
-  "types": "types/index.d.ts",
   "engines": {
-    "node": ">=10.3.0"
+    "node": ">=16.0.0"
   },
   "scripts": {
-    "lint": "eslint . --max-warnings=0",
-    "test": "mocha ./tests/unit/index.js ./examples/user-domain-tests",
-    "test:coverage": "nyc --reporter=lcov --reporter=text-summary node_modules/.bin/_mocha ./tests/unit/index.js",
-    "pretest:coveralls": "npm run test:coverage",
-    "test:coveralls": "cat ./coverage/lcov.info | coveralls",
-    "posttest:coveralls": "rm -rf ./coverage",
-    "changelog": "conventional-changelog -n ./scripts/changelog -i CHANGELOG.md -s",
-    "preversion": "npm run lint && npm test",
-    "version": "npm run changelog && git add CHANGELOG.md"
+    "cleanup": "rm -rf ./dist ./coverage",
+    "test": "jest",
+    "examples": "npm run example:user-domain-framework-free && npm run example:user-domain-ts && npm run example:sagas-simple && npm run example:sagas-overlaps && npm run example:user-domain-cjs && npm run example:workers-worker-projection && npm run example:browser",
+    "example:user-domain-ts": "node examples/user-domain/ts/index.ts",
+    "example:user-domain-framework-free": "node examples/user-domain/framework-free/index.ts",
+    "example:user-domain-cjs": "npm run build:cjs && node examples/user-domain/cjs/index.cjs",
+    "example:sagas-simple": "node examples/sagas/simple/index.ts",
+    "example:sagas-overlaps": "node examples/sagas/overlaps/index.ts",
+    "example:workers-worker-projection": "npm run build:cjs && node examples/workers/worker-projection/index.cjs",
+    "example:browser": "npm run build:browser && echo \"\nOpen ./examples/browser/index.html in your browser (check DevTools console)\n\"",
+    "pretest:examples": "npm run build:cjs",
+    "test:examples": "jest --roots='<rootDir>/examples'",
+    "test:coverage": "npm t -- --collect-coverage",
+    "test:rabbitmq": "jest --verbose --roots='<rootDir>/tests/integration/rabbitmq'",
+    "test:sqlite": "jest --verbose --roots='<rootDir>/tests/integration/sqlite'",
+    "pretest:workers": "npm run build:cjs",
+    "test:workers": "jest --verbose --roots='<rootDir>/tests/integration/workers'",
+    "changelog": "conventional-changelog -n ./scripts/changelog/index.cjs -r 0 > CHANGELOG.md",
+    "build:cjs": "tsc -p ./tsconfig.cjs.json && cp ./scripts/etc/cjs-package.json ./dist/cjs/package.json",
+    "build:esm": "tsc -p ./tsconfig.esm.json",
+    "build:browser:bundle-min": "rollup -c ./rollup.browser.config.mjs --environment MINIFY:true",
+    "build:browser:bundle": "rollup -c ./rollup.browser.config.mjs",
+    "build:browser": "npm run build:esm && npm run build:browser:bundle && npm run build:browser:bundle-min",
+    "build": "npm run build:esm && npm run build:cjs",
+    "prepare": "npm run build",
+    "preversion": "npm test",
+    "version": "./scripts/cleanup_obsolete_tags.sh v$npm_package_version && npm run changelog && git add CHANGELOG.md",
+    "lint": "eslint"
   },
   "author": "@snatalenko",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "homepage": "https://github.com/snatalenko/node-cqrs#readme",
+  "files": [
+    "dist/**",
+    "!dist/.tsbuildinfo*",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "CHANGELOG.md"
+  ],
   "dependencies": {
-    "di0": "^1.0.0"
+    "async-iterable-buffer": "^1.1.0",
+    "async-parallel-pipe": "^1.0.2",
+    "di0": "^1.3.0"
   },
   "devDependencies": {
-    "chai": "^4.3.6",
-    "coveralls": "^3.1.1",
-    "eslint": "^8.7.0",
-    "mocha": "^9.2.0",
-    "nyc": "^15.1.0",
-    "sinon": "^12.0.1"
+    "@rollup/plugin-commonjs": "^29.0.2",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^1.0.0",
+    "@types/amqplib": "^0.10.8",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/jest": "^29.5.14",
+    "@types/md5": "^2.3.6",
+    "@types/node": "^25.5.0",
+    "@typescript-eslint/eslint-plugin": "^8.29.0",
+    "@typescript-eslint/parser": "^8.29.0",
+    "amqplib": "^0.10.9",
+    "better-sqlite3": "^12.6.2",
+    "comlink": "^4.4.2",
+    "conventional-changelog": "^3.1.25",
+    "eslint": "^9.39.4",
+    "eslint-plugin-jest": "^28.14.0",
+    "globals": "^17.4.0",
+    "jest": "^29.7.0",
+    "md5": "^2.3.0",
+    "rollup": "^4.59.0",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.57.0"
+  },
+  "peerDependencies": {
+    "amqplib": "^0.10.9",
+    "better-sqlite3": "^12.6.2",
+    "comlink": "^4.4.2",
+    "md5": "^2.3.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "amqplib": {
+      "optional": true
+    },
+    "comlink": {
+      "optional": true
+    },
+    "md5": {
+      "optional": true
+    }
   }
 }

package/jsconfig.json

@@ -1,15 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es6",
-        "module": "commonjs",
-        "allowSyntheticDefaultImports": true,
-        "checkJs": true,
-        "resolveJsonModule": true,
-        "lib": [
-            "es2018"
-        ]
-    },
-    "exclude": [
-        "node_modules"
-    ]
-}