node-cqrs 1.0.0-rc.9 → 1.0.0

package/src/utils/getHandler.ts

@@ -1,20 +0,0 @@
-import { IMessageHandler } from '../interfaces';
-
-/**
- * Gets a handler for a specific message type, prefers a public (w\o _ prefix) method, if available
- */
-export function getHandler(context: { [key: string]: any }, messageType: string): IMessageHandler | null {
-	if (!context || typeof context !== 'object')
-		throw new TypeError('context argument required');
-	if (typeof messageType !== 'string' || !messageType.length)
-		throw new TypeError('messageType argument must be a non-empty string');
-
-	if (messageType in context && typeof context[messageType] === 'function')
-		return context[messageType].bind(context);
-
-	const privateHandlerName = `_${messageType}`;
-	if (privateHandlerName in context && typeof context[privateHandlerName] === 'function')
-		return context[privateHandlerName].bind(context);
-
-	return null;
-}

package/src/utils/getMessageHandlerNames.ts

@@ -1,38 +0,0 @@
-function getInheritedPropertyNames(prototype: object): string[] {
-	const parentPrototype = prototype && Object.getPrototypeOf(prototype);
-	if (!parentPrototype)
-		return [];
-
-	const propDescriptors = Object.getOwnPropertyDescriptors(parentPrototype);
-	const propNames = Object.keys(propDescriptors);
-
-	return [
-		...propNames,
-		...getInheritedPropertyNames(parentPrototype)
-	];
-}
-
-/**
- * Get message handler names from a command/event handler class.
- * Assumes all private method names start from underscore ("_").
- */
-export function getMessageHandlerNames(observerInstanceOrClass: (object | Function)): string[] {
-	if (!observerInstanceOrClass)
-		throw new TypeError('observerInstanceOrClass argument required');
-
-	const prototype = typeof observerInstanceOrClass === 'function' ?
-		observerInstanceOrClass.prototype :
-		Object.getPrototypeOf(observerInstanceOrClass);
-
-	if (!prototype)
-		throw new TypeError('prototype cannot be resolved');
-
-	const inheritedProperties = getInheritedPropertyNames(prototype);
-	const propDescriptors = Object.getOwnPropertyDescriptors(prototype);
-	const propNames = Object.keys(propDescriptors);
-
-	return propNames.filter(key =>
-		!key.startsWith('_') &&
-		!inheritedProperties.includes(key) &&
-		typeof propDescriptors[key].value === 'function');
-}

package/src/utils/index.ts

@@ -1,12 +0,0 @@
-export * from './Deferred';
-export * from './delay';
-export * from './getClassName';
-export * from './getHandler';
-export * from './getMessageHandlerNames';
-export * from './isClass';
-export * from './iteratorToArray';
-export * from './Lock';
-export * from './notEmpty';
-export * from './setupOneTimeEmitterSubscription';
-export * from './subscribe';
-export * from './validateHandlers';

package/src/utils/isClass.ts

@@ -1,4 +0,0 @@
-export function isClass(func: Function) {
-	return typeof func === 'function'
-		&& Function.prototype.toString.call(func).startsWith('class');
-}

package/src/utils/iteratorToArray.ts

@@ -1,6 +0,0 @@
-export async function iteratorToArray<T>(input: AsyncIterable<T> | Iterable<T>): Promise<T[]> {
-	const result: T[] = [];
-	for await (const item of input)
-		result.push(item);
-	return result;
-}

package/src/utils/notEmpty.ts

@@ -1 +0,0 @@
-export const notEmpty = <T>(t: T): t is Exclude<T, undefined | null> => t !== undefined && t !== null;

package/src/utils/setupOneTimeEmitterSubscription.ts

