node-cqrs 0.16.4 → 1.0.0-beta.0

package/src/infrastructure/InMemoryEventStorage.js

@@ -1,76 +0,0 @@
-/* eslint no-return-assign: "off", eqeqeq: "off", require-jsdoc: "off" */
-'use strict';
-
-/**
- * A simple event storage implementation intended to use for tests only.
- * Storage content resets on each app restart.
- *
- * @class InMemoryEventStorage
- * @implements {IEventStorage}
- */
-class InMemoryEventStorage {
-
-	constructor() {
-		this._nextId = 0;
-		this._events = Promise.resolve([]);
-	}
-
-	/**
-	 * @param {IEvent[]} events
-	 * @returns {Promise<void>}
-	 */
-	commitEvents(events) {
-		return this._events = this._events.then(data =>
-			data.concat(events));
-	}
-
-	/**
-	 * @param {Identifier} aggregateId
-	 * @param {object} [options]
-	 * @param {IEvent} [options.snapshot]
-	 * @returns {Promise<IEventStream>}
-	 */
-	async getAggregateEvents(aggregateId, { snapshot } = {}) {
-		const events = await this._events;
-
-		if (snapshot)
-			return events.filter(e => e.aggregateId == aggregateId && e.aggregateVersion > snapshot.aggregateVersion);
-
-		return events.filter(e => e.aggregateId == aggregateId);
-	}
-
-	/**
-	 * @param {Identifier} sagaId
-	 * @param {object} [options]
-	 * @param {IEvent} [options.beforeEvent]
-	 * @returns {Promise<IEventStream>}
-	 */
-	getSagaEvents(sagaId, { beforeEvent }) {
-		return this._events.then(events =>
-			events.filter(e =>
-				e.sagaId == sagaId
-				&& e.sagaVersion < beforeEvent.sagaVersion));
-	}
-
-	/**
-	 * @param {string[]} eventTypes
-	 * @returns {Promise<IEventStream>}
-	 */
-	getEvents(eventTypes) {
-		if (!eventTypes)
-			return this._events;
-
-		return this._events.then(events =>
-			events.filter(e => eventTypes.includes(e.type)));
-	}
-
-	/**
-	 * @returns {number}
-	 */
-	getNewId() {
-		this._nextId += 1;
-		return this._nextId;
-	}
-}
-
-module.exports = InMemoryEventStorage;

package/src/infrastructure/InMemoryMessageBus.js

@@ -1,132 +0,0 @@
-'use strict';
-
-/**
- * Default implementation of the message bus. Keeps all subscriptions and messages in memory.
- *
- * @class InMemoryMessageBus
- * @implements {IMessageBus}
- */
-class InMemoryMessageBus {
-
-	/**
-	 * Indicates that message bus supports named queue subscriptions
-	 *
-	 * @type {boolean}
-	 * @readonly
-	 * @static
-	 */
-	static get supportsQueues() {
-		return true;
-	}
-
-	/**
-	 * Creates an instance of InMemoryMessageBus
-	 * @param {object} [options]
-	 * @param {string} [options.name]
-	 * @param {boolean} [options.uniqueEventHandlers]
-	 */
-	constructor({ name, uniqueEventHandlers = !!name } = {}) {
-		/** @type {Map<string, Set<IMessageHandler>>} */
-		this._handlers = new Map();
-
-		this._name = name;
-		this._uniqueEventHandlers = uniqueEventHandlers;
-
-		/** @type {Map<string, InMemoryMessageBus>} */
-		this._queues = new Map();
-	}
-
-	/**
-	 * Subscribe to message type
-	 *
-	 * @param {string} messageType
-	 * @param {IMessageHandler} handler
-	 */
-	on(messageType, handler) {
-		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.
-	 *
-	 * @param {string} name
-	 * @returns {IObservable}
-	 */
-	queue(name) {
-		if (!this._queues.has(name))
-			this._queues.set(name, new InMemoryMessageBus({ name, uniqueEventHandlers: true }));
-
-		return this._queues.get(name);
-	}
-
-	/**
-	 * Remove subscription
-	 *
-	 * @param {string} messageType
-	 * @param {IMessageHandler} handler
-	 */
-	off(messageType, handler) {
-		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
-	 *
-	 * @param {ICommand} command
-	 * @returns {Promise<any>}
-	 */
-	async send(command) {
-		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)
-	 *
-	 * @param {IEvent} event
-	 * @returns {Promise<any>}
-	 */
-	async publish(event) {
-		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 => namedQueue.publish(e))
-		];
-
-		return Promise.all(handlers.map(handler => handler(event)));
-	}
-}
-
-module.exports = InMemoryMessageBus;

package/src/infrastructure/InMemorySnapshotStorage.js

