@signageos/lib 23.8.1 → 23.8.2-master.4405

package/dist/AMQP/EventSourcing/EventConsumer/AmqpEventConsumer.js

@@ -0,0 +1,218 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmqpEventConsumer = void 0;
+var lockedDecorator_1 = require("../../../Lock/lockedDecorator");
+var logging_1 = require("../../../Logging/logging");
+var eventQueueDomain_1 = require("../eventQueueDomain");
+var eventConsumerMetrics_1 = require("../../../Metrics/eventConsumerMetrics");
+var consumerLogger = logging_1.logger.createNamespace('EventConsumer');
+var DEFAULT_DOMAIN = 'default';
+var LOCK_NAMESPACE = 'AmqpEventConsumer';
+/**
+ * High level abstraction of event consumption
+ *
+ * This implementation uses AMQP queues to consume events.
+ *
+ * It abstracts all the implementation details of setting up consumption of events
+ * and provides a simple interface so that the consumer can focus on just handling the events.
+ *
+ * All events are consumed from a single queue in a sequential order.
+ * The name of the queue will be constructed from the consumer name and the domain as "<consumerName>_<domain>".
+ */
+var AmqpEventConsumer = /** @class */ (function () {
+    /**
+     * @param amqpConnection The AMQP connection to use
+     * @param consumerName The name of the consumer. This is used to identify the consumer in the AMQP queue
+     * @param domain The domain to consume events from. Defaults to 'default'
+     * @param options Additional options for the consumer
+     */
+    function AmqpEventConsumer(_a) {
+        var amqpConnection = _a.amqpConnection, consumerName = _a.consumerName, domain = _a.domain, options = _a.options;
+        this.consumerCallbacks = {};
+        this.stopCallback = null;
+        this.started = false;
+        this.amqpConnection = amqpConnection;
+        this.consumerName = consumerName;
+        this.domain = domain || DEFAULT_DOMAIN;
+        this.options = options;
+    }
+    /**
+     * Add a consumer for a specific event type
+     *
+     * Has to be called before calling listen(), otherwise it will throw an error.
+     */
+    AmqpEventConsumer.prototype.addEventConsumer = function (eventType, callback, option) {
+        if (this.consumerCallbacks[eventType]) {
+            throw new Error("Consumer for event type ".concat(eventType, " already registered"));
+        }
+        if (this.started) {
+            throw new Error('Cannot add event consumer after consumer has started');
+        }
+        this.consumerCallbacks[eventType] = {
+            callback: callback,
+            schema: option === null || option === void 0 ? void 0 : option.schema,
+        };
+    };
+    AmqpEventConsumer.prototype.listen = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.started) {
+                            throw new Error('Event consumer already started');
+                        }
+                        return [4 /*yield*/, this.bindEvents()];
+                    case 1:
+                        _a.sent();
+                        this.started = true;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmqpEventConsumer.prototype.close = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var closeChannel;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.stopCallback) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.stopCallback()];
+                    case 1:
+                        closeChannel = _a.sent();
+                        return [4 /*yield*/, closeChannel()];
+                    case 2:
+                        _a.sent();
+                        this.stopCallback = null;
+                        _a.label = 3;
+                    case 3:
+                        this.started = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmqpEventConsumer.prototype.bindEvents = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var eventTypes, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        eventTypes = Object.keys(this.consumerCallbacks);
+                        _a = this;
+                        return [4 /*yield*/, (0, eventQueueDomain_1.bindDomain)(this.amqpConnection, eventTypes, this.domain, this.consumerName, this.consumeEvent.bind(this), this.options)];
+                    case 1:
+                        _a.stopCallback = _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AmqpEventConsumer.prototype.shouldConsumeEvent = function (options) {
+        if (options.schema) {
+            return options.schema.safeParse(options.event).success;
+        }
+        return true;
+    };
+    AmqpEventConsumer.prototype.consumeEvent = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, _a, callback, schema, e_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        start = new Date().getTime();
+                        eventConsumerMetrics_1.metrics.emit('events_total', { eventType: event.type });
+                        eventConsumerMetrics_1.metrics.emit('event_duration_seconds_total', { eventType: event.type, phase: 'eventStart' }, start - event.receivedAt.getTime());
+                        eventConsumerMetrics_1.metrics.emit('event_duration_seconds_total', { eventType: event.type, phase: 'commandStart' }, event.receivedAt.getTime() - event.dispatchedAt.getTime());
+                        _a = this.consumerCallbacks[event.type] || {}, callback = _a.callback, schema = _a.schema;
+                        if (!callback) {
+                            eventConsumerMetrics_1.metrics.emit('event_error_total', { eventType: event.type });
+                            throw new Error("Event ".concat(event.type, " received but no consumer registered"));
+                        }
+                        if (!this.shouldConsumeEvent({ schema: schema, event: event })) return [3 /*break*/, 6];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, callback(event)];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        e_1 = _b.sent();
+                        eventConsumerMetrics_1.metrics.emit('event_error_total', { eventType: event.type });
+                        consumerLogger.error("An error occured while consuming event ".concat(event.type), { event: event, error: e_1 });
+                        throw e_1;
+                    case 4:
+                        eventConsumerMetrics_1.metrics.emit('event_duration_seconds_total', { eventType: event.type, phase: 'processing' }, new Date().getTime() - start);
+                        eventConsumerMetrics_1.metrics.emit('event_duration_seconds', { eventType: event.type }, new Date().getTime() - start);
+                        return [7 /*endfinally*/];
+                    case 5:
+                        eventConsumerMetrics_1.metrics.emit('event_success_total', { eventType: event.type });
+                        consumerLogger.info("Event ".concat(event.type, " consumed"), { event: event });
+                        _b.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    __decorate([
+        (0, lockedDecorator_1.locked)(LOCK_NAMESPACE, { scope: 'instance' }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], AmqpEventConsumer.prototype, "listen", null);
+    __decorate([
+        (0, lockedDecorator_1.locked)(LOCK_NAMESPACE, { scope: 'instance' }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], AmqpEventConsumer.prototype, "close", null);
+    return AmqpEventConsumer;
+}());
+exports.AmqpEventConsumer = AmqpEventConsumer;
+//# sourceMappingURL=AmqpEventConsumer.js.map

