node-cqrs 0.16.3 → 0.17.0

package/src/AbstractAggregate.js

@@ -1,277 +0,0 @@
-'use strict';
-
-const { validateHandlers, getHandler, getClassName } = require('./utils');
-const EventStream = require('./EventStream');
-
-/**
- * Deep-clone simple JS object
- * @template T
- * @param {T} obj
- * @returns {T}
- */
-const clone = obj => JSON.parse(JSON.stringify(obj));
-
-const SNAPSHOT_EVENT_TYPE = 'snapshot';
-
-const _id = Symbol('id');
-const _changes = Symbol('changes');
-const _version = Symbol('version');
-const _snapshotVersion = Symbol('snapshotVersion');
-
-/**
- * Base class for Aggregate definition
- *
- * @class AbstractAggregate
- * @implements {IAggregate}
- */
-class AbstractAggregate {
-
-	/**
-	 * Optional list of commands handled by Aggregate.
-	 * Can be overridden in the aggregate implementation
-	 *
-	 * @type {string[]}
-	 * @readonly
-	 * @static
-	 * @example
-	 * 	return ['createUser', 'changePassword'];
-	 */
-	static get handles() {
-		return undefined;
-	}
-
-	/**
-	 * Aggregate ID
-	 *
-	 * @type {string|number}
-	 * @readonly
-	 */
-	get id() {
-		return this[_id];
-	}
-
-	/**
-	 * Aggregate Version
-	 *
-	 * @type {number}
-	 * @readonly
-	 */
-	get version() {
-		return this[_version];
-	}
-
-	/**
-	 * Aggregate Snapshot Version
-	 *
-	 * @type {number|undefined}
-	 * @readonly
-	 */
-	get snapshotVersion() {
-		return this[_snapshotVersion];
-	}
-
-	/**
-	 * Events emitted by Aggregate
-	 *
-	 * @type {IEventStream}
-	 * @readonly
-	 */
-	get changes() {
-		return new EventStream(this[_changes]);
-	}
-
-	/**
-	 * Override to define whether an aggregate state snapshot should be taken
-	 *
-	 * @type {boolean}
-	 * @readonly
-	 * @example
-	 * 	// create snapshot every 50 events
-	 * 	return this.version % 50 === 0;
-	 */
-	get shouldTakeSnapshot() {	// eslint-disable-line class-methods-use-this
-		return false;
-	}
-
-	/**
-	 * Creates an instance of AbstractAggregate.
-	 *
-	 * @param {TAggregateConstructorParams} options
-	 */
-	constructor(options) {
-		const { id, state, events } = options;
-		if (!id) throw new TypeError('id argument required');
-		if (state && typeof state !== 'object') throw new TypeError('state argument, when provided, must be an Object');
-		if (events && !Array.isArray(events)) throw new TypeError('events argument, when provided, must be an Array');
-
-		this[_id] = id;
-		this[_changes] = [];
-		this[_version] = 0;
-		this[_snapshotVersion] = 0;
-
-		validateHandlers(this);
-
-		if (state)
-			this.state = state;
-
-		if (events)
-			events.forEach(event => this.mutate(event));
-	}
-
-	/**
-	 * Pass command to command handler
-	 *
-	 * @param {ICommand} command
-	 * @returns {any}
-	 */
-	handle(command) {
-		if (!command) throw new TypeError('command argument required');
-		if (!command.type) throw new TypeError('command.type argument required');
-
-		const handler = getHandler(this, command.type);
-		if (!handler)
-			throw new Error(`'${command.type}' handler is not defined or not a function`);
-
-		this.command = command;
-
-		return handler.call(this, command.payload, command.context);
-	}
-
-	/**
-	 * Mutate aggregate state and increment aggregate version
-	 *
-	 * @protected
-	 * @param {IEvent} event
-	 */
-	mutate(event) {
-		if ('aggregateVersion' in event)
-			this[_version] = event.aggregateVersion;
-
-		if (event.type === SNAPSHOT_EVENT_TYPE) {
-			this[_snapshotVersion] = event.aggregateVersion;
-			this.restoreSnapshot(event);
-		}
-		else if (this.state) {
-			const handler = this.state.mutate || getHandler(this.state, event.type);
-			if (handler)
-				handler.call(this.state, event);
-		}
-
-		this[_version] += 1;
-	}
-
-	/**
-	 * Format and register aggregate event and mutate aggregate state
-	 *
-	 * @protected
-	 * @param {string} type - event type
-	 * @param {object} [payload] - event data
-	 */
-	emit(type, payload) {
-		if (typeof type !== 'string' || !type.length) throw new TypeError('type argument must be a non-empty string');
-
-		const event = this.makeEvent(type, payload, this.command);
-
-		this.emitRaw(event);
-	}
-
-	/**
-	 * Format event based on a current aggregate state
-	 * and a command being executed
-	 *
-	 * @protected
-	 * @param {string} type
-	 * @param {any} [payload]
-	 * @param {ICommand} [sourceCommand]
-	 * @returns {IEvent}
-	 */
-	makeEvent(type, payload, sourceCommand) {
-		/** @type {IEvent} */
-		const event = {
-			aggregateId: this.id,
-			aggregateVersion: this.version,
-			type,
-			payload
-		};
-
-		if (sourceCommand) {
-			// augment event with command context
-			const { context, sagaId, sagaVersion } = sourceCommand;
-			if (context !== undefined)
-				event.context = context;
-			if (sagaId !== undefined)
-				event.sagaId = sagaId;
-			if (sagaVersion !== undefined)
-				event.sagaVersion = sagaVersion;
-		}
-
-		return event;
-	}
-
-	/**
-	 * Register aggregate event and mutate aggregate state
-	 *
-	 * @protected
-	 * @param {IEvent} event
-	 */
-	emitRaw(event) {
-		if (!event) throw new TypeError('event argument required');
-		if (!event.aggregateId) throw new TypeError('event.aggregateId argument required');
-		if (typeof event.aggregateVersion !== 'number') throw new TypeError('event.aggregateVersion argument must be a Number');
-		if (typeof event.type !== 'string' || !event.type.length) throw new TypeError('event.type argument must be a non-empty String');
-
-		this.mutate(event);
-
-		this[_changes].push(event);
-	}
-
-	/**
-	 * Take an aggregate state snapshot and add it to the changes queue
-	 */
-	takeSnapshot() {
-		this.emit(SNAPSHOT_EVENT_TYPE, this.makeSnapshot());
-	}
-
-	/**
-	 * Create an aggregate state snapshot
-	 *
-	 * @protected
-	 * @returns {object}
-	  */
-	makeSnapshot() {
-		if (!this.state)
-			throw new Error('state property is empty, either define state or override makeSnapshot method');
-
-		return clone(this.state);
-	}
-
-	/**
-	 * Restore aggregate state from a snapshot
-	 *
-	 * @protected
-	 * @param {IEvent} snapshotEvent
-	 */
-	restoreSnapshot(snapshotEvent) {
-		if (!snapshotEvent) throw new TypeError('snapshotEvent argument required');
-		if (!snapshotEvent.type) throw new TypeError('snapshotEvent.type argument required');
-		if (!snapshotEvent.payload) throw new TypeError('snapshotEvent.payload argument required');
-
-		if (snapshotEvent.type !== SNAPSHOT_EVENT_TYPE)
-			throw new Error(`${SNAPSHOT_EVENT_TYPE} event type expected`);
-		if (!this.state)
-			throw new Error('state property is empty, either defined state or override restoreSnapshot method');
-
-		Object.assign(this.state, clone(snapshotEvent.payload));
-	}
-
-	/**
-	 * Get human-readable aggregate identifier
-	 *
-	 * @returns {string}
-	 */
-	toString() {
-		return `${getClassName(this)} ${this.id} (v${this.version})`;
-	}
-}
-
-module.exports = AbstractAggregate;