@@ -1,40 +0,0 @@
-'use strict';
-
-/**
- * In-memory storage for aggregate snapshots.
- * Storage content resets on app restart
- *
- * @class InMemorySnapshotStorage
- * @implements {IAggregateSnapshotStorage}
- */
-class InMemorySnapshotStorage {
-
-	/**
-	 * Creates an instance of InMemorySnapshotStorage
-	 */
-	constructor() {
-		/** @type {Map<Identifier, IEvent>} */
-		this._snapshots = new Map();
-	}
-
-	/**
-	 * Get latest aggregate snapshot
-	 *
-	 * @param {Identifier} aggregateId
-	 * @returns {Promise<IEvent>}
-	 */
-	async getAggregateSnapshot(aggregateId) {
-		return this._snapshots.get(aggregateId);
-	}
-
-	/**
-	 * Save new aggregate snapshot
-	 *
-	 * @param {IEvent} snapshotEvent
-	 */
-	async saveAggregateSnapshot(snapshotEvent) {
-		this._snapshots.set(snapshotEvent.aggregateId, snapshotEvent);
-	}
-}
-
-module.exports = InMemorySnapshotStorage;

package/src/infrastructure/InMemoryView.js

@@ -1,265 +0,0 @@
-'use strict';
-
-const nextCycle = () => new Promise(setImmediate);
-
-/**
- * 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
- *
- * @template TObjectValue
- * @param {TObjectValue} view
- * @param {function (TObjectValue): TObjectValue} update
- * @returns {TObjectValue}
- */
-const applyUpdate = (view, update) => {
-	const valueReturnedByUpdate = update(view);
-	return valueReturnedByUpdate === undefined ?
-		view :
-		valueReturnedByUpdate;
-};
-
-/**
- * In-memory Projection View, which suspends get()'s until it is ready
- *
- * @class InMemoryView
- * @template TRecord
- */
-class InMemoryView {
-
-	/**
-	 * Whether the view is restored
-	 *
-	 * @type {boolean}
-	 */
-	get ready() {
-		return this._ready;
-	}
-
-	/**
-	 * Number of records in the View
-	 *
-	 * @type {number}
-	 * @readonly
-	 */
-	get size() {
-		return this._map.size;
-	}
-
-	/**
-	 * Creates an instance of InMemoryView
-	 */
-	constructor() {
-		/** @type {Map<Identifier, TRecord>} */
-		this._map = new Map();
-
-		// 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
-	 *
-	 * @returns {Promise<void>}
-	 */
-	async lock() {
-		if (this.ready === false)
-			await this.once('ready');
-
-		this._lockPromise = new Promise(resolve => {
-			this._unlock = resolve;
-		});
-
-		this._ready = false;
-	}
-
-	/**
-	 * Release the lock
-	 */
-	unlock() {
-		this._ready = true;
-		if (typeof this._unlock === 'function')
-			this._unlock();
-	}
-
-	/**
-	 * 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
-	 *
-	 * @param {Identifier} key
-	 * @returns {boolean}
-	 */
-	has(key) {
-		return this._map.has(key);
-	}
-
-	/**
-	 * Get record with a given key; await until the view is restored
-	 *
-	 * @param {Identifier} key
-	 * @param {object} [options]
-	 * @param {boolean} [options.nowait] Skip waiting until the view is restored/ready
-	 * @returns {Promise<TRecord>}
-	 */
-	async get(key, options) {
-		if (!key) throw new TypeError('key argument required');
-
-		if (!this._ready && !(options && options.nowait))
-			await this.once('ready');
-
-		await nextCycle();
-
-		return this._map.get(key);
-	}
-
-	/**
-	 * Get all records matching an optional filter
-	 *
-	 * @param {function(TRecord, Identifier): boolean} [filter]
-	 */
-	async getAll(filter) {
-		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 = [];
-		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
-	 *
-	 * @param {Identifier} key
-	 * @param {TRecord} [value]
-	 */
-	create(key, value = {}) {
-		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._map.has(key))
-			throw new Error(`Key '${key}' already exists`);
-
-		this._map.set(key, value);
-	}
-
-	/**
-	 * Update existing view record
-	 *
-	 * @param {Identifier} key
-	 * @param {function(TRecord): TRecord} update
-	 */
-	update(key, update) {
-		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`);
-
-		this._update(key, update);
-	}
-
-	/**
-	 * Update existing view record or create new
-	 *
-	 * @param {Identifier} key
-	 * @param {function(TRecord): TRecord} update
-	 */
-	updateEnforcingNew(key, update) {
-		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
-	 *
-	 * @param {function(TRecord): boolean} [filter]
-	 * @param {function(TRecord): TRecord} update
-	 */
-	updateAll(filter, update) {
-		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))
-				this._update(key, update);
-		}
-	}
-
-	/**
-	 * Update existing record
-	 *
-	 * @private
-	 * @param {Identifier} key
-	 * @param {function(TRecord): TRecord} update
-	 */
-	_update(key, update) {
-		const value = this._map.get(key);
-		this._map.set(key, applyUpdate(value, update));
-	}
-
-	/**
-	 * Delete record
-	 *
-	 * @param {Identifier} key
-	 */
-	delete(key) {
-		if (!key) throw new TypeError('key argument required');
-
-		this._map.delete(key);
-	}
-
-	/**
-	 * Delete all records that match filter criteria
-	 *
-	 * @param {function(TRecord): boolean} [filter]
-	 */
-	deleteAll(filter) {
-		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))
-				this._map.delete(key);
-		}
-	}
-
-	/**
-	 * Create a Promise which will resolve to a first emitted event of a given type
-	 *
-	 * @param {"ready"} eventType
-	 * @returns {Promise<any>}
-	 */
-	once(eventType) {
-		if (eventType !== 'ready')
-			throw new TypeError(`Unexpected event type: ${eventType}`);
-
-		return this._lockPromise;
-	}
-
-	/**
-	 * Get view summary as string
-	 *
-	 * @returns {string}
-	 */
-	toString() {
-		return `${this.size} record${this.size !== 1 ? 's' : ''}`;
-	}
-}
-
-module.exports = InMemoryView;

package/src/subscribe.js

@@ -1,48 +0,0 @@
-'use strict';
-
-const { getHandler } = require('./utils');
-const getHandledMessageTypes = require('./utils/getHandledMessageTypes');
-
-const unique = arr => [...new Set(arr)];
-
-/**
- * Subscribe observer to observable
- *
- * @param {IObservable} observable
- * @param {object} observer
- * @param {object} [options]
- * @param {string[]} [options.messageTypes]
- * @param {IMessageHandler} [options.masterHandler]
- * @param {string} [options.queueName]
- */
-function subscribe(observable, observer, options = {}) {
-	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)
-			observable.queue(queueName).on(messageType, handler);
-		else
-			observable.on(messageType, handler);
-	}
-}
-
-module.exports = subscribe;

package/src/utils/getClassName.js

@@ -1,11 +0,0 @@
-'use strict';
-
-/**
- * Get instance class name
- *
- * @param {object} instance
- * @returns {string}
- */
-module.exports = function getClassName(instance) {
-	return Object.getPrototypeOf(instance).constructor.name;
-};

package/src/utils/getHandledMessageTypes.js

@@ -1,24 +0,0 @@
-'use strict';
-
-const getMessageHandlerNames = require('./getMessageHandlerNames');
-
-/**
- * Get a list of message types handled by observer
- * @param {object | function} observerInstanceOrClass
- * @returns {string[]}
- */
-function getHandledMessageTypes(observerInstanceOrClass) {
-	if (!observerInstanceOrClass)
-		throw new TypeError('observerInstanceOrClass argument required');
-
-	if (observerInstanceOrClass.handles)
-		return observerInstanceOrClass.handles;
-
-	const prototype = Object.getPrototypeOf(observerInstanceOrClass);
-	if (prototype && prototype.constructor && prototype.constructor.handles)
-		return prototype.constructor.handles;
-
-	return getMessageHandlerNames(observerInstanceOrClass);
-}
-
-module.exports = getHandledMessageTypes;

package/src/utils/getHandler.js

@@ -1,21 +0,0 @@
-'use strict';
-
-/**
- * Gets a handler for a specific message type, prefers a public (w\o _ prefix) method, if available
- * @param  {Object} context
- * @param  {String} messageType
- * @return {IMessageHandler}
- */
-module.exports = function getHandler(context, messageType) {
-	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.js

@@ -1,51 +0,0 @@
-'use strict';
-
-const KNOWN_METHOD_NAMES = new Set([
-	'subscribe'
-]);
-
-function getInheritedPropertyNames(prototype) {
-	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 ("_").
- *
- * @param {any} observerInstanceOrClass Command or event handler class
- * @returns {string[]}
- */
-function getMessageHandlerNames(observerInstanceOrClass) {
-	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 = new Set(getInheritedPropertyNames(prototype));
-
-	const propDescriptors = Object.getOwnPropertyDescriptors(prototype);
-	const propNames = Object.keys(propDescriptors);
-
-	return propNames.filter(key =>
-		!key.startsWith('_') &&
-		!inheritedProperties.has(key) &&
-		!KNOWN_METHOD_NAMES.has(key) &&
-		typeof propDescriptors[key].value === 'function');
-}
-
-module.exports = getMessageHandlerNames;

package/src/utils/index.js

@@ -1,6 +0,0 @@
-'use strict';
-
-exports.getClassName = require('./getClassName');
-exports.getHandler = require('./getHandler');
-exports.isClass = require('./isClass');
-exports.validateHandlers = require('./validateHandlers');

package/src/utils/isClass.js

@@ -1,6 +0,0 @@
-'use strict';
-
-module.exports = function isClass(func) {
-	return typeof func === 'function'
-		&& Function.prototype.toString.call(func).startsWith('class');
-};

package/src/utils/nullLogger.js

@@ -1,8 +0,0 @@
-'use strict';
-
-/**
- * @type {ILogger}
- */
-module.exports = {
-	log() { }
-};