node-cqrs 0.16.4 → 1.0.0-beta.0

package/src/AggregateCommandHandler.js

@@ -1,126 +0,0 @@
-'use strict';
-
-const subscribe = require('./subscribe');
-const { isClass, getClassName } = require('./utils');
-const getHandledMessageTypes = require('./utils/getHandledMessageTypes');
-const nullLogger = require('./utils/nullLogger');
-
-/**
- * Aggregate command handler.
- *
- * Subscribes to event store and awaits aggregate commands.
- * Upon command receiving creates an instance of aggregate,
- * restores its state, passes command and commits emitted events to event store.
- *
- * @class AggregateCommandHandler
- * @implements {ICommandHandler}
- */
-class AggregateCommandHandler {
-
-	/**
-	 * Creates an instance of AggregateCommandHandler.
-	 *
-	 * @param {object} options
-	 * @param {IEventStore} options.eventStore
-	 * @param {IAggregateConstructor | IAggregateFactory} options.aggregateType
-	 * @param {string[]} [options.handles]
-	 * @param {ILogger} [options.logger]
-	 */
-	constructor(options) {
-		if (!options.eventStore) throw new TypeError('eventStore argument required');
-		if (!options.aggregateType) throw new TypeError('aggregateType argument required');
-
-		this._eventStore = options.eventStore;
-		this._logger = options.logger || nullLogger;
-
-		if (isClass(options.aggregateType)) {
-			/** @type {IAggregateConstructor} */
-			// @ts-ignore
-			const AggregateType = options.aggregateType;
-
-			this._aggregateFactory = params => new AggregateType(params);
-			this._handles = getHandledMessageTypes(AggregateType);
-		}
-		else {
-			this._aggregateFactory = options.aggregateType;
-			this._handles = options.handles;
-		}
-	}
-
-	/**
-	 * Subscribe to all command types handled by aggregateType
-	 *
-	 * @param {ICommandBus} commandBus
-	 * @returns {any} - whatever EventEmitter.on returns for each messageType
-	 */
-	subscribe(commandBus) {
-		subscribe(commandBus, this, {
-			messageTypes: this._handles,
-			masterHandler: c => this.execute(c)
-		});
-	}
-
-	/**
-	 * Restore aggregate from event store events
-	 *
-	 * @param {Identifier} id
-	 * @returns {Promise<IAggregate>}
-	 */
-	async _restoreAggregate(id) {
-		if (!id) throw new TypeError('id argument required');
-
-		const events = await this._eventStore.getAggregateEvents(id);
-		const aggregate = this._aggregateFactory.call(null, { id, events });
-		this._logger.log('info', `${aggregate} state restored from ${events}`, { service: getClassName(aggregate) });
-
-		return aggregate;
-	}
-
-	/**
-	 * Create new aggregate with new Id generated by event store
-	 *
-	 * @returns {Promise<IAggregate>}
-	 */
-	async _createAggregate() {
-		const id = await this._eventStore.getNewId();
-		const aggregate = this._aggregateFactory.call(null, { id });
-		this._logger.log('info', `${aggregate} created`, { service: getClassName(aggregate) });
-
-		return aggregate;
-	}
-
-	/**
-	 * Pass a command to corresponding aggregate
-	 *
-	 * @param {ICommand} cmd - command to execute
-	 * @return {Promise<IEventStream>} events
-	 */
-	async execute(cmd) {
-		if (!cmd) throw new TypeError('cmd argument required');
-		if (!cmd.type) throw new TypeError('cmd.type argument required');
-
-		const aggregate = cmd.aggregateId ?
-			await this._restoreAggregate(cmd.aggregateId) :
-			await this._createAggregate();
-
-		const handlerResponse = aggregate.handle(cmd);
-		if (handlerResponse instanceof Promise)
-			await handlerResponse;
-
-		let events = aggregate.changes;
-		this._logger.log('info', `${aggregate} "${cmd.type}" command processed, ${events} produced`, { service: getClassName(aggregate) });
-		if (!events.length)
-			return [];
-
-		if (aggregate.shouldTakeSnapshot && this._eventStore.snapshotsSupported) {
-			aggregate.takeSnapshot();
-			events = aggregate.changes;
-		}
-
-		await this._eventStore.commit(events);
-
-		return events;
-	}
-}
-
-module.exports = AggregateCommandHandler;

package/src/CommandBus.js

