node-cqrs 0.16.4 → 0.17.0

package/dist/utils/setupOneTimeEmitterSubscription.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupOneTimeEmitterSubscription = setupOneTimeEmitterSubscription;
+/**
+ * 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
+ */
+function setupOneTimeEmitterSubscription(emitter, messageTypes, filter, handler, logger) {
+    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) {
+            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(',')}'`);
+    });
+}
+//# sourceMappingURL=setupOneTimeEmitterSubscription.js.map

package/dist/utils/setupOneTimeEmitterSubscription.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupOneTimeEmitterSubscription.js","sourceRoot":"","sources":["../../src/utils/setupOneTimeEmitterSubscription.ts"],"names":[],"mappings":";;AAYA,0EA4CC;AAtDD;;;;;;;;;GASG;AACH,SAAgB,+BAA+B,CAC9C,OAAoB,EACpB,YAAsB,EACtB,MAA+B,EAC/B,OAA6B,EAC7B,MAAgB;IAEhB,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,OAAO;QAC1C,MAAM,IAAI,SAAS,CAAC,oCAAoC,CAAC,CAAC;IAC3D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,CAAC;QACtF,MAAM,IAAI,SAAS,CAAC,6DAA6D,CAAC,CAAC;IACpF,IAAI,OAAO,IAAI,OAAO,OAAO,KAAK,UAAU;QAC3C,MAAM,IAAI,SAAS,CAAC,sDAAsD,CAAC,CAAC;IAC7E,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,UAAU;QACzC,MAAM,IAAI,SAAS,CAAC,qDAAqD,CAAC,CAAC;IAE5E,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;QAE5B,qCAAqC;QACrC,8EAA8E;QAC9E,sFAAsF;QACtF,IAAI,OAAO,GAAG,KAAK,CAAC;QAEpB,SAAS,eAAe,CAAC,KAAa;YACrC,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;gBAAE,OAAO;YACrC,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YAEf,KAAK,MAAM,WAAW,IAAI,YAAY;gBACrC,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;YAE3C,MAAM,EAAE,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,yCAAyC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YAExG,IAAI,OAAO;gBACV,OAAO,CAAC,KAAK,CAAC,CAAC;YAEhB,OAAO,CAAC,KAAK,CAAC,CAAC;QAChB,CAAC;QAED,KAAK,MAAM,WAAW,IAAI,YAAY;YACrC,OAAO,CAAC,EAAE,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;QAE1C,MAAM,EAAE,KAAK,CAAC,mBAAmB,MAAM,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,cAAc,QAAQ,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtH,CAAC,CAAC,CAAC;AACJ,CAAC"}

package/dist/utils/subscribe.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribe = subscribe;
+const getHandler_1 = require("./getHandler");
+const getHandledMessageTypes_1 = require("./getHandledMessageTypes");
+const unique = (arr) => [...new Set(arr)];
+/**
+ * Subscribe observer to observable
+ */
+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 || (0, getHandledMessageTypes_1.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 || (0, getHandler_1.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);
+        }
+    }
+}
+//# sourceMappingURL=subscribe.js.map

