node-cqrs 1.0.0-rc.8 → 1.0.0

package/src/SagaEventHandler.ts

@@ -1,160 +0,0 @@
-import * as Event from './Event';
-import {
-	ICommandBus,
-	IContainer,
-	IEvent,
-	IEventReceptor,
-	IEventStore,
-	ILogger,
-	IObservable,
-	ISaga,
-	ISagaConstructor,
-	ISagaFactory
-} from './interfaces';
-
-import {
-	subscribe,
-	getClassName,
-	iteratorToArray
-} from './utils';
-
-/**
- * Listens to Saga events,
- * creates new saga or restores it from event store,
- * applies new events
- * and passes command(s) to command bus
- */
-export class SagaEventHandler implements IEventReceptor {
-
-	#eventStore: IEventStore;
-	#commandBus: ICommandBus;
-	#queueName?: string;
-	#logger?: ILogger;
-	#sagaFactory: (params: any) => ISaga;
-	#startsWith: string[];
-	#handles: string[];
-
-	constructor(options: Pick<IContainer, 'eventStore' | 'commandBus' | 'logger'> & {
-		sagaType?: ISagaConstructor,
-		sagaFactory?: ISagaFactory,
-		queueName?: string,
-		startsWith?: string[],
-		handles?: string[]
-	}) {
-		if (!options)
-			throw new TypeError('options argument required');
-		if (!options.eventStore)
-			throw new TypeError('options.eventStore argument required');
-		if (!options.commandBus)
-			throw new TypeError('options.commandBus argument required');
-
-		this.#eventStore = options.eventStore;
-		this.#commandBus = options.commandBus;
-		this.#queueName = options.queueName;
-		this.#logger = options.logger && 'child' in options.logger ?
-			options.logger.child({ service: getClassName(this) }) :
-			options.logger;
-
-		if (options.sagaType) {
-			const SagaType = options.sagaType as ISagaConstructor;
-
-			this.#sagaFactory = params => new SagaType(params);
-			this.#startsWith = SagaType.startsWith;
-			this.#handles = SagaType.handles;
-		}
-		else if (options.sagaFactory) {
-			if (!Array.isArray(options.startsWith))
-				throw new TypeError('options.startsWith argument must be an Array');
-			if (!Array.isArray(options.handles))
-				throw new TypeError('options.handles argument must be an Array');
-
-			this.#sagaFactory = options.sagaFactory;
-			this.#startsWith = options.startsWith;
-			this.#handles = options.handles;
-		}
-		else {
-			throw new Error('Either sagaType or sagaFactory is required');
-		}
-
-		this.#eventStore.registerSagaStarters(options.startsWith);
-	}
-
-	/** Overrides observer subscribe method */
-	subscribe(eventStore: IObservable) {
-		subscribe(eventStore, this, {
-			messageTypes: [...this.#startsWith, ...this.#handles],
-			masterHandler: e => this.handle(e),
-			queueName: this.#queueName
-		});
-	}
-
-	/** Handle saga event */
-	async handle(event: IEvent): Promise<void> {
-		if (!event)
-			throw new TypeError('event argument required');
-		if (!event.type)
-			throw new TypeError('event.type argument required');
-
-		const isSagaStarterEvent = this.#startsWith.includes(event.type);
-		const saga = isSagaStarterEvent ?
-			await this.#createSaga() :
-			await this.#restoreSaga(event);
-
-		const r = saga.apply(event);
-		if (r instanceof Promise)
-			await r;
-
-		await this.#sendCommands(saga, event);
-
-		// additional commands can be added by the saga.onError handler
-		if (saga.uncommittedMessages.length)
-			await this.#sendCommands(saga, event);
-	}
-
-	async #sendCommands(saga: ISaga, event: IEvent<any>) {
-		const commands = saga.uncommittedMessages;
-		saga.resetUncommittedMessages();
-
-		this.#logger?.debug(`"${Event.describe(event)}" processed, ${commands.map(c => c.type).join(',') || 'no commands'} produced`);
-
-		for (const command of commands) {
-
-			// attach event context to produced command
-			if (command.context === undefined && event.context !== undefined)
-				command.context = event.context;
-
-			try {
-				await this.#commandBus.sendRaw(command);
-			}
-			catch (err: any) {
-				if (typeof saga.onError === 'function') {
-					// let saga to handle the error
-					saga.onError(err, { event, command });
-				}
-				else {
-					throw err;
-				}
-			}
-		}
-	}
-
-	/** Start new saga */
-	async #createSaga(): Promise<ISaga> {
-		const id = await this.#eventStore.getNewId();
-		return this.#sagaFactory.call(null, { id });
-	}
-
-	/** Restore saga from event store */
-	async #restoreSaga(event: IEvent): Promise<ISaga> {
-		if (!event.sagaId)
-			throw new TypeError(`${Event.describe(event)} does not contain sagaId`);
-
-		const eventsIterable = this.#eventStore.getSagaEvents(event.sagaId, { beforeEvent: event });
-		const events = await iteratorToArray(eventsIterable);
-
-		const saga = this.#sagaFactory.call(null, { id: event.sagaId, events });
-		this.#logger?.info(`Saga state restored from ${events.length} event(s)`);
-
-		return saga;
-	}
-}

