node-cqrs 0.17.0 → 1.0.0-beta.1

package/src/infrastructure/InMemoryMessageBus.ts

@@ -1,118 +0,0 @@
-import {
-	ICommand,
-	IEvent,
-	IMessageBus,
-	IMessageHandler,
-	IObservable
-} from "../interfaces";
-
-/**
- * Default implementation of the message bus.
- * Keeps all subscriptions and messages in memory.
- */
-export class InMemoryMessageBus implements IMessageBus {
-
-	#handlers: Map<string, Set<IMessageHandler>> = new Map();
-	#name: string | undefined;
-	#uniqueEventHandlers: boolean;
-	#queues: Map<string, InMemoryMessageBus> = new Map();
-
-	constructor({ name, uniqueEventHandlers = !!name }: {
-		name?: string,
-		uniqueEventHandlers?: boolean
-	} = {}) {
-		this.#name = name;
-		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.#name}" queue`);
-
-		this.#handlers.get(messageType)?.add(handler);
-	}
-
-	/**
-	 * Get or create a named queue.
-	 * Named queues support only one handler per event type.
-	 */
-	queue(name: string): IObservable {
-		let queue = this.#queues.get(name);
-		if (!queue) {
-			queue = new InMemoryMessageBus({ name, uniqueEventHandlers: true });
-			this.#queues.set(name, 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): 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) => namedQueue.publish(e))
-		];
-
-		return Promise.all(handlers.map(handler => handler(event)));
-	}
-}

package/src/infrastructure/InMemorySnapshotStorage.ts

@@ -1,27 +0,0 @@
-import { IAggregateSnapshotStorage, Identifier, IEvent } from "../interfaces";
-
-/**
- * In-memory storage for aggregate snapshots.
- * Storage content resets on app restart
- */
-export class InMemorySnapshotStorage implements IAggregateSnapshotStorage {
-
-	#snapshots: Map<Identifier, IEvent> = new Map();
-
-	/**
-	 * Get latest aggregate snapshot
-	 */
-	async getAggregateSnapshot(aggregateId: Identifier): 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.#snapshots.set(snapshotEvent.aggregateId, snapshotEvent);
-	}
-}

package/src/infrastructure/InMemoryView.ts

