@signageos/lib 23.8.1 → 23.8.2-master.4405

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

@@ -0,0 +1,261 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockedEventConsumer = void 0;
+var eventQueueDomain_1 = require("../eventQueueDomain");
+var debug_1 = __importDefault(require("debug"));
+var deferredState_1 = require("./deferredState");
+var withLock_1 = require("./withLock");
+var eventConsumerMetrics_1 = require("../../../Metrics/eventConsumerMetrics");
+var rejectedTimestamps_1 = require("./rejectedTimestamps");
+var debug = (0, debug_1.default)('@signageos/lib:AMQP:EventSourcing:Locked:LockedEventConsumer');
+/**
+ * The default values for the bind options doesn't allow concurrent processing of events.
+ */
+var DEFAULT_BIND_OPTIONS = {
+    mainPrefetchCount: 1,
+    distributedPrefetchCount: 0,
+    redeliverDelayMs: 30e3,
+    legacyNotification: false,
+};
+var mainEventQueueBindOptions = {
+    queueType: 'quorum',
+    singleActiveConsumer: true,
+    deadLetterIfErred: true,
+};
+var distributedEventQueueBindOptions = {
+    queueType: 'classic',
+    singleActiveConsumer: false,
+    durable: false,
+};
+var DEFAULT_LOCK_KEY = '$default';
+/**
+ * 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.
+ */
+var LockedEventConsumer = /** @class */ (function () {
+    function LockedEventConsumer(amqpConnection) {
+        this.amqpConnection = amqpConnection;
+        this.withLock = (0, withLock_1.createWithLock)({ deferredState: new deferredState_1.DeferredState(), rejectedTimestamps: new rejectedTimestamps_1.RejectedTimestamps() });
+    }
+    LockedEventConsumer.prototype.bind = function (eventTypes_1, domainName_1, consumerType_1, onEvent_1) {
+        return __awaiter(this, arguments, void 0, function (eventTypes, domainName, consumerType, onEvent, bindOptions) {
+            var mainBindOptions, distributedBindOptions, consumeEvent, cancelConsumptions, cancelMain, distributeEvent, cancelDistributed, cancelMain;
+            var _this = this;
+            var _a;
+            if (bindOptions === void 0) { bindOptions = DEFAULT_BIND_OPTIONS; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        bindOptions = __assign(__assign({}, DEFAULT_BIND_OPTIONS), bindOptions);
+                        return [4 /*yield*/, (0, eventQueueDomain_1.prepareRejectedDomain)(this.amqpConnection, domainName, consumerType, {
+                                redeliverDelayMs: (_a = bindOptions.redeliverDelayMs) !== null && _a !== void 0 ? _a : DEFAULT_BIND_OPTIONS.redeliverDelayMs,
+                            })];
+                    case 1:
+                        _b.sent();
+                        mainBindOptions = this.createMainBindOptions(bindOptions);
+                        distributedBindOptions = this.createDistributedBindOptions(bindOptions);
+                        consumeEvent = this.createConsumeEvent(domainName, consumerType, mainBindOptions, onEvent);
+                        cancelConsumptions = [];
+                        if (!(bindOptions.distributedPrefetchCount === 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, (0, eventQueueDomain_1.bindDomain)(this.amqpConnection, eventTypes, domainName, consumerType, consumeEvent, mainBindOptions)];
+                    case 2:
+                        cancelMain = _b.sent();
+                        cancelConsumptions.push(cancelMain);
+                        return [3 /*break*/, 6];
+                    case 3:
+                        distributeEvent = this.createDistributeEvent(domainName, consumerType, distributedBindOptions);
+                        return [4 /*yield*/, (0, eventQueueDomain_1.bindRPCDomain)(this.amqpConnection, domainName, consumerType, consumeEvent, distributedBindOptions)];
+                    case 4:
+                        cancelDistributed = _b.sent();
+                        return [4 /*yield*/, (0, eventQueueDomain_1.bindDomain)(this.amqpConnection, eventTypes, domainName, consumerType, distributeEvent, mainBindOptions)];
+                    case 5:
+                        cancelMain = _b.sent();
+                        cancelConsumptions.push(cancelDistributed);
+                        cancelConsumptions.push(cancelMain);
+                        _b.label = 6;
+                    case 6: return [2 /*return*/, function () { return __awaiter(_this, void 0, void 0, function () {
+                            var closeChannels;
+                            var _this = this;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, Promise.all(cancelConsumptions.map(function (cancel) { return cancel(); }))];
+                                    case 1:
+                                        closeChannels = _a.sent();
+                                        return [2 /*return*/, function () { return __awaiter(_this, void 0, void 0, function () {
+                                                return __generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0: return [4 /*yield*/, Promise.all(closeChannels.map(function (close) { return close(); }))];
+                                                        case 1:
+                                                            _a.sent();
+                                                            return [2 /*return*/];
+                                                    }
+                                                });
+                                            }); }];
+                                }
+                            });
+                        }); }];
+                }
+            });
+        });
+    };
+    LockedEventConsumer.prototype.createMainBindOptions = function (bindOptions) {
+        var _a;
+        return __assign(__assign({}, mainEventQueueBindOptions), { prefetchCount: bindOptions.mainPrefetchCount, notification: (_a = bindOptions.legacyNotification) !== null && _a !== void 0 ? _a : false });
+    };
+    LockedEventConsumer.prototype.createConsumeEvent = function (domainName, consumerType, bindOptions, onEvent) {
+        var _this = this;
+        return function (event) { return __awaiter(_this, void 0, void 0, function () {
+            var start, commandStart, logMetadata, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.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());
+                        commandStart = event.receivedAt.getTime() - event.dispatchedAt.getTime();
+                        if (commandStart !== 0) {
+                            eventConsumerMetrics_1.metrics.emit('event_duration_seconds_total', { eventType: event.type, phase: 'commandStart' }, event.receivedAt.getTime() - event.dispatchedAt.getTime());
+                        }
+                        logMetadata = {
+                            domainName: domainName,
+                            consumerType: consumerType,
+                            bindOptions: bindOptions,
+                            event: event,
+                        };
+                        debug("Consuming event ".concat(event.type, " from ").concat(domainName, ".").concat(consumerType), logMetadata);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, onEvent(event)];
+                    case 2:
+                        _a.sent();
+                        eventConsumerMetrics_1.metrics.emit('event_success_total', { eventType: event.type });
+                        return [3 /*break*/, 5];
+                    case 3:
+                        e_1 = _a.sent();
+                        eventConsumerMetrics_1.metrics.emit('event_error_total', { eventType: event.type });
+                        debug("Error consuming event ".concat(event.type, " from ").concat(domainName, ".").concat(consumerType), logMetadata);
+                        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: return [2 /*return*/];
+                }
+            });
+        }); };
+    };
+    LockedEventConsumer.prototype.createDistributedBindOptions = function (bindOptions) {
+        return __assign(__assign({}, distributedEventQueueBindOptions), { prefetchCount: bindOptions.distributedPrefetchCount });
+    };
+    LockedEventConsumer.prototype.createDistributeEvent = function (domainName, consumerType, bindOptions) {
+        var _this = this;
+        return function (event) { return __awaiter(_this, void 0, void 0, function () {
+            var logMetadata, lockKeys;
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        logMetadata = {
+                            domainName: domainName,
+                            consumerType: consumerType,
+                            bindOptions: bindOptions,
+                            event: event,
+                        };
+                        debug("Received event ".concat(event.type, " to ").concat(domainName, ".").concat(consumerType), logMetadata);
+                        lockKeys = (_a = event.lockKeys) !== null && _a !== void 0 ? _a : [DEFAULT_LOCK_KEY];
+                        return [4 /*yield*/, this.withLock(lockKeys, event, function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            debug("Distributing event ".concat(event.type, " to ").concat(domainName, ".").concat(consumerType), logMetadata);
+                                            // TODO Add timeout for processing event, because it can be stucked until the instance is restarted
+                                            return [4 /*yield*/, (0, eventQueueDomain_1.processRPCDomain)(this.amqpConnection, domainName, consumerType, event, { persistent: false })];
+                                        case 1:
+                                            // TODO Add timeout for processing event, because it can be stucked until the instance is restarted
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _b.sent();
+                        debug("Distributed event consumed ".concat(event.type, " to ").concat(domainName, ".").concat(consumerType), logMetadata);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+    };
+    return LockedEventConsumer;
+}());
+exports.LockedEventConsumer = LockedEventConsumer;
+//# sourceMappingURL=lockedEventConsumer.js.map

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

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

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

@@ -0,0 +1,24 @@
+import { ITimestamp } from '../synchronization';
+/**
+ * A stateful class used for temporary storing of rejected consumptions of lockedEventConsumer
+ * to prevent processing/consuming events in incorrect order based on random (temporary) failing events.
+ *
+ * This class helps maintain event ordering by keeping track of rejected events' timestamps,
+ * ensuring that later events cannot be processed until earlier failed events are resolved.
+ * It has to be sideloaded to __rejected queues (dead-letter queues) so it doesn't affect
+ * processing of other events with different lockKeys.
+ *
+ * The main goal is to react as soon as possible and skip failing events, but continue
+ * processing others to prevent downtimes or outages. This implementation should only slow down
+ * or block a single lockDomain without significantly affecting others.
+ *
+ * Usually, the errors are temporary (for example MongoDB transactions), so this keeps in memory
+ * the last rejected events' timestamps to know that later events cannot be processed yet (by lockKeys).
+ */
+export declare class RejectedTimestamps {
+    private rejectedTimestamps;
+    addRejection(lockKeys: string[], timestamp: ITimestamp): void;
+    removeRejection(lockKeys: string[], timestamp: ITimestamp): void;
+    previousWasRejected(lockKeys: string[], timestamp: ITimestamp): boolean;
+    private compareTimestamps;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RejectedTimestamps = void 0;
+/**
+ * A stateful class used for temporary storing of rejected consumptions of lockedEventConsumer
+ * to prevent processing/consuming events in incorrect order based on random (temporary) failing events.
+ *
+ * This class helps maintain event ordering by keeping track of rejected events' timestamps,
+ * ensuring that later events cannot be processed until earlier failed events are resolved.
+ * It has to be sideloaded to __rejected queues (dead-letter queues) so it doesn't affect
+ * processing of other events with different lockKeys.
+ *
+ * The main goal is to react as soon as possible and skip failing events, but continue
+ * processing others to prevent downtimes or outages. This implementation should only slow down
+ * or block a single lockDomain without significantly affecting others.
+ *
+ * Usually, the errors are temporary (for example MongoDB transactions), so this keeps in memory
+ * the last rejected events' timestamps to know that later events cannot be processed yet (by lockKeys).
+ */
+var RejectedTimestamps = /** @class */ (function () {
+    function RejectedTimestamps() {
+        this.rejectedTimestamps = new Map();
+    }
+    RejectedTimestamps.prototype.addRejection = function (lockKeys, timestamp) {
+        for (var _i = 0, lockKeys_1 = lockKeys; _i < lockKeys_1.length; _i++) {
+            var key = lockKeys_1[_i];
+            this.rejectedTimestamps.set(key, timestamp);
+        }
+    };
+    RejectedTimestamps.prototype.removeRejection = function (lockKeys, timestamp) {
+        for (var _i = 0, lockKeys_2 = lockKeys; _i < lockKeys_2.length; _i++) {
+            var key = lockKeys_2[_i];
+            var rejectedTimestamp = this.rejectedTimestamps.get(key);
+            if (rejectedTimestamp && this.compareTimestamps(rejectedTimestamp, timestamp) === 0) {
+                this.rejectedTimestamps.delete(key);
+            }
+        }
+    };
+    RejectedTimestamps.prototype.previousWasRejected = function (lockKeys, timestamp) {
+        for (var _i = 0, lockKeys_3 = lockKeys; _i < lockKeys_3.length; _i++) {
+            var key = lockKeys_3[_i];
+            var rejectedTimestamp = this.rejectedTimestamps.get(key);
+            if (rejectedTimestamp && this.compareTimestamps(rejectedTimestamp, timestamp) < 0) {
+                return true;
+            }
+        }
+        return false;
+    };
+    RejectedTimestamps.prototype.compareTimestamps = function (ts1, ts2) {
+        if (ts1.receivedAt.valueOf() === ts2.receivedAt.valueOf() && ts1.secondaryIndex === ts2.secondaryIndex) {
+            return 0;
+        }
+        else if (ts1.receivedAt.valueOf() < ts2.receivedAt.valueOf() ||
+            (ts1.receivedAt.valueOf() === ts2.receivedAt.valueOf() && ts1.secondaryIndex < ts2.secondaryIndex)) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    };
+    return RejectedTimestamps;
+}());
+exports.RejectedTimestamps = RejectedTimestamps;
+//# sourceMappingURL=rejectedTimestamps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rejectedTimestamps.js","sourceRoot":"","sources":["../../../../src/AMQP/EventSourcing/Locked/rejectedTimestamps.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;GAeG;AACH;IAAA;QACS,uBAAkB,GAA4B,IAAI,GAAG,EAAE,CAAC;IAuCjE,CAAC;IArCO,yCAAY,GAAnB,UAAoB,QAAkB,EAAE,SAAqB;QAC5D,KAAkB,UAAQ,EAAR,qBAAQ,EAAR,sBAAQ,EAAR,IAAQ,EAAE,CAAC;YAAxB,IAAM,GAAG,iBAAA;YACb,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;QAC7C,CAAC;IACF,CAAC;IAEM,4CAAe,GAAtB,UAAuB,QAAkB,EAAE,SAAqB;QAC/D,KAAkB,UAAQ,EAAR,qBAAQ,EAAR,sBAAQ,EAAR,IAAQ,EAAE,CAAC;YAAxB,IAAM,GAAG,iBAAA;YACb,IAAM,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC3D,IAAI,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrF,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACrC,CAAC;QACF,CAAC;IACF,CAAC;IAEM,gDAAmB,GAA1B,UAA2B,QAAkB,EAAE,SAAqB;QACnE,KAAkB,UAAQ,EAAR,qBAAQ,EAAR,sBAAQ,EAAR,IAAQ,EAAE,CAAC;YAAxB,IAAM,GAAG,iBAAA;YACb,IAAM,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC3D,IAAI,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC;gBACnF,OAAO,IAAI,CAAC;YACb,CAAC;QACF,CAAC;QACD,OAAO,KAAK,CAAC;IACd,CAAC;IAEO,8CAAiB,GAAzB,UAA0B,GAAe,EAAE,GAAe;QACzD,IAAI,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,CAAC,cAAc,KAAK,GAAG,CAAC,cAAc,EAAE,CAAC;YACxG,OAAO,CAAC,CAAC;QACV,CAAC;aAAM,IACN,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE;YACnD,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,CAAC,cAAc,GAAG,GAAG,CAAC,cAAc,CAAC,EACjG,CAAC;YACF,OAAO,CAAC,CAAC,CAAC;QACX,CAAC;aAAM,CAAC;YACP,OAAO,CAAC,CAAC;QACV,CAAC;IACF,CAAC;IACF,yBAAC;AAAD,CAAC,AAxCD,IAwCC;AAxCY,gDAAkB"}

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

@@ -0,0 +1,42 @@
+import { DeferredState } from './deferredState';
+import { RejectedTimestamps } from './rejectedTimestamps';
+import { ITimestamp } from '../synchronization';
+/**
+ * Function type that executes a callback with locking and timestamp-based ordering.
+ *
+ * @param lockKeys - Array of lock keys that determine which events should be processed sequentially
+ * @param timestamp - Event timestamp used for ordering and rejection tracking
+ * @param callback - The async function to execute within the lock
+ */
+export type WithLock = (lockKeys: string[], timestamp: ITimestamp, callback: () => Promise<void>) => Promise<void>;
+/**
+ * Configuration object for creating a withLock function.
+ */
+type WithLockArgs = {
+    /** State manager for deferred promises */
+    deferredState: DeferredState;
+    /** Timestamp tracker for rejected events */
+    rejectedTimestamps: RejectedTimestamps;
+};
+/**
+ * Creates a locking function that uses deferredState for managing deferred promises and
+ * rejectedTimestamps for handling timestamp-based event ordering.
+ *
+ * The returned function will:
+ * 1. Wait for all previous promises with the same lock-keys to finish before executing the callback
+ * 2. Check if previous events with the same lock-keys were rejected based on timestamps
+ * 3. If the callback throws an error, all subsequent waiting promises with the same lock-keys will be rejected
+ * 4. Store rejection timestamps to prevent processing later events until earlier ones are resolved
+ *
+ * This ensures proper event ordering and prevents processing events out of sequence when temporary
+ * failures occur (e.g., MongoDB transaction failures).
+ */
+export declare const createWithLock: ({ deferredState, rejectedTimestamps }: WithLockArgs) => (lockKeys: string[], timestamp: ITimestamp, callback: () => Promise<void>) => Promise<void>;
+/**
+ * Error thrown when a previous promise with the same lock keys failed,
+ * causing subsequent promises to be rejected to maintain event ordering.
+ */
+export declare class WithLockPreviousError extends Error {
+    constructor(lockKeys: string[]);
+}
+export {};

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

@@ -0,0 +1,141 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithLockPreviousError = exports.createWithLock = void 0;
+var debug_1 = __importDefault(require("debug"));
+var debug = (0, debug_1.default)('@signageos/lib:AMQP:EventSourcing:Locked:withLock');
+/**
+ * Creates a locking function that uses deferredState for managing deferred promises and
+ * rejectedTimestamps for handling timestamp-based event ordering.
+ *
+ * The returned function will:
+ * 1. Wait for all previous promises with the same lock-keys to finish before executing the callback
+ * 2. Check if previous events with the same lock-keys were rejected based on timestamps
+ * 3. If the callback throws an error, all subsequent waiting promises with the same lock-keys will be rejected
+ * 4. Store rejection timestamps to prevent processing later events until earlier ones are resolved
+ *
+ * This ensures proper event ordering and prevents processing events out of sequence when temporary
+ * failures occur (e.g., MongoDB transaction failures).
+ */
+var createWithLock = function (_a) {
+    var deferredState = _a.deferredState, rejectedTimestamps = _a.rejectedTimestamps;
+    return function (lockKeys, timestamp, callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var previousPromises, currentDeferred, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    previousPromises = deferredState.getPreviousPromises(lockKeys);
+                    currentDeferred = deferredState.addDeferred(lockKeys);
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, , 7, 8]);
+                    // Wait for all previous promises with the same lock-keys to finish
+                    return [4 /*yield*/, Promise.all(previousPromises)];
+                case 2:
+                    // Wait for all previous promises with the same lock-keys to finish
+                    _a.sent();
+                    if (rejectedTimestamps.previousWasRejected(lockKeys, timestamp)) {
+                        debug('Error in previous locked callback', { lockKeys: lockKeys, timestamp: timestamp });
+                        currentDeferred.reject(new WithLockPreviousError(lockKeys));
+                        throw new Error("Previous callback with same lock-key ".concat(lockKeys.join(','), " failed."));
+                    }
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 5, , 6]);
+                    debug('Starting locked callback', { lockKeys: lockKeys });
+                    return [4 /*yield*/, callback()];
+                case 4:
+                    _a.sent();
+                    debug('Finished locked callback', { lockKeys: lockKeys });
+                    // Resolve the current deferred to allow the next promise to proceed
+                    currentDeferred.resolve();
+                    return [3 /*break*/, 6];
+                case 5:
+                    error_1 = _a.sent();
+                    debug('Error in locked callback', { lockKeys: lockKeys, error: error_1 });
+                    // Reject all subsequent waiting promises with the same lock-keys in the same order
+                    currentDeferred.reject(new WithLockPreviousError(lockKeys));
+                    // Store current event timestamp (receivedAt + secondaryIndex) in memory and reject all events with the higher timestamp
+                    rejectedTimestamps.addRejection(lockKeys, timestamp);
+                    // Because of call stack of JS, following error will be thrown and promise rejected first, before the above rejected promise
+                    throw error_1;
+                case 6:
+                    rejectedTimestamps.removeRejection(lockKeys, timestamp);
+                    return [3 /*break*/, 8];
+                case 7:
+                    deferredState.removeDeferred(lockKeys, currentDeferred);
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/];
+            }
+        });
+    }); };
+};
+exports.createWithLock = createWithLock;
+/**
+ * Error thrown when a previous promise with the same lock keys failed,
+ * causing subsequent promises to be rejected to maintain event ordering.
+ */
+var WithLockPreviousError = /** @class */ (function (_super) {
+    __extends(WithLockPreviousError, _super);
+    function WithLockPreviousError(lockKeys) {
+        var _this = _super.call(this, "Previous promise with same lock-key ".concat(lockKeys.join(','), " failed, rejecting all subsequent waiting promises.")) || this;
+        Object.setPrototypeOf(_this, WithLockPreviousError.prototype);
+        return _this;
+    }
+    return WithLockPreviousError;
+}(Error));
+exports.WithLockPreviousError = WithLockPreviousError;
+//# sourceMappingURL=withLock.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withLock.js","sourceRoot":"","sources":["../../../../src/AMQP/EventSourcing/Locked/withLock.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,gDAA0B;AAG1B,IAAM,KAAK,GAAG,IAAA,eAAK,EAAC,mDAAmD,CAAC,CAAC;AAqBzE;;;;;;;;;;;;GAYG;AACI,IAAM,cAAc,GAC1B,UAAC,EAAmD;QAAjD,aAAa,mBAAA,EAAE,kBAAkB,wBAAA;IACpC,OAAA,UAAO,QAAkB,EAAE,SAAqB,EAAE,QAA6B;;;;;oBACxE,gBAAgB,GAAG,aAAa,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;oBAC/D,eAAe,GAAG,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;;;;oBAG3D,mEAAmE;oBACnE,qBAAM,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,EAAA;;oBADnC,mEAAmE;oBACnE,SAAmC,CAAC;oBAEpC,IAAI,kBAAkB,CAAC,mBAAmB,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,CAAC;wBACjE,KAAK,CAAC,mCAAmC,EAAE,EAAE,QAAQ,UAAA,EAAE,SAAS,WAAA,EAAE,CAAC,CAAC;wBACpE,eAAe,CAAC,MAAM,CAAC,IAAI,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CAAC;wBAC5D,MAAM,IAAI,KAAK,CAAC,+CAAwC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,aAAU,CAAC,CAAC;oBACvF,CAAC;;;;oBAGA,KAAK,CAAC,0BAA0B,EAAE,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC;oBAChD,qBAAM,QAAQ,EAAE,EAAA;;oBAAhB,SAAgB,CAAC;oBACjB,KAAK,CAAC,0BAA0B,EAAE,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC;oBAChD,oEAAoE;oBACpE,eAAe,CAAC,OAAO,EAAE,CAAC;;;;oBAE1B,KAAK,CAAC,0BAA0B,EAAE,EAAE,QAAQ,UAAA,EAAE,KAAK,SAAA,EAAE,CAAC,CAAC;oBACvD,mFAAmF;oBACnF,eAAe,CAAC,MAAM,CAAC,IAAI,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CAAC;oBAC5D,wHAAwH;oBACxH,kBAAkB,CAAC,YAAY,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;oBACrD,4HAA4H;oBAC5H,MAAM,OAAK,CAAC;;oBAEb,kBAAkB,CAAC,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;;;oBAExD,aAAa,CAAC,cAAc,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;;;;;SAEzD;AAjCD,CAiCC,CAAC;AAnCU,QAAA,cAAc,kBAmCxB;AAEH;;;GAGG;AACH;IAA2C,yCAAK;IAC/C,+BAAY,QAAkB;QAC7B,YAAA,MAAK,YAAC,8CAAuC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,wDAAqD,CAAC,SAAC;QACtH,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,qBAAqB,CAAC,SAAS,CAAC,CAAC;;IAC9D,CAAC;IACF,4BAAC;AAAD,CAAC,AALD,CAA2C,KAAK,GAK/C;AALY,sDAAqB"}

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