package/src/in-memory/InMemoryEventStorage.ts

@@ -1,108 +0,0 @@
-import {
-	IIdentifierProvider,
-	IEvent,
-	IEventSet,
-	EventQueryAfter,
-	IEventStorageReader,
-	IEventStream,
-	IEventStorageWriter,
-	Identifier,
-	IDispatchPipelineProcessor,
-	DispatchPipelineBatch
-} from '../interfaces';
-import { nextCycle } from './utils';
-
-/**
- * A simple event storage implementation intended to use for tests only.
- * Storage content resets on each app restart.
- */
-export class InMemoryEventStorage implements
-	IEventStorageReader,
-	IEventStorageWriter,
-	IIdentifierProvider,
-	IDispatchPipelineProcessor {
-
-	#nextId: number = 0;
-	#events: IEventSet = [];
-
-	getNewId(): string {
-		this.#nextId += 1;
-		return String(this.#nextId);
-	}
-
-	async commitEvents(events: IEventSet): Promise<IEventSet> {
-		await nextCycle();
-
-		this.#events = this.#events.concat(events);
-
-		await nextCycle();
-
-		return events;
-	}
-
-	async* getAggregateEvents(aggregateId: Identifier, options?: { snapshot: IEvent }): IEventStream {
-		await nextCycle();
-
-		const afterVersion = options?.snapshot?.aggregateVersion;
-		const results = !afterVersion ?
-			this.#events.filter(e => e.aggregateId === aggregateId) :
-			this.#events.filter(e =>
-				e.aggregateId === aggregateId &&
-				e.aggregateVersion !== undefined &&
-				e.aggregateVersion > afterVersion);
-
-		await nextCycle();
-
-		yield* results;
-	}
-
-	async* getSagaEvents(sagaId: Identifier, { beforeEvent }: { beforeEvent: IEvent }): IEventStream {
-		await nextCycle();
-
-		const results = this.#events.filter(e =>
-			e.sagaId === sagaId &&
-			e.sagaVersion !== undefined &&
-			beforeEvent.sagaVersion !== undefined &&
-			e.sagaVersion < beforeEvent.sagaVersion);
-
-		await nextCycle();
-
-		yield* results;
-	}
-
-	async* getEventsByTypes(eventTypes: Readonly<string[]>, options?: EventQueryAfter): IEventStream {
-		await nextCycle();
-
-		const lastEventId = options?.afterEvent?.id;
-		if (options?.afterEvent && !lastEventId)
-			throw new TypeError('options.afterEvent.id is required');
-
-		let offsetFound = !lastEventId;
-		for (const event of this.#events) {
-			if (!offsetFound)
-				offsetFound = event.id === lastEventId;
-			else if (!eventTypes || eventTypes.includes(event.type))
-				yield event;
-		}
-	}
-
-	/**
-	 * 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.
-	 */
-	async process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch> {
-		const events: IEvent[] = [];
-		for (const { event } of batch) {
-			if (!event)
-				throw new Error('Event batch does not contain `event`');
-
-			events.push(event);
-		}
-
-		await this.commitEvents(events);
-
-		return batch;
-	}
-}

package/src/in-memory/InMemoryLock.ts

@@ -1,43 +0,0 @@
-import { Deferred } from '../utils';
-
-export class InMemoryLock {
-
-	#lockMarker: Deferred<void> | undefined;
-
-	/**
-	 * Indicates if lock is acquired
-	 */
-	get locked(): boolean {
-		return !!this.#lockMarker;
-	}
-
-	/**
-	 * Acquire the lock on the current instance.
-	 * Resolves when the lock is successfully acquired
-	 */
-	async lock(): Promise<void> {
-		while (this.locked)
-			await this.once('unlocked');
-
-		this.#lockMarker = new Deferred();
-	}
-
-	/**
-	 * Release the lock acquired earlier
-	 */
-	async unlock(): Promise<void> {
-		this.#lockMarker?.resolve();
-		this.#lockMarker = undefined;
-	}
-
-	/**
-	 * Wait until the lock is released.
-	 * Resolves immediately if the lock is not acquired
-	 */
-	once(event: 'unlocked'): Promise<void> {
-		if (event !== 'unlocked')
-			throw new TypeError(`Unexpected event type: ${event}`);
-
-		return this.#lockMarker?.promise ?? Promise.resolve();
-	}
-}