package/src/AbstractProjection.js

@@ -1,192 +0,0 @@
-'use strict';
-
-const subscribe = require('./subscribe');
-const InMemoryView = require('./infrastructure/InMemoryView');
-const getHandledMessageTypes = require('./utils/getHandledMessageTypes');
-const { validateHandlers, getHandler, getClassName } = require('./utils');
-const nullLogger = require('./utils/nullLogger');
-
-/**
- * @param {any} view
- */
-const isConcurrentView = view =>
-	typeof view.lock === 'function' &&
-	typeof view.unlock === 'function' &&
-	typeof view.once === 'function';
-
-/**
- * @param {any} view
- * @returns {IConcurrentView}
- */
-const asConcurrentView = view => (isConcurrentView(view) ? view : undefined);
-
-/**
- * Base class for Projection definition
- *
- * @class AbstractProjection
- * @implements {IProjection}
- */
-class AbstractProjection {
-
-	/**
-	 * Optional list of event types being handled by projection.
-	 * Can be overridden in projection implementation.
-	 * If not overridden, will detect event types from event handlers declared on the Projection class
-	 *
-	 * @type {string[]}
-	 * @readonly
-	 * @static
-	 */
-	static get handles() {
-		return undefined;
-	}
-
-	/**
-	 * Default view associated with projection.
-	 * If not defined, an instance of `NodeCqrs.InMemoryView` is created on first access.
-	 *
-	 * @readonly
-	 */
-	get view() {
-		return this._view || (this._view = new InMemoryView());
-	}
-
-	/**
-	 * Indicates if view should be restored from EventStore on start.
-	 * Override for custom behavior.
-	 *
-	 * @type {boolean | Promise<boolean>}
-	 * @readonly
-	 */
-	get shouldRestoreView() {
-		return (this.view instanceof Map)
-			|| (this.view instanceof InMemoryView);
-	}
-
-	/**
-	 * Creates an instance of AbstractProjection
-	 *
-	 * @param {object} [options]
-	 * @param {any} [options.view]
-	 * @param {ILogger} [options.logger]
-	 */
-	constructor(options) {
-		validateHandlers(this);
-
-		if (options && options.view)
-			this._view = options.view;
-
-		this._logger = (options && options.logger) || nullLogger;
-	}
-
-	/**
-	 * Subscribe to event store
-	 *
-	 * @param {IEventStore} eventStore
-	 * @return {Promise<void>}
-	 */
-	async subscribe(eventStore) {
-		subscribe(eventStore, this, {
-			masterHandler: e => this.project(e)
-		});
-
-		await this.restore(eventStore);
-	}
-
-	/**
-	 * Pass event to projection event handler
-	 *
-	 * @param {IEvent} event
-	 * @returns {Promise<void>}
-	 */
-	async project(event) {
-		const concurrentView = asConcurrentView(this.view);
-		if (concurrentView && !concurrentView.ready)
-			await concurrentView.once('ready');
-
-		return this._project(event);
-	}
-
-	/**
-	 * Pass event to projection event handler, without awaiting for restore operation to complete
-	 * @protected
-	 * @param {IEvent} event
-	 * @returns {Promise<void>}
-	 */
-	async _project(event) {
-		const handler = getHandler(this, event.type);
-		if (!handler)
-			throw new Error(`'${event.type}' handler is not defined or not a function`);
-
-		return handler.call(this, event);
-	}
-
-	/**
-	 * Restore projection view from event store
-	 *
-	 * @param {IEventStore} eventStore
-	 * @return {Promise<void>}
-	 */
-	async restore(eventStore) {
-		// lock the view to ensure same restoring procedure
-		// won't be performed by another projection instance
-		const concurrentView = asConcurrentView(this.view);
-		if (concurrentView)
-			await concurrentView.lock();
-
-		const shouldRestore = await this.shouldRestoreView;
-		if (shouldRestore)
-			await this._restore(eventStore);
-
-		if (concurrentView)
-			concurrentView.unlock();
-	}
-
-	/**
-	 * Restore projection view from event store
-	 * @protected
-	 * @param {IEventStore} eventStore
-	 * @return {Promise<void>}
-	 */
-	async _restore(eventStore) {
-		/* istanbul ignore if */
-		if (!eventStore) throw new TypeError('eventStore argument required');
-		/* istanbul ignore if */
-		if (typeof eventStore.getAllEvents !== 'function') throw new TypeError('eventStore.getAllEvents must be a Function');
-
-		const service = getClassName(this);
-		this._logger.log('debug', 'retrieving events and restoring projection...', { service });
-
-		const messageTypes = getHandledMessageTypes(this);
-		const eventsIterable = eventStore.getAllEvents(messageTypes);
-
-		for await (const event of eventsIterable) {
-			try {
-				await this._project(event);
-			}
-			catch (err) {
-				this._onRestoringError(err, event);
-			}
-		}
-
-		this._logger.log('info', `view restored (${this.view})`, { service });
-	}
-
-	/**
-	 * Handle error on restoring
-	 *
-	 * @protected
-	 * @param {Error} error
-	 * @param {IEvent} event
-	 */
-	_onRestoringError(error, event) {
-		this._logger.log('error', `view restoring has failed: ${error.message}`, {
-			service: getClassName(this),
-			event,
-			stack: error.stack
-		});
-		throw error;
-	}
-}
-
-module.exports = AbstractProjection;

