node-cqrs 0.16.3 → 0.17.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/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/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/nullLogger.js

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

package/types/classes/AbstractAggregate.d.ts

@@ -1,64 +0,0 @@
-namespace NodeCqrs {
-
-	/** Base class for Aggregate definition */
-	declare abstract class AbstractAggregate implements IAggregate {
-
-		/**
-		 * Optional list of commands handled by Aggregate.
-		 * Can be overridden in the aggregate implementation
-		 */
-		static readonly handles: Array<string>;
-
-		/** Aggregate ID */
-		readonly id: string | number;
-
-		/** Aggregate Version */
-		readonly version: number;
-
-		/** Aggregate Snapshot Version */
-		readonly snapshotVersion: number | undefined;
-
-		/** Events emitted by Aggregate */
-		readonly changes: IEventStream;
-
-		/** Override to define whether an aggregate state snapshot should be taken */
-		readonly shouldTakeSnapshot: boolean;
-
-		state;
-
-		command;
-
-		/** Creates an instance of AbstractAggregate. */
-		constructor(options: TAggregateConstructorParams): void;
-
-		/** Pass command to command handler */
-		handle(command: ICommand): any;
-
-		/** Mutate aggregate state and increment aggregate version */
-		protected mutate(event: IEvent): void;
-
-		/** Format and register aggregate event and mutate aggregate state */
-		protected emit(type: string, payload?: object): void;
-
-		/**
-		 * Format event based on a current aggregate state
-		 * and a command being executed
-		 */
-		protected makeEvent(type: string, payload?: any, sourceCommand?: ICommand): IEvent;
-
-		/** Register aggregate event and mutate aggregate state */
-		protected emitRaw(event: IEvent): void;
-
-		/** Take an aggregate state snapshot and add it to the changes queue */
-		takeSnapshot(): void;
-
-		/** Create an aggregate state snapshot */
-		protected makeSnapshot(): object;
-
-		/** Restore aggregate state from a snapshot */
-		protected restoreSnapshot(snapshotEvent: IEvent): void;
-
-		/** Get human-readable aggregate identifier */
-		toString(): string;
-	}
-}

package/types/classes/AbstractProjection.d.ts

@@ -1,46 +0,0 @@
-namespace NodeCqrs {
-
-	/** Base class for Projection definition */
-	declare abstract class AbstractProjection implements IProjection {
-
-		/**
-		 * 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
-		 */
-		static readonly handles: Array<string>;
-
-		/**
-		 * Default view associated with projection.
-		 * If not defined, an instance of `NodeCqrs.InMemoryView` is created on first access.
-		 */
-		readonly view;
-
-		/**
-		 * Indicates if view should be restored from EventStore on start.
-		 * Override for custom behavior.
-		 */
-		readonly shouldRestoreView: boolean | Promise<boolean>;
-
-		/** Creates an instance of AbstractProjection */
-		constructor(options?: { view?: any, logger?: ILogger }): void;
-
-		/** 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 */
-		protected _onRestoringError(error: Error, event: IEvent): void;
-	}
-}

package/types/classes/AbstractSaga.d.ts

@@ -1,39 +0,0 @@
-namespace NodeCqrs {
-
-	/** Base class for Saga definition */
-	declare abstract class AbstractSaga implements ISaga {
-
-		/** List of events that start new saga, must be overridden in Saga implementation */
-		static readonly startsWith: Array<string>;
-
-		/** List of event types being handled by Saga, must be overridden in Saga implementation */
-		static readonly handles: Array<string>;
-
-		/** Saga ID */
-		readonly id: string | number;
-
-		/** Saga version */
-		readonly version: number;
-
-		/** Command execution queue */
-		readonly uncommittedMessages: Array<ICommand>;
-
-		/** Creates an instance of AbstractSaga */
-		constructor(options: TSagaConstructorParams): void;
-
-		/** Modify saga state by applying an event */
-		apply(event: IEvent): void | Promise<void>;
-
-		/** Format a command and put it to the execution queue */
-		protected enqueue(commandType: string, aggregateId: string | number, 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;
-	}
-}