package/dist/utils/subscribe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.js","sourceRoot":"","sources":["../../src/utils/subscribe.ts"],"names":[],"mappings":";;AASA,8BAyCC;AAjDD,6CAA0C;AAC1C,qEAAkE;AAElE,MAAM,MAAM,GAAG,CAAI,GAAQ,EAAO,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvD;;GAEG;AACH,SAAgB,SAAS,CACxB,UAAuB,EACvB,QAAgB,EAChB,UAII,EAAE;IAEN,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,CAAC,UAAU;QAChD,MAAM,IAAI,SAAS,CAAC,uCAAuC,CAAC,CAAC;IAC9D,IAAI,OAAO,UAAU,CAAC,EAAE,KAAK,UAAU;QACtC,MAAM,IAAI,SAAS,CAAC,kCAAkC,CAAC,CAAC;IACzD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,QAAQ;QAC5C,MAAM,IAAI,SAAS,CAAC,qCAAqC,CAAC,CAAC;IAE5D,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;IAC3D,IAAI,aAAa,IAAI,OAAO,aAAa,KAAK,UAAU;QACvD,MAAM,IAAI,SAAS,CAAC,4DAA4D,CAAC,CAAC;IACnF,IAAI,SAAS,IAAI,OAAO,UAAU,CAAC,KAAK,KAAK,UAAU;QACtD,MAAM,IAAI,SAAS,CAAC,mEAAmE,CAAC,CAAC;IAE1F,MAAM,WAAW,GAAG,YAAY,IAAI,IAAA,+CAAsB,EAAC,QAAQ,CAAC,CAAC;IACrE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;QAC9B,MAAM,IAAI,SAAS,CAAC,mFAAmF,CAAC,CAAC;IAE1G,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QAC/C,MAAM,OAAO,GAAG,aAAa,IAAI,IAAA,uBAAU,EAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAClE,IAAI,CAAC,OAAO;YACZ,MAAM,IAAI,KAAK,CAAC,IAAI,WAAW,4CAA4C,CAAC,CAAC;QAE9E,IAAI,SAAS,EAAE,CAAC;YACf,IAAG,CAAC,UAAU,CAAC,KAAK;gBACnB,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,CAAC;YAE/D,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QACtD,CAAC;aACI,CAAC;YACL,UAAU,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QACrC,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/utils/validateHandlers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHandlers = validateHandlers;
+const getHandler_1 = require("./getHandler");
+/**
+ * Ensure instance has handlers declared for all handled message types
+ */
+function validateHandlers(instance, 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 (!(0, getHandler_1.getHandler)(instance, type))
+            throw new Error(`'${type}' handler is not defined or not a function`);
+    }
+}
+//# sourceMappingURL=validateHandlers.js.map

package/dist/utils/validateHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateHandlers.js","sourceRoot":"","sources":["../../src/utils/validateHandlers.ts"],"names":[],"mappings":";;AAKA,4CAaC;AAlBD,6CAA0C;AAE1C;;GAEG;AACH,SAAgB,gBAAgB,CAAC,QAAgB,EAAE,gBAAgB,GAAG,SAAS;IAC9E,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,SAAS,CAAC,4BAA4B,CAAC,CAAC;IAEjE,MAAM,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;IACnF,IAAI,YAAY,KAAK,SAAS;QAC7B,OAAO;IACR,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;QAC/B,MAAM,IAAI,SAAS,CAAC,+DAA+D,CAAC,CAAC;IAEtF,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QACjC,IAAI,CAAC,IAAA,uBAAU,EAAC,QAAQ,EAAE,IAAI,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,IAAI,IAAI,4CAA4C,CAAC,CAAC;IACxE,CAAC;AACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-cqrs",
-  "version": "0.16.4",
+  "version": "0.17.0",
   "description": "Basic ES6 backbone for CQRS app development",
   "repository": {
     "type": "git",
@@ -18,20 +18,25 @@
     "domain",
     "eventstore"
   ],
-  "main": "src/index.js",
-  "types": "types/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./src/index.ts",
   "engines": {
     "node": ">=10.3.0"
   },
   "scripts": {
-    "lint": "eslint . --max-warnings=0",
-    "test": "mocha ./tests/unit/index.js ./examples/user-domain-tests",
-    "test:coverage": "nyc --reporter=lcov --reporter=text-summary node_modules/.bin/_mocha ./tests/unit/index.js",
+    "pretest": "npm run build",
+    "test": "jest --verbose tests/unit",
+    "test:coverage": "jest --collect-coverage tests/unit",
+    "pretest:integration": "npm run build",
+    "test:integration": "jest --verbose examples/user-domain-tests",
     "pretest:coveralls": "npm run test:coverage",
     "test:coveralls": "cat ./coverage/lcov.info | coveralls",
     "posttest:coveralls": "rm -rf ./coverage",
     "changelog": "conventional-changelog -n ./scripts/changelog -i CHANGELOG.md -s",
-    "preversion": "npm run lint && npm test",
+    "clean": "tsc --build --clean",
+    "build": "tsc --build",
+    "prepare": "npm run build",
+    "preversion": "npm test",
     "version": "npm run changelog && git add CHANGELOG.md"
   },
   "author": "@snatalenko",