@@ -1,221 +0,0 @@
-import { InMemoryLock } from './InMemoryLock';
-import { IProjectionView, Identifier } from "../interfaces";
-import { nextCycle } from './utils';
-
-/**
- * Update given value with an update Cb and return updated value.
- * Wrapper is needed for backward compatibility with update methods that were modifying the passed in objects directly
- */
-function applyUpdate<T>(view: T | undefined, update: (r?: T) => T | undefined): T | undefined {
-	const valueReturnedByUpdate = update(view);
-	return valueReturnedByUpdate === undefined ?
-		view :
-		valueReturnedByUpdate;
-}
-
-/**
- * In-memory Projection View, which suspends get()'s until it is ready
- */
-export class InMemoryView<TRecord> implements IProjectionView {
-
-	static factory<TView>(): TView {
-		return (new InMemoryView() as unknown) as TView;
-	}
-
-	protected _map: Map<Identifier, TRecord> = new Map();
-
-	#lock: InMemoryLock;
-
-	#asyncWrites: boolean;
-
-	/** Whether the view is restored */
-	get ready(): boolean {
-		return !this.#lock.locked;
-	}
-
-	/** Number of records in the View */
-	get size(): number {
-		return this._map.size;
-	}
-
-	constructor(options?: {
-		/** Indicates if writes should be submitted asynchronously */
-		asyncWrites?: boolean
-	}) {
-		this.#asyncWrites = options?.asyncWrites ?? false;
-
-		this.#lock = new InMemoryLock();
-
-		// explicitly bind the `get` method to this object for easier using in Promises
-		Object.defineProperty(this, this.get.name, {
-			value: this.get.bind(this)
-		});
-	}
-
-	/** Lock the view to prevent concurrent modifications */
-	async lock(): Promise<boolean> {
-		await this.#lock.lock();
-		return this.#lock.locked;
-	}
-
-	/** Release the lock */
-	async unlock(): Promise<void> {
-		return this.#lock.unlock();
-	}
-
-	/** Create a Promise which will resolve to a first emitted event of a given type */
-	once(eventType: 'ready'): Promise<any> {
-		if (eventType !== 'ready')
-			throw new TypeError(`Unexpected event type: ${eventType}`);
-
-		return this.#lock.once('unlocked');
-	}
-
-	/**
-	 * Check if view contains a record with a given key.
-	 * This is the only synchronous method, so make sure to check the `ready` flag, if necessary
-	 *
-	 * @deprecated Use `async get()` instead
-	 */
-	has(key: Identifier): boolean {
-		return this._map.has(key);
-	}
-
-	/** Get record with a given key; await until the view is restored */
-	async get(key: Identifier, options?: { nowait?: boolean }): Promise<TRecord | undefined> {
-		if (!key)
-			throw new TypeError('key argument required');
-
-		if (!this.ready && !options?.nowait)
-			await this.once('ready');
-
-		await nextCycle();
-
-		return this._map.get(key);
-	}
-
-	/**
-	 * Get record with a given key synchronously
-	 */
-	getSync(key: Identifier): TRecord | undefined {
-		if (!key)
-			throw new TypeError('key argument required');
-
-		return this._map.get(key);
-	}
-
-	/** Get all records matching an optional filter */
-	async getAll(filter?: (r: TRecord | undefined, i: Identifier) => boolean):
-		Promise<Array<[Identifier, TRecord | undefined]>> {
-		if (filter && typeof filter !== 'function')
-			throw new TypeError('filter argument, when defined, must be a Function');
-
-		if (!this.ready)
-			await this.once('ready');
-
-		await nextCycle();
-
-		const r: Array<[Identifier, TRecord | undefined]> = [];
-		for (const entry of this._map.entries()) {
-			if (!filter || filter(entry[1], entry[0]))
-				r.push(entry);
-		}
-
-		return r;
-	}
-
-	/** Create record with a given key and value */
-	async create(key: Identifier, value: TRecord = {} as TRecord) {
-		if (!key)
-			throw new TypeError('key argument required');
-		if (typeof value === 'function')
-			throw new TypeError('value argument must be an instance of an Object');
-
-		if (this.#asyncWrites)
-			await nextCycle();
-
-		if (this._map.has(key))
-			throw new Error(`Key '${key}' already exists`);
-
-		this._map.set(key, value);
-	}
-
-	/** Update existing view record */
-	async update(key: Identifier, update: (r: TRecord) => TRecord) {
-		if (!key)
-			throw new TypeError('key argument required');
-		if (typeof update !== 'function')
-			throw new TypeError('update argument must be a Function');
-
-		if (!this._map.has(key))
-			throw new Error(`Key '${key}' does not exist`);
-
-		return this._update(key, update);
-	}
-
-	/** Update existing view record or create new */
-	async updateEnforcingNew(key: Identifier, update: (r?: TRecord) => TRecord) {
-		if (!key)
-			throw new TypeError('key argument required');
-		if (typeof update !== 'function')
-			throw new TypeError('update argument must be a Function');
-
-		if (!this._map.has(key))
-			return this.create(key, applyUpdate(undefined, update));
-
-		return this._update(key, update);
-	}
-
-	/** Update all records that match filter criteria */
-	async updateAll(filter: (r: TRecord) => boolean, update: (r: TRecord) => TRecord) {
-		if (filter && typeof filter !== 'function')
-			throw new TypeError('filter argument, when specified, must be a Function');
-		if (typeof update !== 'function')
-			throw new TypeError('update argument must be a Function');
-
-		for (const [key, value] of this._map) {
-			if (!filter || filter(value))
-				await this._update(key, update);
-		}
-	}
-
-	/** Update existing record */
-	private async _update(key: Identifier, update: (r?: TRecord) => TRecord) {
-		const value = this._map.get(key);
-		const updatedValue = applyUpdate(value, update);
-		if (updatedValue === undefined)
-			return;
-
-		if (this.#asyncWrites)
-			await nextCycle();
-
-		this._map.set(key, updatedValue);
-	}
-
-	/** Delete record */
-	async delete(key: Identifier) {
-		if (!key)
-			throw new TypeError('key argument required');
-
-		if (this.#asyncWrites)
-			await nextCycle();
-
-		this._map.delete(key);
-	}
-
-	/** Delete all records that match filter criteria */
-	async deleteAll(filter: (r?: TRecord) => boolean) {
-		if (filter && typeof filter !== 'function')
-			throw new TypeError('filter argument, when specified, must be a Function');
-
-		for (const [key, value] of this._map) {
-			if (!filter || filter(value))
-				await this.delete(key);
-		}
-	}
-
-	/** Get view summary as string */
-	toString(): string {
-		return `${this.size} record${this.size !== 1 ? 's' : ''}`;
-	}
-}

package/src/infrastructure/utils/Deferred.ts

@@ -1,41 +0,0 @@
-/**
- * Deferred promise that must be resolved from outside
- */
-export class Deferred<TDeferredValue> {
-
-	readonly promise: Promise<TDeferredValue | void>;
-
-	get resolved() {
-		return this.#resolved;
-	}
-
-	get rejected() {
-		return this.#rejected;
-	}
-
-	get settled() {
-		return this.#resolved || this.#rejected;
-	}
-
-	#resolve!: (value?: TDeferredValue | PromiseLike<TDeferredValue>) => void;
-	#resolved: boolean = false;
-	#reject!: (reason?: any) => void;
-	#rejected: boolean = false;
-
-	constructor() {
-		this.promise = new Promise<TDeferredValue | void>((resolve, reject) => {
-			this.#resolve = resolve;
-			this.#reject = reject;
-		});
-	}
-
-	resolve(value?: TDeferredValue) {
-		this.#resolve(value);
-		this.#resolved = true;
-	}
-
-	reject(reason?: any) {
-		this.#reject(reason);
-		this.#rejected = true;
-	}
-}

package/src/infrastructure/utils/index.ts

@@ -1,2 +0,0 @@
-export * from './Deferred';
-export * from './nextCycle';

package/src/infrastructure/utils/nextCycle.ts

@@ -1,4 +0,0 @@
-/**
- * @returns Promise that resolves on next event loop cycle
- */
-export const nextCycle = (): Promise<void> => new Promise(rs => setImmediate(rs));