@@ -1,59 +0,0 @@
-import { IEvent, ILogger, IObservable } from '../interfaces';
-
-/**
- * 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 function setupOneTimeEmitterSubscription(
-	emitter: IObservable,
-	messageTypes: string[],
-	filter?: (e: IEvent) => boolean,
-	handler?: (e: IEvent) => void,
-	logger?: ILogger
-): Promise<IEvent> {
-	if (typeof emitter !== 'object' || !emitter)
-		throw new TypeError('emitter argument must be an Object');
-	if (!Array.isArray(messageTypes) || messageTypes.some(m => !m || typeof m !== 'string'))
-		throw new TypeError('messageTypes argument must be an Array of non-empty Strings');
-	if (handler && typeof handler !== 'function')
-		throw new TypeError('handler argument, when specified, must be a Function');
-	if (filter && typeof filter !== 'function')
-		throw new TypeError('filter argument, when specified, must be a Function');
-
-	return new Promise(resolve => {
-
-		// handler will be invoked only once,
-		// even if multiple events have been emitted before subscription was destroyed
-		// https://nodejs.org/api/events.html#events_emitter_removelistener_eventname_listener
-		let handled = false;
-
-		function filteredHandler(event: IEvent) {
-			if (filter && !filter(event))
-				return;
-			if (handled)
-				return;
-			handled = true;
-
-			for (const messageType of messageTypes)
-				emitter.off(messageType, filteredHandler);
-
-			logger?.debug(`'${event.type}' received, one-time subscription to '${messageTypes.join(',')}' removed`);
-
-			if (handler)
-				handler(event);
-
-			resolve(event);
-		}
-
-		for (const messageType of messageTypes)
-			emitter.on(messageType, filteredHandler);
-
-		logger?.debug(`set up one-time ${filter ? 'filtered subscription' : 'subscription'} to '${messageTypes.join(',')}'`);
-	});
-}

package/src/utils/subscribe.ts

@@ -1,65 +0,0 @@
-import { IMessageHandler, IObservable } from '../interfaces';
-import { getHandler } from './getHandler';
-import { getMessageHandlerNames } from './getMessageHandlerNames';
-
-const unique = <T>(arr: T[]): T[] => [...new Set(arr)];
-
-/**
- * Get a list of message types handled by observer
- */
-export function getHandledMessageTypes(observerInstanceOrClass: (object | Function)): string[] {
-	if (!observerInstanceOrClass)
-		throw new TypeError('observerInstanceOrClass argument required');
-
-	const prototype = Object.getPrototypeOf(observerInstanceOrClass);
-	if (prototype && prototype.constructor && prototype.constructor.handles)
-		return prototype.constructor.handles;
-
-	return getMessageHandlerNames(observerInstanceOrClass);
-}
-
-/**
- * Subscribe observer to observable
- */
-export function subscribe(
-	observable: IObservable,
-	observer: object,
-	options: {
-		messageTypes?: string[],
-		masterHandler?: IMessageHandler,
-		queueName?: string
-	} = {}
-) {
-	if (typeof observable !== 'object' || !observable)
-		throw new TypeError('observable argument must be an Object');
-	if (typeof observable.on !== 'function')
-		throw new TypeError('observable.on must be a Function');
-	if (typeof observer !== 'object' || !observer)
-		throw new TypeError('observer argument must be an Object');
-
-	const { masterHandler, messageTypes, queueName } = options;
-	if (masterHandler && typeof masterHandler !== 'function')
-		throw new TypeError('masterHandler parameter, when provided, must be a Function');
-	if (queueName && typeof observable.queue !== 'function')
-		throw new TypeError('observable.queue, when queueName is specified, must be a Function');
-
-	const subscribeTo = messageTypes || getHandledMessageTypes(observer);
-	if (!Array.isArray(subscribeTo))
-		throw new TypeError('either options.messageTypes, observer.handles or ObserverType.handles is required');
-
-	for (const messageType of unique(subscribeTo)) {
-		const handler = masterHandler || getHandler(observer, messageType);
-		if (!handler)
-			throw new Error(`'${messageType}' handler is not defined or not a function`);
-
-		if (queueName) {
-			if (!observable.queue)
-				throw new TypeError('Observer does not support named queues');
-
-			observable.queue(queueName).on(messageType, handler);
-		}
-		else {
-			observable.on(messageType, handler);
-		}
-	}
-}

package/src/utils/validateHandlers.ts

@@ -1,20 +0,0 @@
-import { getHandler } from './getHandler';
-
-/**
- * Ensure instance has handlers declared for all handled message types
- */
-export function validateHandlers(instance: object, handlesFieldName = 'handles') {
-	if (!instance)
-		throw new TypeError('instance argument required');
-
-	const messageTypes = Object.getPrototypeOf(instance).constructor[handlesFieldName];
-	if (messageTypes === undefined)
-		return;
-	if (!Array.isArray(messageTypes))
-		throw new TypeError('handles getter, when defined, must return an Array of Strings');
-
-	for (const type of messageTypes) {
-		if (!getHandler(instance, type))
-			throw new Error(`'${type}' handler is not defined or not a function`);
-	}
-}

package/types/AbstractAggregate.d.ts

