node-cqrs 0.17.0 → 1.0.0-beta.0

package/src/interfaces.ts

@@ -1,328 +0,0 @@
-export type Identifier = string | number;
-
-export interface IMessage<TPayload = any> {
-	/** Event or command type */
-	type: string;
-
-	aggregateId?: Identifier;
-	aggregateVersion?: number;
-
-	sagaId?: Identifier;
-	sagaVersion?: number;
-
-	payload?: TPayload;
-	context?: any;
-}
-
-export type ICommand<TPayload = any> = IMessage<TPayload>;
-
-export type IEvent<TPayload = any> = IMessage<TPayload> & {
-	/** Unique event identifier */
-	id?: string;
-};
-
-/**
- * @deprecated Try to use `IEventStream` instead
- */
-export type IEventSet = ReadonlyArray<Readonly<IEvent>>;
-
-export type IEventStream = AsyncIterableIterator<Readonly<IEvent>>;
-
-
-/**
- * Minimum aggregate interface, as it's used by default `AggregateCommandHandler`
- */
-export interface IAggregate {
-
-	/** Unique aggregate identifier */
-	readonly id: Identifier;
-
-	/** Main entry point for aggregate commands */
-	handle(command: ICommand): void | Promise<void>;
-
-	/** List of events emitted by Aggregate as a result of handling command(s) */
-	readonly changes: IEventSet;
-
-	/** An indicator if aggregate snapshot should be taken */
-	readonly shouldTakeSnapshot?: boolean;
-
-	/** Take an aggregate state snapshot and add it to the changes queue */
-	takeSnapshot(): void;
-}
-
-export interface IMutableAggregateState {
-	// schemaVersion?: number;
-	// constructor: IAggregateStateConstructor;
-	mutate(event: IEvent): void;
-}
-
-// export interface IAggregateStateConstructor extends Function {
-// 	schemaVersion?: number;
-// 	new(): IAggregateState;
-// }
-
-export type IAggregateConstructorParams<TState extends IMutableAggregateState | object | void> = {
-	/** Unique aggregate identifier */
-	id: Identifier,
-
-	/** Aggregate events, logged after latest snapshot */
-	events?: IEventSet,
-
-	/** Aggregate state instance */
-	state?: TState
-};
-
-export interface IAggregateConstructor<TState extends IMutableAggregateState | object | void> {
-	readonly handles?: string[];
-	new(options: IAggregateConstructorParams<TState>): IAggregate;
-}
-
-export type IAggregateFactory<TState extends IMutableAggregateState | object | void> =
-	(options: IAggregateConstructorParams<TState>) => IAggregate;
-
-export interface ISaga {
-	/** Unique Saga ID */
-	readonly id: Identifier;
-
-	/** List of commands emitted by Saga */
-	readonly uncommittedMessages: ICommand[];
-
-	/** Main entry point for Saga events */
-	apply(event: IEvent): void | Promise<void>;
-
-	/** Reset emitted commands when they are not longer needed */
-	resetUncommittedMessages(): void;
-
-	onError?(error: Error, options: { event: IEvent, command: ICommand }): void;
-}
-
-export type ISagaConstructorParams = {
-	id: Identifier,
-	events?: IEventSet
-};
-
-export type ISagaFactory = (options: ISagaConstructorParams) => ISaga;
-
-export interface ISagaConstructor {
-	new(options: ISagaConstructorParams): ISaga;
-
-	/** List of event types that trigger new saga start */
-	readonly startsWith: string[];
-
-	/** List of events being handled by Saga */
-	readonly handles: string[];
-}
-
-export interface IMessageHandler {
-	(...args: any[]): any | Promise<any>
-};
-
-export interface IObservable {
-	on(type: string, handler: IMessageHandler): void;
-
-	off(type: string, handler: IMessageHandler): void;
-
-	queue?(name: string): IObservable;
-}
-
-export interface IObserver {
-	subscribe(observable: IObservable): void;
-}
-
-/** Commands */
-
-export interface ICommandBus extends IObservable {
-	send(commandType: string, aggregateId: Identifier, options: { payload?: object, context?: object }):
-		Promise<IEventSet>;
-
-	sendRaw(command: ICommand):
-		Promise<IEventSet>;
-
-	on(type: string, handler: IMessageHandler): void;
-}
-
-export interface ICommandHandler extends IObserver {
-	subscribe(commandBus: ICommandBus): void;
-}
-
-/** Events */
-
-export type IEventQueryFilter = {
-	/** Get events emitted after this specific event */
-	afterEvent?: IEvent;
-
-	/** Get events emitted before this specific event */
-	beforeEvent?: IEvent;
-}
-
-export interface IEventStorage {
-	/**
-	 * Create unique identifier 
-	 */
-	getNewId(): Identifier | Promise<Identifier>;
-
-	commitEvents(events: IEventSet): Promise<IEventSet>;
-
-	getEvents(eventTypes?: Readonly<string[]>): IEventStream;
-
-	getAggregateEvents(aggregateId: Identifier, options?: { snapshot?: IEvent }): Promise<IEventSet>;
-
-	getSagaEvents(sagaId: Identifier, options: Pick<IEventQueryFilter, "beforeEvent">): Promise<IEventSet>;
-}
-
-export interface IEventStore extends IObservable {
-	readonly snapshotsSupported?: boolean;
-
-	getNewId(): Identifier | Promise<Identifier>;
-
-	commit(events: IEventSet): Promise<IEventSet>;
-
-	getAllEvents(eventTypes?: Readonly<string[]>): IEventStream;
-
-	getAggregateEvents(aggregateId: Identifier, options?: { snapshot?: IEvent }): Promise<IEventSet>;
-
-	getSagaEvents(sagaId: Identifier, options: Pick<IEventQueryFilter, "beforeEvent">): Promise<IEventSet>;
-
-	once(messageTypes: string | string[], handler?: IMessageHandler, filter?: (e: IEvent) => boolean): Promise<IEvent>;
-
-	queue(name: string): IObservable;
-
-	registerSagaStarters(startsWith: string[] | undefined): void;
-}
-
-export interface IEventReceptor extends IObserver {
-	subscribe(eventStore: IEventStore): void;
-}
-
-export interface IMessageBus extends IObservable {
-	send(command: ICommand): Promise<any>;
-	publish(event: IEvent): Promise<any>;
-}
-
-
-/** Projection */
-
-export interface IProjection<TView extends object> extends IObserver {
-	readonly view: TView;
-
-	subscribe(eventStore: IEventStore): Promise<void>;
-
-	project(event: IEvent): Promise<void>;
-}
-
-export interface IProjectionConstructor {
-	new(c?: any): IProjection<any>;
-	readonly handles?: string[];
-}
-
-// export type ProjectionViewFactoryParams = {
-// 	schemaVersion: string,
-// 	collectionName: string
-// }
-
-export interface IViewFactory<TView> {
-	(): TView;
-}
-
-export interface ILockable {
-	lock(): Promise<any>;
-	unlock(): Promise<any>;
-}
-
-export interface ILockableWithIndication extends ILockable {
-	locked: Readonly<boolean>;
-	once(event: 'unlocked'): Promise<void>;
-}
-
-export interface IProjectionView extends ILockable {
-
-	/**
-	 * Indicates if view is ready for new events projecting
-	 */
-	ready: boolean;
-
-	/**
-	 * Lock the view for external reads/writes
-	 */
-	lock(): Promise<boolean>;
-
-	/**
-	 * Unlock external read/write operations
-	 */
-	unlock(): Promise<void>;
-
-	/**
-	 * Wait till the view is ready to accept new events
-	 */
-	once(eventType: "ready"): Promise<void>;
-}
-
-export interface IPersistentView extends IProjectionView {
-
-	/**
-	 * Get last projected event
-	 */
-	getLastEvent(): Promise<IEvent | undefined>;
-
-	/**
-	 * Mark event as projecting to prevent its handling by another
-	 * projection instance working with the same storage.
-	 *
-	 * @returns False value if event is already processing or processed
-	 */
-	tryMarkAsProjecting(event: IEvent<any>): Promise<boolean>;
-
-	/**
-	 * Mark event as projected
-	 */
-	markAsProjected(event: IEvent<any>): Promise<void>;
-}
-
-
-/** Snapshots */
-
-type TSnapshot<TPayload = object> = {
-	/** 
-	 * Schema version of the data stored in `state` property.
-	 * Snapshots with older schema versions must be passed thru a data migration before applying for a newer schema
-	 */
-	schemaVersion: string | number;
-
-	/**
-	 * Last event that was processed before making a snapshot
-	 */
-	lastEvent: IEvent;
-
-	/**
-	 * Snapshot data
-	 */
-	data: TPayload;
-}
-
-interface ISnapshotStorage {
-	getSnapshot(id: Identifier): Promise<TSnapshot>;
-	saveSnapshot(id: Identifier, snapshot: TSnapshot): Promise<void>;
-}
-
-type ISnapshotEvent<TPayload> = IEvent<TSnapshot<TPayload>>;
-
-export interface IAggregateSnapshotStorage {
-	getAggregateSnapshot<TState>(aggregateId: Identifier): Promise<IEvent<TState> | undefined> | IEvent<TState> | undefined;
-
-	saveAggregateSnapshot<TState>(snapshotEvent: IEvent<TState>): Promise<void> | void;
-}
-
-
-/** Interfaces */
-
-export interface ILogger {
-	log(level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: { [key: string]: any }): void;
-	debug(message: string, meta?: { [key: string]: any }): void;
-	info(message: string, meta?: { [key: string]: any }): void;
-	warn(message: string, meta?: { [key: string]: any }): void;
-	error(message: string, meta?: { [key: string]: any }): void;
-}
-
-export interface IExtendableLogger extends ILogger {
-	child(meta?: { [key: string]: any }): IExtendableLogger;
-}