package/dist/AMQP/EventSourcing/EventConsumer/AmqpEventConsumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmqpEventConsumer.js","sourceRoot":"","sources":["../../../../src/AMQP/EventSourcing/EventConsumer/AmqpEventConsumer.ts"],"names":[],"mappings":"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"}

package/dist/AMQP/EventSourcing/EventConsumer/IEventConsumer.d.ts

@@ -0,0 +1,13 @@
+import { ZodObject } from 'zod';
+import IEvent, { IEventPayload } from '../IEvent';
+export type EventCallback<TPayload extends IEventPayload> = (event: IEvent<TPayload>) => Promise<void>;
+export type EventOptions = {
+    schema?: ZodObject<any>;
+};
+/**
+ * High level abstraction of event consumption
+ */
+export interface IEventConsumer {
+    /** Add a consumer for a specific event type */
+    addEventConsumer<TPayload extends IEventPayload>(eventType: string, callback: EventCallback<TPayload>, options?: EventOptions): void;
+}

package/dist/AMQP/EventSourcing/EventConsumer/IEventConsumer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IEventConsumer.js.map

package/dist/AMQP/EventSourcing/EventConsumer/IEventConsumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IEventConsumer.js","sourceRoot":"","sources":["../../../../src/AMQP/EventSourcing/EventConsumer/IEventConsumer.ts"],"names":[],"mappings":""}

package/dist/AMQP/EventSourcing/EventConsumer/InMemoryEventConsumer.d.ts