@@ -1,57 +0,0 @@
-import { IAggregate, IMutableAggregateState, ICommand, Identifier, IEvent, IEventSet, IAggregateConstructorParams } from './interfaces';
-/**
- * Base class for Aggregate definition
- */
-export declare abstract class AbstractAggregate<TState extends IMutableAggregateState | object | 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[];
-    /** 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;
-    /** Events emitted by Aggregate */
-    get changes(): IEventSet;
-    /**
-     * Override to define whether an aggregate state snapshot should be taken
-     *
-     * @example
-     * 	// create snapshot every 50 events
-     * 	return this.version % 50 === 0;
-     */
-    get shouldTakeSnapshot(): boolean;
-    constructor(options: IAggregateConstructorParams<TState>);
-    /** Pass command to command handler */
-    handle(command: ICommand): any;
-    /** Mutate aggregate state and increment aggregate version */
-    mutate(event: IEvent): void;
-    /** Format and register aggregate event and mutate aggregate state */
-    protected emit<TPayload>(type: string, payload?: TPayload): void;
-    /** 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;
-    /**
-     * Take an aggregate state snapshot and add it to the changes queue
-     */
-    takeSnapshot(): void;
-    /** Create an aggregate state snapshot */
-    makeSnapshot(): TState;
-    /** Restore aggregate state from a snapshot */
-    protected restoreSnapshot(snapshotEvent: IEvent<TState>): void;
-    /** Get human-readable aggregate identifier */
-    toString(): string;
-}

package/types/AbstractProjection.d.ts

@@ -1,60 +0,0 @@
-import { IViewLocker, IEventLocker, IProjection, ILogger, IExtendableLogger, IEventStore, IEvent } from './interfaces';
-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 | undefined;
-    protected set _viewLocker(value: IViewLocker | undefined);
-    /**
-     * Tracks event processing state to prevent concurrent handling by multiple processes.
-     */
-    protected get _eventLocker(): IEventLocker | undefined;
-    protected set _eventLocker(value: IEventLocker | undefined);
-    constructor({ view, viewLocker, eventLocker, logger }?: AbstractProjectionParams<TView>);
-    /** Subscribe to event store */
-    subscribe(eventStore: IEventStore): Promise<void>;
-    /** Pass event to projection event handler */
-    project(event: IEvent): Promise<void>;
-    /** Pass event to projection event handler, without awaiting for restore operation to complete */
-    protected _project(event: IEvent): Promise<void>;
-    /** Restore projection view from event store */
-    restore(eventStore: IEventStore): Promise<void>;
-    /** Restore projection view from event store */
-    protected _restore(eventStore: IEventStore): Promise<void>;
-    /** Handle error on restoring. Logs and throws error by default */
-    protected _onRestoringError(error: Error, event: IEvent): void;
-}

package/types/AbstractSaga.d.ts

@@ -1,31 +0,0 @@
-import { ICommand, Identifier, IEvent, ISaga, ISagaConstructorParams } from './interfaces';
-/**
- * Base class for Saga definition
- */
-export declare abstract class AbstractSaga implements ISaga {
-    #private;
-    /** List of events that start new saga, must be overridden in Saga implementation */
-    static get startsWith(): string[];
-    /** List of event types being handled by Saga, must be overridden in Saga implementation */
-    static get handles(): string[];
-    /** Saga ID */
-    get id(): Identifier;
-    /** Saga version */
-    get version(): number;
-    /** Command execution queue */
-    get uncommittedMessages(): ICommand[];
-    /**
-     * Creates an instance of AbstractSaga
-     */
-    constructor(options: ISagaConstructorParams);
-    /** Modify saga state by applying an event */
-    apply(event: IEvent): Promise<void> | void;
-    /** Format a command and put it to the execution queue */
-    protected enqueue(commandType: string, aggregateId: Identifier | undefined, payload: object): void;
-    /** Put a command to the execution queue */
-    protected enqueueRaw(command: ICommand): void;
-    /** Clear the execution queue */
-    resetUncommittedMessages(): void;
-    /** Get human-readable Saga name */
-    toString(): string;
-}

package/types/AggregateCommandHandler.d.ts

@@ -1,20 +0,0 @@
-import { IAggregateConstructor, IAggregateFactory, ICommand, ICommandBus, ICommandHandler, IContainer, IEventSet } from './interfaces';
-/**
- * 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 implements ICommandHandler {
-    #private;
-    constructor({ eventStore, aggregateType, aggregateFactory, handles, logger }: Pick<IContainer, 'eventStore' | 'logger'> & {
-        aggregateType?: IAggregateConstructor<any>;
-        aggregateFactory?: IAggregateFactory<any>;
-        handles?: string[];
-    });
-    /** Subscribe to all command types handled by aggregateType */
-    subscribe(commandBus: ICommandBus): void;
-    /** Pass a command to corresponding aggregate */
-    execute(cmd: ICommand): Promise<IEventSet>;
-}