package/src/utils/getClassName.ts

@@ -1,6 +0,0 @@
-/**
- * Get instance class name
- */
-export function getClassName(instance: object): string {
-	return Object.getPrototypeOf(instance).constructor.name;
-}

package/src/utils/getHandledMessageTypes.ts

@@ -1,20 +0,0 @@
-import { getMessageHandlerNames } from './getMessageHandlerNames';
-
-/**
- * Get a list of message types handled by observer
- */
-export function getHandledMessageTypes(
-	observerInstanceOrClass: (object | Function) & { handles?: string[] }
-): string[] {
-	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);
-}

package/src/utils/getHandler.ts

@@ -1,20 +0,0 @@
-import { IMessageHandler } from "../interfaces";
-
-/**
- * Gets a handler for a specific message type, prefers a public (w\o _ prefix) method, if available
- */
-export function getHandler(context: { [key: string]: any }, messageType: string): IMessageHandler | null {
-	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.ts

@@ -1,44 +0,0 @@
-const KNOWN_METHOD_NAMES = new Set([
-	'subscribe'
-]);
-
-function getInheritedPropertyNames(prototype: object): string[] {
-	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 ("_").
- */
-export function getMessageHandlerNames(observerInstanceOrClass: (object | Function)): string[] {
-	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');
-}

package/src/utils/index.ts

@@ -1,8 +0,0 @@
-export * from './getClassName';
-export * from './getHandler';
-export * from './validateHandlers';
-export * from './getMessageHandlerNames';
-export * from './getHandledMessageTypes';
-export * from './setupOneTimeEmitterSubscription';
-export * from './subscribe';
-export * from './isClass';

package/src/utils/isClass.ts

@@ -1,4 +0,0 @@
-export function isClass(func: Function) {
-	return typeof func === 'function'
-		&& Function.prototype.toString.call(func).startsWith('class');
-}

package/src/utils/setupOneTimeEmitterSubscription.ts

@@ -1,57 +0,0 @@
-import { IEvent, ILogger, IObservable } from "../interfaces";
-
-/**
- * Create one-time eventEmitter subscription for one or multiple events that match a filter
- *
- * @param {IObservable} emitter
- * @param {string[]} messageTypes Array of event type to subscribe to
- * @param {function(IEvent):any} [handler] Optional handler to execute for a first event received
- * @param {function(IEvent):boolean} [filter] Optional filter to apply before executing a handler
- * @param {ILogger} logger
- * @return {Promise<IEvent>} Resolves to first event that passes filter
- */
-export function setupOneTimeEmitterSubscription(
-	emitter: IObservable,
-	messageTypes: string[],
-	filter?: (e: IEvent) => boolean,
-	handler?: (e: IEvent) => void,
-	logger?: ILogger
-): Promise<IEvent> {
-	if (typeof emitter !== 'object' || !emitter)
-		throw new TypeError('emitter argument must be an Object');
-	if (!Array.isArray(messageTypes) || messageTypes.some(m => !m || typeof m !== 'string'))
-		throw new TypeError('messageTypes argument must be an Array of non-empty Strings');
-	if (handler && typeof handler !== 'function')
-		throw new TypeError('handler argument, when specified, must be a Function');
-	if (filter && typeof filter !== 'function')
-		throw new TypeError('filter argument, when specified, must be a Function');
-
-	return new Promise(resolve => {
-
-		// handler will be invoked only once,
-		// even if multiple events have been emitted before subscription was destroyed
-		// https://nodejs.org/api/events.html#events_emitter_removelistener_eventname_listener
-		let handled = false;
-
-		function filteredHandler(event: IEvent) {
-			if (filter && !filter(event)) return;
-			if (handled) return;
-			handled = true;
-
-			for (const messageType of messageTypes)
-				emitter.off(messageType, filteredHandler);
-
-			logger?.debug(`'${event.type}' received, one-time subscription to '${messageTypes.join(',')}' removed`);
-
-			if (handler)
-				handler(event);
-
-			resolve(event);
-		}
-
-		for (const messageType of messageTypes)
-			emitter.on(messageType, filteredHandler);
-
-		logger?.debug(`set up one-time ${filter ? 'filtered subscription' : 'subscription'} to '${messageTypes.join(',')}'`);
-	});
-}

package/src/utils/subscribe.ts

@@ -1,51 +0,0 @@
-import { IMessageHandler, IObservable } from "../interfaces";
-import { getHandler } from './getHandler';
-import { getHandledMessageTypes } from './getHandledMessageTypes';
-
-const unique = <T>(arr: T[]): T[] => [...new Set(arr)];
-
-/**
- * Subscribe observer to observable
- */
-export function subscribe(
-	observable: IObservable,
-	observer: object,
-	options: {
-		messageTypes?: string[],
-		masterHandler?: IMessageHandler,
-		queueName?: string
-	} = {}
-) {
-	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) {
-			if(!observable.queue)
-				throw new TypeError('Observer does not support named queues');
-
-			observable.queue(queueName).on(messageType, handler);
-		}
-		else {
-			observable.on(messageType, handler);
-		}
-	}
-}

package/src/utils/validateHandlers.ts

@@ -1,19 +0,0 @@
-import { getHandler } from './getHandler';
-
-/**
- * Ensure instance has handlers declared for all handled message types
- */
-export function validateHandlers(instance: object, handlesFieldName = 'handles') {
-	if (!instance) throw new TypeError('instance argument required');
-
-	const messageTypes = Object.getPrototypeOf(instance).constructor[handlesFieldName];
-	if (messageTypes === undefined)
-		return;
-	if (!Array.isArray(messageTypes))
-		throw new TypeError('handles getter, when defined, must return an Array of Strings');
-
-	for (const type of messageTypes) {
-		if (!getHandler(instance, type))
-			throw new Error(`'${type}' handler is not defined or not a function`);
-	}
-}