package/src/in-memory/InMemoryMessageBus.ts

@@ -1,140 +0,0 @@
-import {
-	DispatchPipelineBatch,
-	ICommand,
-	IDispatchPipelineProcessor,
-	IEvent,
-	IMessageBus,
-	IMessageHandler,
-	IObservable
-} from '../interfaces';
-
-/**
- * Default implementation of the message bus.
- * Keeps all subscriptions and messages in memory.
- */
-export class InMemoryMessageBus implements IMessageBus, IDispatchPipelineProcessor {
-
-	protected handlers: Map<string, Set<IMessageHandler>> = new Map();
-	protected uniqueEventHandlers: boolean;
-	protected queueName: string | undefined;
-	protected queues: Map<string, IMessageBus> = new Map();
-
-	constructor({ queueName, uniqueEventHandlers = !!queueName }: {
-		queueName?: string,
-		uniqueEventHandlers?: boolean
-	} = {}) {
-		this.queueName = queueName;
-		this.uniqueEventHandlers = uniqueEventHandlers;
-	}
-
-	/**
-	 * Subscribe to message type
-	 */
-	on(messageType: string, handler: IMessageHandler) {
-		if (typeof messageType !== 'string' || !messageType.length)
-			throw new TypeError('messageType argument must be a non-empty String');
-		if (typeof handler !== 'function')
-			throw new TypeError('handler argument must be a Function');
-		if (arguments.length !== 2)
-			throw new TypeError(`2 arguments are expected, but ${arguments.length} received`);
-
-		// Events published to a named queue must be consumed only once.
-		// For example, for sending a welcome email, NotificationReceptor will subscribe to "notifications:userCreated".
-		// Since we use an in-memory bus, there is no need to track message handling by multiple distributed
-		// subscribers, and we only need to make sure that no more than 1 such subscriber will be created
-		if (!this.handlers.has(messageType))
-			this.handlers.set(messageType, new Set());
-		else if (this.uniqueEventHandlers)
-			throw new Error(`"${messageType}" handler is already set up on the "${this.queueName}" queue`);
-
-		this.handlers.get(messageType)?.add(handler);
-	}
-
-	/**
-	 * Get or create a named queue.
-	 * Named queues support only one handler per event type.
-	 */
-	queue(queueName: string): IObservable {
-		let queue = this.queues.get(queueName);
-		if (!queue) {
-			queue = new InMemoryMessageBus({ queueName, uniqueEventHandlers: true });
-			this.queues.set(queueName, queue);
-		}
-
-		return queue;
-	}
-
-	/**
-	 * Remove subscription
-	 */
-	off(messageType: string, handler: IMessageHandler) {
-		if (typeof messageType !== 'string' || !messageType.length)
-			throw new TypeError('messageType argument must be a non-empty String');
-		if (typeof handler !== 'function')
-			throw new TypeError('handler argument must be a Function');
-		if (arguments.length !== 2)
-			throw new TypeError(`2 arguments are expected, but ${arguments.length} received`);
-		if (!this.handlers.has(messageType))
-			throw new Error(`No ${messageType} subscribers found`);
-
-		this.handlers.get(messageType)?.delete(handler);
-	}
-
-	/**
-	 * Send command to exactly 1 command handler
-	 */
-	async send(command: ICommand): Promise<any> {
-		if (typeof command !== 'object' || !command)
-			throw new TypeError('command argument must be an Object');
-		if (typeof command.type !== 'string' || !command.type.length)
-			throw new TypeError('command.type argument must be a non-empty String');
-
-		const handlers = this.handlers.get(command.type);
-		if (!handlers || !handlers.size)
-			throw new Error(`No '${command.type}' subscribers found`);
-		if (handlers.size > 1)
-			throw new Error(`More than one '${command.type}' subscriber found`);
-
-		const commandHandler = handlers.values().next().value;
-
-		return commandHandler!(command);
-	}
-
-	/**
-	 * Publish event to all subscribers (if any)
-	 */
-	async publish(event: IEvent, meta?: Record<string, any>): Promise<any> {
-		if (typeof event !== 'object' || !event)
-			throw new TypeError('event argument must be an Object');
-		if (typeof event.type !== 'string' || !event.type.length)
-			throw new TypeError('event.type argument must be a non-empty String');
-
-		const handlers = [
-			...this.handlers.get(event.type) || [],
-			...Array.from(this.queues.values()).map(namedQueue =>
-				(e: IEvent, m?: Record<string, any>) => namedQueue.publish(e, m))
-		];
-
-		return Promise.all(handlers.map(handler => handler(event, meta)));
-	}
-
-	/**
-	 * Processes a batch of events and publishes them to the fanout exchange.
-	 *
-	 * This method is part of the `IDispatchPipelineProcessor` interface.
-	 */
-	async process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch> {
-		for (const { event, origin } of batch) {
-			// Skip publishing if the event was dispatched from external source
-			if (origin === 'external')
-				continue;
-
-			if (!event)
-				throw new Error('Event batch does not contain `event`');
-
-			await this.publish(event);
-		}
-
-		return batch;
-	}
-}