package/src/AbstractSaga.js

@@ -1,171 +0,0 @@
-'use strict';
-
-const { validateHandlers, getHandler, getClassName } = require('./utils');
-
-const _id = Symbol('id');
-const _version = Symbol('version');
-const _messages = Symbol('messages');
-
-/**
- * Base class for Saga definition
- *
- * @class AbstractSaga
- * @implements {ISaga}
- */
-class AbstractSaga {
-
-	/**
-	 * List of events that start new saga, must be overridden in Saga implementation
-	 *
-	 * @type {string[]}
-	 * @readonly
-	 * @static
-	 */
-	static get startsWith() {
-		throw new Error('startsWith must be overridden to return a list of event types that start saga');
-	}
-
-	/**
-	 * List of event types being handled by Saga, must be overridden in Saga implementation
-	 *
-	 * @type {string[]}
-	 * @readonly
-	 * @static
-	 */
-	static get handles() {
-		return [];
-	}
-
-	/**
-	 * Saga ID
-	 *
-	 * @type {string|number}
-	 * @readonly
-	 */
-	get id() {
-		return this[_id];
-	}
-
-	/**
-	 * Saga version
-	 *
-	 * @type {number}
-	 * @readonly
-	 */
-	get version() {
-		return this[_version];
-	}
-
-	/**
-	 * Command execution queue
-	 *
-	 * @type {ICommand[]}
-	 * @readonly
-	 */
-	get uncommittedMessages() {
-		return Array.from(this[_messages]);
-	}
-
-	/**
-	 * Creates an instance of AbstractSaga
-	 *
-	 * @param {TSagaConstructorParams} options
-	 */
-	constructor(options) {
-		if (!options) throw new TypeError('options argument required');
-		if (!options.id) throw new TypeError('options.id argument required');
-
-		this[_id] = options.id;
-		this[_version] = 0;
-		this[_messages] = [];
-
-		validateHandlers(this, 'startsWith');
-		validateHandlers(this, 'handles');
-
-		if (options.events) {
-			options.events.forEach(e => this.apply(e));
-			this.resetUncommittedMessages();
-		}
-
-		Object.defineProperty(this, 'restored', { value: true });
-	}
-
-	/**
-	 * Modify saga state by applying an event
-	 *
-	 * @param {IEvent} event
-	 * @returns {void|Promise<void>}
-	 */
-	apply(event) {
-		if (!event) throw new TypeError('event argument required');
-		if (!event.type) throw new TypeError('event.type argument required');
-
-		const handler = getHandler(this, event.type);
-		if (!handler)
-			throw new Error(`'${event.type}' handler is not defined or not a function`);
-
-		const r = handler.call(this, event);
-		if (r instanceof Promise) {
-			return r.then(() => {
-				this[_version] += 1;
-			});
-		}
-
-		this[_version] += 1;
-		return undefined;
-	}
-
-	/**
-	 * Format a command and put it to the execution queue
-	 *
-	 * @protected
-	 * @param {string} commandType
-	 * @param {string|number} aggregateId
-	 * @param {object} payload
-	 */
-	enqueue(commandType, aggregateId, payload) {
-		if (typeof commandType !== 'string' || !commandType.length)
-			throw new TypeError('commandType argument must be a non-empty String');
-		if (!['string', 'number', 'undefined'].includes(typeof aggregateId))
-			throw new TypeError('aggregateId argument must be either string, number or undefined');
-
-		this.enqueueRaw({
-			aggregateId,
-			sagaId: this.id,
-			sagaVersion: this.version,
-			type: commandType,
-			payload
-		});
-	}
-
-	/**
-	 * Put a command to the execution queue
-	 *
-	 * @protected
-	 * @param {ICommand} command
-	 */
-	enqueueRaw(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');
-
-		this[_messages].push(command);
-	}
-
-	/**
-	 * Clear the execution queue
-	 */
-	resetUncommittedMessages() {
-		this[_messages].length = 0;
-	}
-
-	/**
-	 * Get human-readable Saga name
-	 *
-	 * @returns {string}
-	 */
-	toString() {
-		return `${getClassName(this)} ${this.id} (v${this.version})`;
-	}
-}
-
-module.exports = AbstractSaga;