@@ -0,0 +1,15 @@
+import IEvent, { IEventPayload } from '../IEvent';
+import { EventCallback, IEventConsumer } from './IEventConsumer';
+/**
+ * In-memory implementation of IEventConsumer
+ *
+ * Main use case is for testing so that the tests are not dependent on AMQP or other external services
+ */
+export declare class InMemoryEventConsumer implements IEventConsumer {
+    private emitter;
+    addEventConsumer<TPayload extends IEventPayload>(eventType: string, callback: EventCallback<TPayload>): Promise<void>;
+    /**
+     * Will deliver the event to all consumers that were added via addEventConsumer
+     */
+    emitEvent<TPayload extends IEventPayload>(event: IEvent<TPayload>): Promise<void>;
+}

package/dist/AMQP/EventSourcing/EventConsumer/InMemoryEventConsumer.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryEventConsumer = void 0;
+var AsyncEventEmitter_1 = require("../../../Events/AsyncEventEmitter");
+/**
+ * In-memory implementation of IEventConsumer
+ *
+ * Main use case is for testing so that the tests are not dependent on AMQP or other external services
+ */
+var InMemoryEventConsumer = /** @class */ (function () {
+    function InMemoryEventConsumer() {
+        this.emitter = new AsyncEventEmitter_1.AsyncEventEmitter();
+    }
+    InMemoryEventConsumer.prototype.addEventConsumer = function (eventType, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.emitter.addListener(eventType, callback);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Will deliver the event to all consumers that were added via addEventConsumer
+     */
+    InMemoryEventConsumer.prototype.emitEvent = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.emitter.emit(event.type, event)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return InMemoryEventConsumer;
+}());
+exports.InMemoryEventConsumer = InMemoryEventConsumer;
+//# sourceMappingURL=InMemoryEventConsumer.js.map

package/dist/AMQP/EventSourcing/EventConsumer/InMemoryEventConsumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryEventConsumer.js","sourceRoot":"","sources":["../../../../src/AMQP/EventSourcing/EventConsumer/InMemoryEventConsumer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uEAAsE;AAItE;;;;GAIG;AACH;IAAA;QACS,YAAO,GAAsB,IAAI,qCAAiB,EAAE,CAAC;IAY9D,CAAC;IAVa,gDAAgB,GAA7B,UAA8D,SAAiB,EAAE,QAAiC;;;gBACjH,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;;;;KAC9C;IAED;;OAEG;IACU,yCAAS,GAAtB,UAAuD,KAAuB;;;;4BAC7E,qBAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,EAAA;;wBAA1C,SAA0C,CAAC;;;;;KAC3C;IACF,4BAAC;AAAD,CAAC,AAbD,IAaC;AAbY,sDAAqB"}

package/dist/AMQP/EventSourcing/IEvent.d.ts

@@ -0,0 +1,72 @@
+export interface IEventPayload<TType extends string = string> {
+    type: TType;
+}
+/**
+ * Event is a representation of a single event that happened in the system.
+ * It's a wrapper interface for a generic event payload.
+ * It contains all the necessary metadata for the event.
+ * This event is mostly used for event sourcing.
+ */
+interface IEvent<TPayload extends IEventPayload> {
+    /**
+     * Unique identifier of the event.
+     * In MongoDB, it is stored as `_id` and is automatically generated.
+     */
+    id: string;
+    /**
+     * Unique identifier of the command that caused the event.
+     * You can find it in {@link import("../CQRS/ICommand").id}.
+     */
+    commandId: string;
+    /**
+     * Type of the event.
+     * It should be always the same as {@link IEventPayload['type']}.
+     */
+    type: string;
+    /**
+     * Identifier of the source of the event.
+     * It's usually the same as the {@link import("../CQRS/ICommand").sourceUid}.
+     * It's usually used for logging and debugging.
+     * It can be used in some cases to identify the source of the event
+     * and to check if the event was dispatched by the same source as the command.
+     */
+    sourceUid: string;
+    /**
+     * Date when the original command was dispatched.
+     * It's the same as {@link import("../CQRS/ICommand").receivedAt}.
+     * It can differ when the event is not produced by the command.
+     */
+    dispatchedAt: Date;
+    /**
+     * Date when the event was received (written) to event store.
+     * This date is the most important date that should be used
+     * as a replacement for the `Date.now()` function.
+     * Since event sourcing is used as a source of truth,
+     * for consistency, all dates should be based on this date.
+     */
+    receivedAt: Date;
+    /**
+     * All events are ordered by the `receivedAt` date.
+     * However, in some cases, there are multiple events emitted with the same `receivedAt` date.
+     * It's the case where a single command emits multiple events.
+     * In this case, the `secondaryIndex` is used to order the events.
+     * So it's the important part of the ordering of the events.
+     * See also {@link import("../CQRS/commandQueue").ITimestamp}.
+     */
+    secondaryIndex: number;
+    /**
+     * Lock keys are used to identify affected domains of the event.
+     * It's used for specifying the dependencies between the events.
+     * Only those events within the same lock key are dependent on each other.
+     * So the order of the events is guaranteed only within the same lock key.
+     * Events with different lock keys can be processed in parallel.
+     */
+    lockKeys: string[];
+    /**
+     * The generic payload of the event.
+     * The only required field is the `type` field.
+     * The `type` field should always be the same as the `type` field of the event.
+     */
+    payload: TPayload;
+}
+export default IEvent;

package/dist/AMQP/EventSourcing/IEvent.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IEvent.js.map

package/dist/AMQP/EventSourcing/IEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IEvent.js","sourceRoot":"","sources":["../../../src/AMQP/EventSourcing/IEvent.ts"],"names":[],"mappings":""}

package/dist/AMQP/EventSourcing/Locked/deferredState.d.ts

@@ -0,0 +1,21 @@
+import { IDeferred } from '../../../Promise/deferred';
+/**
+ * DeferredState is a helper class for managing deferred promises for the LockedEventConsumer.
+ * It allows to manage internal map of deferred promises for each lock-key.
+ */
+export declare class DeferredState {
+    private deferredMap;
+    /**
+     * Create a deferred for the current lock-keys and push it to the list for subsequent promises to wait on.
+     */
+    addDeferred(lockKeys: string[]): IDeferred<void>;
+    /**
+     * Remove the deferred from the list for the given lock-keys.
+     * If the list becomes empty, remove it from the map (cleanup).
+     */
+    removeDeferred(lockKeys: string[], deferred: IDeferred<void>): void;
+    /**
+     * Get a list of promises for all previously created deferred with the same lock-keys.
+     */
+    getPreviousPromises(lockKeys: string[]): Promise<void>[];
+}

package/dist/AMQP/EventSourcing/Locked/deferredState.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeferredState = void 0;
+var deferred_1 = require("../../../Promise/deferred");
+var debug_1 = __importDefault(require("debug"));
+var debug = (0, debug_1.default)('@signageos/lib:AMQP:EventSourcing:Locked:deferredState');
+/**
+ * DeferredState is a helper class for managing deferred promises for the LockedEventConsumer.
+ * It allows to manage internal map of deferred promises for each lock-key.
+ */
+var DeferredState = /** @class */ (function () {
+    function DeferredState() {
+        this.deferredMap = new Map();
+    }
+    /**
+     * Create a deferred for the current lock-keys and push it to the list for subsequent promises to wait on.
+     */
+    DeferredState.prototype.addDeferred = function (lockKeys) {
+        var _a;
+        debug('Adding deferred for lock-keys', { lockKeys: lockKeys });
+        var currentDeferred = (0, deferred_1.createDeferred)(true);
+        for (var _i = 0, lockKeys_1 = lockKeys; _i < lockKeys_1.length; _i++) {
+            var lockKey = lockKeys_1[_i];
+            var listOfDeferred = (_a = this.deferredMap.get(lockKey)) !== null && _a !== void 0 ? _a : [];
+            this.deferredMap.set(lockKey, listOfDeferred);
+            listOfDeferred.push(currentDeferred);
+        }
+        return currentDeferred;
+    };
+    /**
+     * Remove the deferred from the list for the given lock-keys.
+     * If the list becomes empty, remove it from the map (cleanup).
+     */
+    DeferredState.prototype.removeDeferred = function (lockKeys, deferred) {
+        var _a;
+        debug('Removing deferred for lock-keys', { lockKeys: lockKeys });
+        for (var _i = 0, lockKeys_2 = lockKeys; _i < lockKeys_2.length; _i++) {
+            var lockKey = lockKeys_2[_i];
+            var listOfDeferred = (_a = this.deferredMap.get(lockKey)) !== null && _a !== void 0 ? _a : [];
+            var index = listOfDeferred.indexOf(deferred);
+            if (index !== -1) {
+                listOfDeferred.splice(index, 1);
+            }
+            if (listOfDeferred.length === 0) {
+                this.deferredMap.delete(lockKey);
+            }
+        }
+    };
+    /**
+     * Get a list of promises for all previously created deferred with the same lock-keys.
+     */
+    DeferredState.prototype.getPreviousPromises = function (lockKeys) {
+        var _a;
+        var promises = [];
+        for (var _i = 0, lockKeys_3 = lockKeys; _i < lockKeys_3.length; _i++) {
+            var lockKey = lockKeys_3[_i];
+            var listOfDeferred = (_a = this.deferredMap.get(lockKey)) !== null && _a !== void 0 ? _a : [];
+            for (var _b = 0, listOfDeferred_1 = listOfDeferred; _b < listOfDeferred_1.length; _b++) {
+                var deferred = listOfDeferred_1[_b];
+                promises.push(deferred.promise);
+            }
+        }
+        debug('Getting previous promises for lock-keys', { lockKeys: lockKeys, count: promises.length });
+        return promises;
+    };
+    return DeferredState;
+}());
+exports.DeferredState = DeferredState;
+//# sourceMappingURL=deferredState.js.map

package/dist/AMQP/EventSourcing/Locked/deferredState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferredState.js","sourceRoot":"","sources":["../../../../src/AMQP/EventSourcing/Locked/deferredState.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAsE;AACtE,gDAA0B;AAC1B,IAAM,KAAK,GAAG,IAAA,eAAK,EAAC,wDAAwD,CAAC,CAAC;AAE9E;;;GAGG;AACH;IAAA;QACS,gBAAW,GAAmC,IAAI,GAAG,EAA6B,CAAC;IAgD5F,CAAC;IA9CA;;OAEG;IACI,mCAAW,GAAlB,UAAmB,QAAkB;;QACpC,KAAK,CAAC,+BAA+B,EAAE,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC;QACrD,IAAM,eAAe,GAAG,IAAA,yBAAc,EAAO,IAAI,CAAC,CAAC;QACnD,KAAsB,UAAQ,EAAR,qBAAQ,EAAR,sBAAQ,EAAR,IAAQ,EAAE,CAAC;YAA5B,IAAM,OAAO,iBAAA;YACjB,IAAM,cAAc,GAAG,MAAA,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,mCAAI,EAAE,CAAC;YAC3D,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YAC9C,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,eAAe,CAAC;IACxB,CAAC;IAED;;;OAGG;IACI,sCAAc,GAArB,UAAsB,QAAkB,EAAE,QAAyB;;QAClE,KAAK,CAAC,iCAAiC,EAAE,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC;QACvD,KAAsB,UAAQ,EAAR,qBAAQ,EAAR,sBAAQ,EAAR,IAAQ,EAAE,CAAC;YAA5B,IAAM,OAAO,iBAAA;YACjB,IAAM,cAAc,GAAG,MAAA,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,mCAAI,EAAE,CAAC;YAC3D,IAAM,KAAK,GAAG,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAC/C,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBAClB,cAAc,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACjC,CAAC;YACD,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACjC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAClC,CAAC;QACF,CAAC;IACF,CAAC;IAED;;OAEG;IACI,2CAAmB,GAA1B,UAA2B,QAAkB;;QAC5C,IAAM,QAAQ,GAAoB,EAAE,CAAC;QACrC,KAAsB,UAAQ,EAAR,qBAAQ,EAAR,sBAAQ,EAAR,IAAQ,EAAE,CAAC;YAA5B,IAAM,OAAO,iBAAA;YACjB,IAAM,cAAc,GAAG,MAAA,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,mCAAI,EAAE,CAAC;YAC3D,KAAuB,UAAc,EAAd,iCAAc,EAAd,4BAAc,EAAd,IAAc,EAAE,CAAC;gBAAnC,IAAM,QAAQ,uBAAA;gBAClB,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YACjC,CAAC;QACF,CAAC;QACD,KAAK,CAAC,yCAAyC,EAAE,EAAE,QAAQ,UAAA,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QACvF,OAAO,QAAQ,CAAC;IACjB,CAAC;IACF,oBAAC;AAAD,CAAC,AAjDD,IAiDC;AAjDY,sCAAa"}

package/dist/AMQP/EventSourcing/Locked/lockedEventConsumer.d.ts

@@ -0,0 +1,63 @@
+import { IAMQPConnection } from '../../amqpConnectionFactory';
+import IEvent, { IEventPayload } from '../IEvent';
+export interface LockedBindOptions {
+    /**
+     * Number of events to prefetch from the main queue.
+     * This number has to greater than 0.
+     * Make sure that you have enough main prefetch count that can properly utilize the distributed prefetch count
+     * for all started consumers. The general rule is to have at least the same number of main prefetch count as the number of consumers times distributed prefetch count.
+     * In other words: `mainPrefetchCount >= numberOfConsumers * distributedPrefetchCount`
+     */
+    mainPrefetchCount?: number;
+    /**
+     * Number of events to prefetch from the distributed queue.
+     * This number can be 0, which means that the distributed consumption is disabled.
+     * In this case, the events are consumed directly from the main queue and the distributed queue is not used (neither created).
+     * If this number is greater than 0, the distributed consumption is enabled and the events are distributed from the main queue to the distributed queue.
+     * You can scale the number of consumers that multiply the total number of possibly concurrently processed events.
+     */
+    distributedPrefetchCount?: number;
+    /**
+     * Delay in milliseconds before redelivering the event in case of error.
+     * It's dead-lettered on the first error and redirected to the event_rejected queue for the specified delay.
+     */
+    redeliverDelayMs?: number;
+    /**
+     * If true, binding is done with notification option, so the exchange is prefixed with `events_notifications-` instead of standard `events-`.
+     * @deprecated This logic is about to be removed soon. Use it temporarily only for platform-consumer-redis until it's migrated to the new logic.
+     * 	The new logic is based on strong consistency awaiting.
+     */
+    legacyNotification?: boolean;
+}
+/**
+ * Event consumer that consumes events in a locked manner with timestamp-based ordering.
+ *
+ * It ensures that only one event with the same lockKey is processed at a time.
+ * Practically, it means that events with the same lockKey are processed sequentially.
+ * However, events with different lockKeys can be processed in parallel.
+ *
+ * The consumer includes a rejection mechanism that prevents processing events out of order
+ * when temporary failures occur (e.g., MongoDB transaction failures). Failed events are
+ * sent to rejected queues (dead-letter queues) and their timestamps are tracked to ensure
+ * later events with the same lockKeys wait until earlier failed events are resolved.
+ *
+ * Internal implementation uses 2 separate queues (if distributedPrefetchCount > 0):
+ * - Main queue for distributing events to distributed queue
+ * - Distributed queue for processing events
+ *
+ * The main queue is "Single Active Consumer" and is locking the event processing based on lockKeys field of the event.
+ * So the order of events is preserved based on the lockKeys.
+ * However, the distributed queue is not locking the event processing and is processing across multiple consumers at the same time.
+ * Messages in the distributed queue are transient. In case of failure, they are not lost because the main queue is persistent
+ * and is not acked until the distributed queue acks the message.
+ */
+export declare class LockedEventConsumer {
+    private amqpConnection;
+    private withLock;
+    constructor(amqpConnection: IAMQPConnection);
+    bind<TPayload extends IEventPayload>(eventTypes: string[], domainName: string, consumerType: string, onEvent: (event: IEvent<TPayload>) => Promise<void>, bindOptions?: LockedBindOptions): Promise<() => Promise<() => Promise<void>>>;
+    private createMainBindOptions;
+    private createConsumeEvent;
+    private createDistributedBindOptions;
+    private createDistributeEvent;
+}