@@ -41,11 +46,17 @@
     "di0": "^1.0.0"
   },
   "devDependencies": {
-    "chai": "^4.3.6",
+    "@types/chai": "^4.3.17",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.14.14",
+    "@types/sinon": "^10.0.20",
+    "chai": "^4.5.0",
+    "conventional-changelog": "^3.1.25",
     "coveralls": "^3.1.1",
-    "eslint": "^8.7.0",
-    "mocha": "^9.2.0",
-    "nyc": "^15.1.0",
-    "sinon": "^12.0.1"
+    "jest": "^29.7.0",
+    "sinon": "^15.2.0",
+    "ts-jest": "^29.2.4",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
   }
 }

package/src/AbstractAggregate.ts

@@ -0,0 +1,223 @@
+import {
+	IAggregate,
+	IMutableAggregateState,
+	ICommand,
+	Identifier,
+	IEvent,
+	IEventSet,
+	IAggregateConstructorParams
+} from "./interfaces";
+
+import { getClassName, validateHandlers, getHandler } from './utils';
+
+/**
+ * Deep-clone simple JS object
+ */
+function clone<T>(obj: T): T {
+	return JSON.parse(JSON.stringify(obj));
+}
+
+const SNAPSHOT_EVENT_TYPE = 'snapshot';
+
+/**
+ * Base class for Aggregate definition
+ */
+export abstract class AbstractAggregate<TState extends IMutableAggregateState | object | void> implements IAggregate {
+
+	/**
+	 * Optional list of commands handled by Aggregate.
+	 * 
+	 * If not overridden in Aggregate implementation,
+	 * `AggregateCommandHandler` will treat all public methods as command handlers
+	 *
+	 * @example
+	 * 	return ['createUser', 'changePassword'];
+	 */
+	static get handles(): string[] | undefined {
+		return undefined;
+	}
+
+	#id: Identifier;
+	#changes: IEvent[] = [];
+	#version: number = 0;
+	#snapshotVersion: number | undefined;
+
+	/** Internal aggregate state */
+	protected state: TState;
+
+	/** Command being handled by aggregate */
+	protected command?: ICommand;
+
+	/** Unique aggregate instance identifier */
+	get id(): Identifier {
+		return this.#id;
+	}
+
+	/** Aggregate instance version */
+	get version(): number {
+		return this.#version;
+	}
+
+	/** Restored snapshot version */
+	get snapshotVersion(): number | undefined {
+		return this.#snapshotVersion;
+	}
+
+	/** Events emitted by Aggregate */
+	get changes(): IEventSet {
+		return [...this.#changes];
+	}
+
+	/**
+	 * Override to define whether an aggregate state snapshot should be taken
+	 *
+	 * @example
+	 * 	// create snapshot every 50 events
+	 * 	return this.version % 50 === 0;
+	 */
+	get shouldTakeSnapshot(): boolean {
+		return false;
+	}
+
+	constructor(options: IAggregateConstructorParams<TState>) {
+		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;
+
+		validateHandlers(this);
+
+		if (state)
+			this.state = state;
+
+		if (events)
+			events.forEach(event => this.mutate(event));
+	}
+
+	/** Pass command to command handler */
+	handle(command: ICommand) {
+		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 */
+	mutate(event) {
+		if (event.aggregateVersion !== undefined)
+			this.#version = event.aggregateVersion;
+
+		if (event.type === SNAPSHOT_EVENT_TYPE) {
+			this.#snapshotVersion = event.aggregateVersion;
+			this.restoreSnapshot(event);
+		}
+		else if (this.state) {
+			const handler = 'mutate' in this.state ?
+				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 emit<TPayload>(type: string, payload?: TPayload) {
+		if (typeof type !== 'string' || !type.length)
+			throw new TypeError('type argument must be a non-empty string');
+
+		const event = this.makeEvent<TPayload>(type, payload, this.command);
+
+		this.emitRaw(event);
+	}
+
+	/** Format event based on a current aggregate state and a command being executed */
+	protected makeEvent<TPayload>(type: string, payload?: TPayload, sourceCommand?: ICommand): IEvent<TPayload> {
+		const event: IEvent<TPayload> = {
+			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 emitRaw<TPayload>(event: IEvent<TPayload>): void {
+		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 */
+	makeSnapshot(): TState {
+		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 restoreSnapshot(snapshotEvent: IEvent<TState>) {
+		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 */
+	toString(): string {
+		return `${getClassName(this)} ${this.id} (v${this.version})`;
+	}
+}

package/src/AbstractProjection.ts

@@ -0,0 +1,172 @@
+import { InMemoryView } from './infrastructure/InMemoryView';
+
+import {
+	IProjectionView,
+	IEvent,
+	IPersistentView,
+	IEventStore,
+	IExtendableLogger,
+	ILogger,
+	IProjection,
+	IViewFactory
+} from "./interfaces";
+
+import {
+	getClassName,
+	validateHandlers,
+	getHandler,
+	getHandledMessageTypes,
+	subscribe
+} from './utils';
+
+const isProjectionView = (view: IProjectionView): view is IProjectionView =>
+	'ready' in view &&
+	'lock' in view &&
+	'unlock' in view &&
+	'once' in view;
+
+const asProjectionView = (view: any): IProjectionView | undefined =>
+	(isProjectionView(view) ? view : undefined);
+
+/**
+ * Base class for Projection definition
+ */
+export abstract class AbstractProjection<TView extends IProjectionView | IPersistentView> implements IProjection<TView> {
+
+	/**
+	 * 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 get handles(): string[] | undefined {
+		return undefined;
+	}
+
+	/**
+	 * Default view associated with projection
+	 */
+	get view(): TView {
+		if (!this.#view)
+			this.#view = this.#viewFactory();
+
+		return this.#view;
+	}
+
+	#viewFactory: IViewFactory<TView>;
+	#view?: TView;
+
+	protected _logger?: ILogger;
+
+	get collectionName(): string {
+		return getClassName(this);
+	}
+
+	/**
+	 * Indicates if view should be restored from EventStore on start.
+	 * Override for custom behavior.
+	 */
+	get shouldRestoreView(): boolean | Promise<boolean> {
+		return (this.view instanceof Map)
+			|| (this.view instanceof InMemoryView);
+	}
+
+	constructor({
+		view,
+		viewFactory = InMemoryView.factory,
+		logger
+	}: {
+		view?: TView,
+		viewFactory?: IViewFactory<TView>,
+		logger?: ILogger | IExtendableLogger
+	} = {}) {
+		validateHandlers(this);
+
+		this.#viewFactory = view ?
+			() => view :
+			viewFactory;
+
+		this._logger = logger && 'child' in logger ?
+			logger.child({ service: getClassName(this) }) :
+			logger;
+	}
+
+	/** Subscribe to event store */
+	async subscribe(eventStore: IEventStore): Promise<void> {
+		subscribe(eventStore, this, {
+			masterHandler: (e: IEvent) => this.project(e)
+		});
+
+		await this.restore(eventStore);
+	}
+
+	/** Pass event to projection event handler */
+	async project(event: IEvent): Promise<void> {
+		const concurrentView = asProjectionView(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 async _project(event: IEvent): Promise<void> {
+		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 */
+	async restore(eventStore: IEventStore): Promise<void> {
+		// lock the view to ensure same restoring procedure
+		// won't be performed by another projection instance
+		const concurrentView = asProjectionView(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 async _restore(eventStore: IEventStore): Promise<void> {
+		if (!eventStore)
+			throw new TypeError('eventStore argument required');
+		if (typeof eventStore.getAllEvents !== 'function')
+			throw new TypeError('eventStore.getAllEvents must be a Function');
+
+		this._logger?.debug('retrieving events and restoring projection...');
+
+		const messageTypes = getHandledMessageTypes(this);
+		const eventsIterable = eventStore.getAllEvents(messageTypes);
+		let eventsCount = 0;
+		const startTs = Date.now();
+
+		for await (const event of eventsIterable) {
+			try {
+				await this._project(event);
+				eventsCount += 1;
+			}
+			catch (err) {
+				this._onRestoringError(err, event);
+			}
+		}
+
+		this._logger?.info(`view restored (${this.view}) from ${eventsCount} event(s) in ${Date.now() - startTs} ms`);
+	}
+
+	/** Handle error on restoring. Logs and throws error by default */
+	protected _onRestoringError(error: Error, event: IEvent) {
+		this._logger?.error(`view restoring has failed (view will remain locked): ${error.message}`, {
+			service: getClassName(this),
+			event,
+			stack: error.stack
+		});
+		throw error;
+	}
+}