package/src/in-memory/InMemorySnapshotStorage.ts

@@ -1,89 +0,0 @@
-import {
-	DispatchPipelineBatch,
-	IAggregateSnapshotStorage,
-	IContainer,
-	Identifier,
-	IDispatchPipelineProcessor,
-	IEvent,
-	ILogger
-} from '../interfaces';
-import * as Event from '../Event';
-
-const SNAPSHOT_EVENT_TYPE = 'snapshot';
-const isSnapshotEvent = (event?: IEvent): event is IEvent & { type: 'snapshot' } =>
-	(!!event && event.type === SNAPSHOT_EVENT_TYPE);
-
-/**
- * In-memory storage for aggregate snapshots.
- * Storage content resets on app restart
- */
-export class InMemorySnapshotStorage implements IAggregateSnapshotStorage, IDispatchPipelineProcessor {
-
-	#snapshots: Map<Identifier, IEvent> = new Map();
-	#logger: ILogger | undefined;
-
-	constructor(c?: Partial<Pick<IContainer, 'logger'>>) {
-		this.#logger = c?.logger && 'child' in c?.logger ?
-			c?.logger.child({ service: new.target.name }) :
-			c?.logger;
-	}
-
-	/**
-	 * Get latest aggregate snapshot
-	 */
-	async getAggregateSnapshot(aggregateId: string): Promise<IEvent | undefined> {
-		return this.#snapshots.get(aggregateId);
-	}
-
-	/**
-	 * Save new aggregate snapshot
-	 */
-	async saveAggregateSnapshot(snapshotEvent: IEvent) {
-		if (!snapshotEvent.aggregateId)
-			throw new TypeError('event.aggregateId is required');
-
-		this.#logger?.debug(`Persisting ${Event.describe(snapshotEvent)}`);
-
-		this.#snapshots.set(snapshotEvent.aggregateId, snapshotEvent);
-	}
-
-	/**
-	 * Delete aggregate snapshot
-	 */
-	deleteAggregateSnapshot<TState>(snapshotEvent: IEvent<TState>): Promise<void> | void {
-		if (!snapshotEvent.aggregateId)
-			throw new TypeError('snapshotEvent.aggregateId argument required');
-
-		this.#logger?.debug(`Removing ${Event.describe(snapshotEvent)}`);
-
-		this.#snapshots.delete(snapshotEvent.aggregateId);
-	}
-
-	/**
-	 * Processes a batch of events, saves any snapshot events found, and returns the batch
-	 * without the snapshot events.
-	 *
-	 * This method is part of the `IDispatchPipelineProcessor` interface.
-	 */
-	async process(batch: DispatchPipelineBatch): Promise<DispatchPipelineBatch> {
-		const snapshotEvents = batch.map(e => e.event).filter(isSnapshotEvent);
-		for (const event of snapshotEvents)
-			await this.saveAggregateSnapshot(event);
-
-		return batch.filter(e => !isSnapshotEvent(e.event));
-	}
-
-	/**
-	 * Reverts the snapshots associated with the events in the given batch.
-	 * It filters the batch for snapshot events and deletes the corresponding aggregate snapshots.
-	 *
-	 * This method is part of the `IDispatchPipelineProcessor` interface.
-	 *
-	 * @param batch The batch of events to revert snapshots for.
-	 */
-	async revert(batch: DispatchPipelineBatch): Promise<void> {
-		const snapshotEvents = batch.map(e => e.event).filter(isSnapshotEvent);
-		for (const snapshotEvent of snapshotEvents)
-			await this.deleteAggregateSnapshot(snapshotEvent);
-	}
-}