@@ -0,0 +1,87 @@
+import IEvent, { IEventPayload } from './IEvent';
+import { IAMQPConnection } from '../amqpConnectionFactory';
+import IQueueOptions from '../IQueueOptions';
+import { deleteQueues, IBindOptions, IRejectedRedeliverOptions, purgeQueue } from './eventQueue.utils';
+import { bindDetached, bindDetachedExpectingConfirmation, fetchRejectedDetached, prepareDetached, prepareRejectedDetached, IEventDetachedMessage, bindRejectedDetached } from './eventQueueDetached';
+import { bindDomain, bindRejectedDomain, bindRPCDomain, fetchRejectedDomain, prepareDomain, prepareRejectedDomain as prepareRejected, processRPCDomain, IEventDomainMessage as IEventMessage } from './eventQueueDomain';
+import { enqueue, enqueueBatch, enqueueNotification, enqueueToConsumer } from './eventQueuePublish';
+/**
+ * Fetch one event from the queue, either it's domain type or detached type.
+ * It automatically asserts exchanges and queues that is non-standard.
+ * The fetched message is automatically acked.
+ * This function is meant mostly for testing purposes.
+ * @deprecated TODO Use fetchDomain or fetchDetached instead
+ */
+export declare function fetchNext<TPayload extends IEventPayload>(amqpConnection: IAMQPConnection, eventType: string, consumerType: string, bindOptions?: IBindOptions, queueOptions?: IQueueOptions, domainName?: string): Promise<IEvent<TPayload> | null>;
+export { 
+/** @deprecated Use IBindOptions from './eventQueue.utils' instead. */
+IBindOptions, 
+/** @deprecated Use IRejectedRedeliverOptions from './eventQueue.utils' instead. */
+IRejectedRedeliverOptions, 
+/** @deprecated Use IEventDomainMessage from './eventQueueDomain' instead. */
+IEventMessage, 
+/** @deprecated Use IEventDetachedMessage from './eventQueueDetached' instead. */
+IEventDetachedMessage, };
+export { 
+/** @deprecated Use enqueue from './eventQueuePublish' instead. */
+enqueue, 
+/** @deprecated Use enqueueBatch from './eventQueuePublish' instead. */
+enqueueBatch, 
+/** @deprecated Use enqueueNotification from './eventQueuePublish' instead. */
+enqueueNotification, 
+/** @deprecated Use enqueueToConsumer from './eventQueuePublish' instead. */
+enqueueToConsumer, 
+/** @deprecated Use bindRejectedDetached from './eventQueueDetached' instead. */
+bindRejectedDetached, 
+/** @deprecated Use prepareRejectedDomain from './eventQueueDomain' instead. */
+prepareRejected, 
+/** @deprecated Use prepareRejectedDetached from './eventQueueDetached' instead. */
+prepareRejectedDetached, };
+/**
+ * @deprecated Use bindDetached from './eventQueueDetached' instead. This alias will be removed in the next major version.
+ */
+export declare const bindOne: typeof bindDetached;
+/**
+ * @deprecated Use bindDetachedExpectingConfirmation from './eventQueueDetached' instead. This alias will be removed in the next major version.
+ */
+export declare const bindOneExpectingConfirmation: typeof bindDetachedExpectingConfirmation;
+/**
+ * @deprecated Use purgeQueue from './eventQueueDetached' instead. This alias will be removed in the next major version.
+ */
+export declare const purgeOne: typeof purgeQueue;
+/**
+ * @deprecated Use deleteQueues from './eventQueueDetached' instead. This alias will be removed in the next major version.
+ */
+export declare const deleteMore: typeof deleteQueues;
+/**
+ * @deprecated Use bindDomain from './eventQueueDomain' instead. This alias will be removed in the next major version.
+ */
+export declare const bindMany: typeof bindDomain;
+/**
+ * @deprecated Use bindRejectedDomain from './eventQueueDomain' instead. This alias will be removed in the next major version.
+ */
+export declare const bindRejectedMany: typeof bindRejectedDomain;
+/**
+ * @deprecated Use prepareDomain from './eventQueueDomain' instead. This alias will be removed in the next major version.
+ */
+export declare const prepareMany: typeof prepareDomain;
+/**
+ * @deprecated Use fetchRejectedDomain from './eventQueueDomain' instead. This alias will be removed in the next major version.
+ */
+export declare const fetchOneRejected: typeof fetchRejectedDomain;
+/**
+ * @deprecated Use fetchRejectedDetached from './eventQueueDetached' instead. This alias will be removed in the next major version.
+ */
+export declare const fetchOneRejectedDetached: typeof fetchRejectedDetached;
+/**
+ * @deprecated Use prepareDetached from './eventQueueDetached' instead. This alias will be removed in the next major version.
+ */
+export declare const prepareMore: typeof prepareDetached;
+/**
+ * @deprecated Use bindRPCDomain from './eventQueueDomain' instead. This alias will be removed in the next major version.
+ */
+export declare const bindRPC: typeof bindRPCDomain;
+/**
+ * @deprecated Use processRPCDomain from './eventQueueDomain' instead. This alias will be removed in the next major version.
+ */
+export declare const processRPC: typeof processRPCDomain;