package/types/CommandBus.d.ts

@@ -1,27 +0,0 @@
-import { ICommand, ICommandBus, IEventSet, IExtendableLogger, ILogger, IMessageBus, IMessageHandler } from './interfaces';
-export declare class CommandBus implements ICommandBus {
-    #private;
-    constructor(o?: {
-        messageBus?: IMessageBus;
-        logger?: ILogger | IExtendableLogger;
-    });
-    /**
-     * Set up a command handler
-     */
-    on(commandType: string, handler: IMessageHandler): void;
-    /**
-     * Remove previously installed command handler
-     */
-    off(commandType: string, handler: IMessageHandler): void;
-    /**
-     * Format and send a command for execution
-     */
-    send<TPayload>(type: string, aggregateId: string, options: {
-        payload: TPayload;
-        context: object;
-    }, ...otherArgs: object[]): Promise<IEventSet>;
-    /**
-     * Send a command for execution
-     */
-    sendRaw<TPayload>(command: ICommand<TPayload>): Promise<IEventSet>;
-}

package/types/CqrsContainerBuilder.d.ts

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

package/types/Event.d.ts

@@ -1,13 +0,0 @@
-import { IEvent } from './interfaces';
-/**
- * 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;
-/**
- * Validate event structure
- */
-export declare function validate(event: IEvent): void;

package/types/EventDispatcher.d.ts

@@ -1,32 +0,0 @@
-import { IEventDispatcher, IDispatchPipelineProcessor, IEventSet, IEventBus, IContainer } from './interfaces';
-export declare class EventDispatcher implements IEventDispatcher {
-    #private;
-    /**
-     * Event bus where dispatched messages are delivered after processing.
-     *
-     * If not provided in the constructor, defaults to an instance of `InMemoryMessageBus`.
-     */
-    eventBus: IEventBus;
-    /**
-     * Maximum number of event batches that each pipeline processor can handle in parallel.
-     */
-    concurrentLimit: number;
-    constructor(o?: Pick<IContainer, 'eventBus' | 'eventDispatchPipeline'> & {
-        eventDispatcherConfig?: {
-            concurrentLimit?: number;
-        };
-    });
-    addPipelineProcessors(eventDispatchPipeline: IDispatchPipelineProcessor[]): void;
-    /**
-     * Adds a preprocessor to the event dispatch pipeline.
-     *
-     * Preprocessors run in order they are added but process separate batches in parallel, maintaining FIFO order.
-     */
-    addPipelineProcessor(preprocessor: IDispatchPipelineProcessor): void;
-    /**
-     * Dispatch a set of events through the processing pipeline.
-     *
-     * Returns a promise that resolves after all events are processed and published.
-     */
-    dispatch(events: IEventSet, meta?: Record<string, any>): Promise<IEventSet>;
-}

package/types/EventStore.d.ts

@@ -1,34 +0,0 @@
-import { IEvent, IEventSet, IMessageHandler, IObservable, IEventStream, IEventStore, EventQueryAfter, EventQueryBefore, Identifier, IEventBus, IContainer } from './interfaces';
-export declare class EventStore implements IEventStore {
-    #private;
-    eventBus: IEventBus;
-    constructor({ eventStorageReader, identifierProvider, snapshotStorage, eventBus, eventDispatcher, logger }: Pick<IContainer, 'identifierProvider' | 'eventStorageReader' | 'snapshotStorage' | 'eventBus' | 'eventDispatcher' | 'logger'>);
-    /**
-     * Generates and returns a new unique identifier using the configured identifier provider.
-     *
-     * @returns A promise resolving to a unique identifier suitable for aggregates, sagas, and events.
-     */
-    getNewId(): Promise<Identifier>;
-    getEventsByTypes(eventTypes: Readonly<string[]>, options?: EventQueryAfter): IEventStream;
-    /** Retrieve all events of specific Aggregate */
-    getAggregateEvents(aggregateId: Identifier): IEventStream;
-    /** Retrieve events of specific Saga */
-    getSagaEvents(sagaId: Identifier, filter: EventQueryBefore): AsyncGenerator<Readonly<IEvent>, void, any>;
-    /**
-     * Register event types that start sagas.
-     * Upon such event commit a new sagaId will be assigned
-     */
-    registerSagaStarters(eventTypes?: string[]): void;
-    /**
-     * Validate events, commit to storage and publish to messageBus, if needed
-     *
-     * @param events - a set of events to commit
-     * @returns Signed and committed events
-     */
-    dispatch(events: IEventSet): Promise<IEventSet>;
-    on(messageType: string, handler: IMessageHandler): void;
-    off(messageType: string, handler: IMessageHandler): void;
-    queue(name: string): IObservable;
-    /** Creates one-time subscription for one or multiple events that match a filter */
-    once(messageTypes: string | string[], handler?: IMessageHandler, filter?: (e: IEvent) => boolean): Promise<IEvent>;
-}