@@ -1,91 +0,0 @@
-'use strict';
-
-const InMemoryBus = require('./infrastructure/InMemoryMessageBus');
-const nullLogger = require('./utils/nullLogger');
-const service = 'CommandBus';
-
-/**
- * @class CommandBus
- * @implements {ICommandBus}
- */
-class CommandBus {
-
-	/**
-	 * Creates an instance of CommandBus.
-	 *
-	 * @param {object} [options]
-	 * @param {IMessageBus} [options.messageBus]
-	 * @param {ILogger} [options.logger]
-	 */
-	constructor(options) {
-		this._bus = (options && options.messageBus) || new InMemoryBus();
-		this._logger = (options && options.logger) || nullLogger;
-	}
-
-	/**
-	 * Set up a command handler
-	 *
-	 * @param {string} commandType
-	 * @param {IMessageHandler} handler
-	 * @returns {any}
-	 */
-	on(commandType, handler) {
-		if (typeof commandType !== 'string' || !commandType.length) throw new TypeError('commandType argument must be a non-empty String');
-		if (typeof handler !== 'function') throw new TypeError('handler argument must be a Function');
-
-		return this._bus.on(commandType, handler);
-	}
-
-	/**
-	 * Format and send a command for execution
-	 *
-	 * @param {string} type
-	 * @param {string} [aggregateId]
-	 * @param {object} [options]
-	 * @param {any} [options.payload]
-	 * @param {object} [options.context]
-	 * @param {...object} [otherArgs]
-	 * @returns {Promise<IEventStream>} - produced events
-	 */
-	send(type, aggregateId, options, ...otherArgs) {
-		if (typeof type !== 'string' || !type.length)
-			throw new TypeError('type argument must be a non-empty String');
-		if (options && typeof options !== 'object')
-			throw new TypeError('options argument, when defined, must be an Object');
-		if (otherArgs.length > 1)
-			throw new TypeError('more than expected arguments supplied');
-
-		// obsolete. left for backward compatibility
-		const optionsContainContext = options && !('context' in options) && !('payload' in options);
-		if (otherArgs.length || optionsContainContext) {
-			const context = options;
-			const payload = otherArgs.length ? otherArgs[0] : undefined;
-			return this.sendRaw({ type, aggregateId, context, payload });
-		}
-
-		return this.sendRaw({ type, aggregateId, ...options });
-	}
-
-	/**
-	 * Send a command for execution
-	 *
-	 * @param {ICommand} command
-	 * @returns {Promise<IEventStream>} - produced events
-	 */
-	sendRaw(command) {
-		if (!command) throw new TypeError('command argument required');
-		if (!command.type) throw new TypeError('command.type argument required');
-
-		this._logger.log('debug', `sending '${command.type}' command...`, { service });
-
-		return this._bus.send(command).then(r => {
-			this._logger.log('debug', `'${command.type}' processed`, { service });
-			return r;
-		}, error => {
-			this._logger.log('error', `'${command.type}' processing has failed: ${error.message}`, { service, stack: error.stack });
-			throw error;
-		});
-	}
-}
-
-module.exports = CommandBus;

package/src/CqrsContainerBuilder.js

@@ -1,131 +0,0 @@
-'use strict';
-
-const { ContainerBuilder } = require('di0');
-
-const AggregateCommandHandler = require('./AggregateCommandHandler');
-const SagaEventHandler = require('./SagaEventHandler');
-const CommandBus = require('./CommandBus');
-const EventStore = require('./EventStore');
-const getHandledMessageTypes = require('./utils/getHandledMessageTypes');
-
-function isClass(func) {
-	return typeof func === 'function'
-		&& Function.prototype.toString.call(func).startsWith('class');
-}
-
-class CqrsContainerBuilder extends ContainerBuilder {
-
-	/**
-	 * Creates an instance of CqrsContainerBuilder
-	 *
-	 * @param {object} [options]
-	 * @param {Readonly<import('di0').TypeConfig[]>} options.types
-	 * @param {object} options.singletones
-	 */
-	constructor(options) {
-		super(options);
-		this.register(EventStore).as('eventStore');
-		this.register(CommandBus).as('commandBus');
-	}
-
-	/**
-	 * Register command handler, which will be subscribed to commandBus upon instance creation
-	 *
-	 * @param {function} typeOrFactory
-	 */
-	registerCommandHandler(typeOrFactory) {
-		return super.register(
-			container => {
-				const handler = container.createInstance(typeOrFactory);
-				handler.subscribe(container.commandBus);
-				return handler;
-			})
-			.asSingleInstance();
-	}
-
-	/**
-	 * Register event receptor, which will be subscribed to eventStore upon instance creation
-	 *
-	 * @param {function} typeOrFactory
-	 */
-	registerEventReceptor(typeOrFactory) {
-		return super.register(
-			container => {
-				const receptor = container.createInstance(typeOrFactory);
-				receptor.subscribe(container.eventStore);
-				return receptor;
-			})
-			.asSingleInstance();
-	}
-
-	/**
-	 * Register projection, which will expose view and will be subscribed
-	 * to eventStore and will restore its state upon instance creation
-	 *
-	 * @param {IProjectionConstructor} ProjectionType
-	 * @param {string} [exposedViewAlias]
-	 */
-	registerProjection(ProjectionType, exposedViewAlias) {
-		if (!isClass(ProjectionType))
-			throw new TypeError('ProjectionType argument must be a constructor function');
-
-		const projectionFactory = container => {
-			const projection = container.createInstance(ProjectionType);
-			projection.subscribe(container.eventStore);
-
-			if (exposedViewAlias)
-				return projection.view;
-
-			return projection;
-		};
-
-		const t = super.register(projectionFactory).asSingleInstance();
-
-		if (exposedViewAlias)
-			t.as(exposedViewAlias);
-
-		return t;
-	}
-
-	/**
-	 * Register aggregate type in the container
-	 *
-	 * @param {IAggregateConstructor} AggregateType
-	 */
-	registerAggregate(AggregateType) {
-		if (!isClass(AggregateType))
-			throw new TypeError('AggregateType argument must be a constructor function');
-
-		const commandHandlerFactory = container =>
-			container.createInstance(AggregateCommandHandler, {
-				aggregateType: options =>
-					container.createInstance(AggregateType, options),
-				handles: getHandledMessageTypes(AggregateType)
-			});
-
-		return this.registerCommandHandler(commandHandlerFactory);
-	}
-
-
-	/**
-	 * Register saga type in the container
-	 *
-	 * @param {ISagaConstructor} SagaType
-	 */
-	registerSaga(SagaType) {
-		if (!isClass(SagaType))
-			throw new TypeError('SagaType argument must be a constructor function');
-
-		const eventReceptorFactory = container =>
-			container.createInstance(SagaEventHandler, {
-				sagaType: options => container.createInstance(SagaType, options),
-				handles: SagaType.handles,
-				startsWith: SagaType.startsWith,
-				queueName: SagaType.name
-			});
-
-		return this.registerEventReceptor(eventReceptorFactory);
-	}
-}
-
-module.exports = CqrsContainerBuilder;