package/types/EventValidationProcessor.d.ts

@@ -1,19 +0,0 @@
-import { DispatchPipelineBatch, IEvent, IDispatchPipelineProcessor } from './interfaces';
-export type EventValidator = (event: IEvent) => void;
-/**
- * Processor that validates the format of events.
- * Rejects the batch if any event fails validation.
- */
-export declare class EventValidationProcessor implements IDispatchPipelineProcessor {
-    #private;
-    constructor(o?: {
-        eventFormatValidator?: EventValidator;
-    });
-    /**
-     * Processes a batch of dispatch pipeline items by validating each event within the batch.
-     * It iterates through the batch and calls the private `#validate` method for each event found.
-     *
-     * This method is part of the `IDispatchPipelineProcessor` interface.
-     */
-    process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch>;
-}

package/types/SagaEventHandler.d.ts

@@ -1,21 +0,0 @@
-import { IContainer, IEvent, IEventReceptor, IObservable, ISagaConstructor, ISagaFactory } from './interfaces';
-/**
- * Listens to Saga events,
- * creates new saga or restores it from event store,
- * applies new events
- * and passes command(s) to command bus
- */
-export declare class SagaEventHandler implements IEventReceptor {
-    #private;
-    constructor(options: Pick<IContainer, 'eventStore' | 'commandBus' | 'logger'> & {
-        sagaType?: ISagaConstructor;
-        sagaFactory?: ISagaFactory;
-        queueName?: string;
-        startsWith?: string[];
-        handles?: string[];
-    });
-    /** Overrides observer subscribe method */
-    subscribe(eventStore: IObservable): void;
-    /** Handle saga event */
-    handle(event: IEvent): Promise<void>;
-}

package/types/in-memory/InMemoryEventStorage.d.ts

@@ -1,24 +0,0 @@
-import { IIdentifierProvider, IEvent, IEventSet, EventQueryAfter, IEventStorageReader, IEventStream, IEventStorageWriter, Identifier, IDispatchPipelineProcessor, DispatchPipelineBatch } from '../interfaces';
-/**
- * A simple event storage implementation intended to use for tests only.
- * Storage content resets on each app restart.
- */
-export declare class InMemoryEventStorage implements IEventStorageReader, IEventStorageWriter, IIdentifierProvider, IDispatchPipelineProcessor {
-    #private;
-    getNewId(): string;
-    commitEvents(events: IEventSet): Promise<IEventSet>;
-    getAggregateEvents(aggregateId: Identifier, options?: {
-        snapshot: IEvent;
-    }): IEventStream;
-    getSagaEvents(sagaId: Identifier, { beforeEvent }: {
-        beforeEvent: IEvent;
-    }): IEventStream;
-    getEventsByTypes(eventTypes: Readonly<string[]>, options?: EventQueryAfter): IEventStream;
-    /**
-     * Processes a batch of dispatch pipeline items, extracts the events,
-     * commits them to the in-memory storage, and returns the original batch.
-     *
-     * This method is part of the `IDispatchPipelineProcessor` interface.
-     */
-    process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch>;
-}

package/types/in-memory/InMemoryLock.d.ts

@@ -1,21 +0,0 @@
-export declare class InMemoryLock {
-    #private;
-    /**
-     * Indicates if lock is acquired
-     */
-    get locked(): boolean;
-    /**
-     * Acquire the lock on the current instance.
-     * Resolves when the lock is successfully acquired
-     */
-    lock(): Promise<void>;
-    /**
-     * Release the lock acquired earlier
-     */
-    unlock(): Promise<void>;
-    /**
-     * Wait until the lock is released.
-     * Resolves immediately if the lock is not acquired
-     */
-    once(event: 'unlocked'): Promise<void>;
-}