@signageos/lib 23.8.1 → 23.8.2-master.4405

package/dist/InfluxDB/influxDBConnectionFactory.d.ts

@@ -0,0 +1,9 @@
+import { IInfluxDB } from './IInfluxDB';
+export interface IInfluxdbConnection {
+    connect: (timeout?: number) => Promise<void>;
+    getClient: () => IInfluxDB;
+    getOrganization: () => string;
+    getBucket: () => string;
+    close: () => Promise<void>;
+}
+export declare function createInfluxdbConnection(baseUrl: string, token: string, organization: string, bucket: string): IInfluxdbConnection;

package/dist/InfluxDB/influxDBConnectionFactory.js

@@ -0,0 +1,83 @@
+"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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInfluxdbConnection = createInfluxdbConnection;
+var influxdb_client_1 = require("@influxdata/influxdb-client");
+function createInfluxdbConnection(baseUrl, token, organization, bucket) {
+    var _this = this;
+    var influxDBClient = null;
+    return {
+        connect: function () {
+            var args_1 = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args_1[_i] = arguments[_i];
+            }
+            return __awaiter(_this, __spreadArray([], args_1, true), void 0, function (timeout) {
+                if (timeout === void 0) { timeout = 30e3; }
+                return __generator(this, function (_a) {
+                    influxDBClient = new influxdb_client_1.InfluxDB({ url: baseUrl, token: token, timeout: timeout });
+                    return [2 /*return*/];
+                });
+            });
+        },
+        getClient: function () {
+            if (influxDBClient) {
+                return influxDBClient;
+            }
+            throw new Error('Client was closed.');
+        },
+        close: function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                influxDBClient = null;
+                return [2 /*return*/];
+            });
+        }); },
+        getOrganization: function () { return organization; },
+        getBucket: function () { return bucket; },
+    };
+}
+//# sourceMappingURL=influxDBConnectionFactory.js.map

package/dist/InfluxDB/influxDBConnectionFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"influxDBConnectionFactory.js","sourceRoot":"","sources":["../../src/InfluxDB/influxDBConnectionFactory.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,4DAmBC;AA9BD,+DAAuD;AAWvD,SAAgB,wBAAwB,CAAC,OAAe,EAAE,KAAa,EAAE,YAAoB,EAAE,MAAc;IAA7G,iBAmBC;IAlBA,IAAI,cAAc,GAAqB,IAAI,CAAC;IAE5C,OAAO;QACN,OAAO,EAAE;;;;;uFAAO,OAAsB;gBAAtB,wBAAA,EAAA,cAAsB;;oBACrC,cAAc,GAAG,IAAI,0BAAQ,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,SAAA,EAAE,CAAC,CAAC;;;;SACvE;QACD,SAAS,EAAE;YACV,IAAI,cAAc,EAAE,CAAC;gBACpB,OAAO,cAAc,CAAC;YACvB,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACvC,CAAC;QACD,KAAK,EAAE;;gBACN,cAAc,GAAG,IAAI,CAAC;;;aACtB;QACD,eAAe,EAAE,cAAM,OAAA,YAAY,EAAZ,CAAY;QACnC,SAAS,EAAE,cAAM,OAAA,MAAM,EAAN,CAAM;KACvB,CAAC;AACH,CAAC"}

package/dist/JSON/jsonHelper.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated Use `@signageos/core/dist/JSON/jsonHelper` instead.
+ */
+export * from '@signageos/core/dist/JSON/jsonHelper';

package/dist/JSON/jsonHelper.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @deprecated Use `@signageos/core/dist/JSON/jsonHelper` instead.
+ */
+__exportStar(require("@signageos/core/dist/JSON/jsonHelper"), exports);
+//# sourceMappingURL=jsonHelper.js.map

package/dist/JSON/jsonHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonHelper.js","sourceRoot":"","sources":["../../src/JSON/jsonHelper.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,uEAAqD"}

package/dist/Lib/Redis/connection.utils.d.ts

@@ -0,0 +1,22 @@
+import { RedisClient } from 'redis';
+import { Options } from '../../Redis/redisConnectionFactory';
+interface DangerousRedisOperationReasoning {
+    reason: string;
+    documentationLink: string;
+    alternativeOperation?: keyof RedisClient;
+}
+/**
+ * Wraps the dangerous function with either an error or a warning. Almost always it should throw an error, indicating that
+ * developer is playing with fire. Logs warnings by default.
+ *
+ * Testing enviroments are exception and do not log warnings unless explicitly enabled by options.
+ *
+ * For more explanation @see wrapRedisConnection
+ */
+export declare function wrapDangerousRedisFunction<T extends Function>(fn: T, reasoning: DangerousRedisOperationReasoning, { disableExpensiveOperations, enableExpensiveOperationsWarning }: Options): T;
+/**
+ * Created to ban all dangerous Redis operations that could take down production. While they are possible to enable,
+ * only acceptable use case should be testing. Outside of that, do not disable this without a very good reason.
+ */
+export declare function wrapRedisConnection(redisConnection: RedisClient, options: Options): RedisClient;
+export {};

package/dist/Lib/Redis/connection.utils.js

@@ -0,0 +1,95 @@
+"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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapDangerousRedisFunction = wrapDangerousRedisFunction;
+exports.wrapRedisConnection = wrapRedisConnection;
+var DangerousRedisOperationError = /** @class */ (function (_super) {
+    __extends(DangerousRedisOperationError, _super);
+    function DangerousRedisOperationError(_a) {
+        var disabledOperation = _a.disabledOperation, reason = _a.reason, documentationLink = _a.documentationLink, alternativeOperation = _a.alternativeOperation;
+        var _this = _super.call(this, "\n\t\t\tRedis operation - ".concat(disabledOperation, " is banned!\n\n\t\t\t\tYou should not use this function in production. It may not be a good idea in development either.\n\n\n\t\t\tDetail: ").concat(reason, "\n\n\t\t\tDocumentation: ").concat(documentationLink, "\n\t\t\t").concat(alternativeOperation ? '\n\nAlternatively you can use safer operation - ' + alternativeOperation.toString() : '', "\n\t\t")) || this;
+        _this.disabledOperation = disabledOperation;
+        return _this;
+    }
+    return DangerousRedisOperationError;
+}(Error));
+/**
+ * Wraps the dangerous function with either an error or a warning. Almost always it should throw an error, indicating that
+ * developer is playing with fire. Logs warnings by default.
+ *
+ * Testing enviroments are exception and do not log warnings unless explicitly enabled by options.
+ *
+ * For more explanation @see wrapRedisConnection
+ */
+function wrapDangerousRedisFunction(fn, reasoning, _a) {
+    var disableExpensiveOperations = _a.disableExpensiveOperations, enableExpensiveOperationsWarning = _a.enableExpensiveOperationsWarning;
+    var error = new DangerousRedisOperationError(__assign({ disabledOperation: fn.name }, reasoning));
+    if (disableExpensiveOperations === true) {
+        return (function () {
+            throw error;
+        });
+    }
+    if (process.env.NODE_ENV !== 'test' || enableExpensiveOperationsWarning === true) {
+        console.warn(error);
+    }
+    return fn;
+}
+/**
+ * Created to ban all dangerous Redis operations that could take down production. While they are possible to enable,
+ * only acceptable use case should be testing. Outside of that, do not disable this without a very good reason.
+ */
+function wrapRedisConnection(redisConnection, options) {
+    redisConnection.keys = wrapDangerousRedisFunction(redisConnection.keys, {
+        reason: 'Iterates over every single key in DB and locks the thread while doing so.',
+        documentationLink: 'https://redis.io/docs/latest/commands/keys/',
+    }, options);
+    redisConnection.KEYS = wrapDangerousRedisFunction(redisConnection.KEYS, {
+        reason: 'Iterates over every single key in DB and locks the thread while doing so.',
+        documentationLink: 'https://redis.io/docs/latest/commands/keys/',
+    }, options);
+    redisConnection.scan = wrapDangerousRedisFunction(redisConnection.scan, {
+        reason: 'Iterates over every single key in DB, it may not lock but the performance cost is major.',
+        documentationLink: 'https://redis.io/docs/latest/commands/scan/',
+    }, options);
+    redisConnection.SCAN = wrapDangerousRedisFunction(redisConnection.SCAN, {
+        reason: 'Iterates over every single key in DB, it may not lock but the performance cost is major.',
+        documentationLink: 'https://redis.io/docs/latest/commands/scan/',
+    }, options);
+    redisConnection.del = wrapDangerousRedisFunction(redisConnection.del, {
+        reason: 'Locks the thread while it reclaims memory. Especially dangerous when deleting many keys.',
+        documentationLink: 'https://redis.io/docs/latest/commands/del/',
+        alternativeOperation: 'UNLINK',
+    }, options);
+    redisConnection.DEL = wrapDangerousRedisFunction(redisConnection.DEL, {
+        reason: 'Locks the thread while it reclaims memory. Especially dangerous when deleting many keys.',
+        documentationLink: 'https://redis.io/docs/latest/commands/del/',
+        alternativeOperation: 'UNLINK',
+    }, options);
+    return redisConnection;
+}
+//# sourceMappingURL=connection.utils.js.map

package/dist/Lib/Redis/connection.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.utils.js","sourceRoot":"","sources":["../../../src/Lib/Redis/connection.utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,gEAgBC;AAMD,kDA0DC;AAnHD;IAA2C,gDAAK;IAG/C,sCAAY,EAOX;YANA,iBAAiB,uBAAA,EACjB,MAAM,YAAA,EACN,iBAAiB,uBAAA,EACjB,oBAAoB,0BAAA;QAIpB,YAAA,MAAK,YAAC,oCACe,iBAAiB,wJAE3B,MAAM,sCACC,iBAAiB,qBAChC,oBAAoB,CAAC,CAAC,CAAC,kDAAkD,GAAG,oBAAoB,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,WAClH,CAAC,SAAC;QACH,KAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;;IAC5C,CAAC;IACF,mCAAC;AAAD,CAAC,AApBD,CAA2C,KAAK,GAoB/C;AAOD;;;;;;;GAOG;AACH,SAAgB,0BAA0B,CACzC,EAAK,EACL,SAA2C,EAC3C,EAAyE;QAAvE,0BAA0B,gCAAA,EAAE,gCAAgC,sCAAA;IAE9D,IAAM,KAAK,GAAG,IAAI,4BAA4B,YAAG,iBAAiB,EAAE,EAAE,CAAC,IAAI,IAAK,SAAS,EAAG,CAAC;IAE7F,IAAI,0BAA0B,KAAK,IAAI,EAAE,CAAC;QACzC,OAAO,CAAC;YACP,MAAM,KAAK,CAAC;QACb,CAAC,CAAiB,CAAC;IACpB,CAAC;IACD,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,IAAI,gCAAgC,KAAK,IAAI,EAAE,CAAC;QAClF,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IACD,OAAO,EAAE,CAAC;AACX,CAAC;AAED;;;GAGG;AACH,SAAgB,mBAAmB,CAAC,eAA4B,EAAE,OAAgB;IACjF,eAAe,CAAC,IAAI,GAAG,0BAA0B,CAChD,eAAe,CAAC,IAAI,EACpB;QACC,MAAM,EAAE,2EAA2E;QACnF,iBAAiB,EAAE,6CAA6C;KAChE,EACD,OAAO,CACP,CAAC;IAEF,eAAe,CAAC,IAAI,GAAG,0BAA0B,CAChD,eAAe,CAAC,IAAI,EACpB;QACC,MAAM,EAAE,2EAA2E;QACnF,iBAAiB,EAAE,6CAA6C;KAChE,EACD,OAAO,CACP,CAAC;IAEF,eAAe,CAAC,IAAI,GAAG,0BAA0B,CAChD,eAAe,CAAC,IAAI,EACpB;QACC,MAAM,EAAE,0FAA0F;QAClG,iBAAiB,EAAE,6CAA6C;KAChE,EACD,OAAO,CACP,CAAC;IAEF,eAAe,CAAC,IAAI,GAAG,0BAA0B,CAChD,eAAe,CAAC,IAAI,EACpB;QACC,MAAM,EAAE,0FAA0F;QAClG,iBAAiB,EAAE,6CAA6C;KAChE,EACD,OAAO,CACP,CAAC;IAEF,eAAe,CAAC,GAAG,GAAG,0BAA0B,CAC/C,eAAe,CAAC,GAAG,EACnB;QACC,MAAM,EAAE,0FAA0F;QAClG,iBAAiB,EAAE,4CAA4C;QAC/D,oBAAoB,EAAE,QAAQ;KAC9B,EACD,OAAO,CACP,CAAC;IAEF,eAAe,CAAC,GAAG,GAAG,0BAA0B,CAC/C,eAAe,CAAC,GAAG,EACnB;QACC,MAAM,EAAE,0FAA0F;QAClG,iBAAiB,EAAE,4CAA4C;QAC/D,oBAAoB,EAAE,QAAQ;KAC9B,EACD,OAAO,CACP,CAAC;IAEF,OAAO,eAAe,CAAC;AACxB,CAAC"}

package/dist/Lib/String/string.d.ts

@@ -0,0 +1 @@
+export declare const getEmailDomain: (email: string) => string;

package/dist/Lib/String/string.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmailDomain = void 0;
+var getEmailDomain = function (email) { return email.split('@')[1]; };
+exports.getEmailDomain = getEmailDomain;
+//# sourceMappingURL=string.js.map

package/dist/Lib/String/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../../src/Lib/String/string.ts"],"names":[],"mappings":";;;AAAO,IAAM,cAAc,GAAG,UAAC,KAAa,IAAK,OAAA,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAnB,CAAmB,CAAC;AAAxD,QAAA,cAAc,kBAA0C"}

package/dist/Lock/lockedDecorator.d.ts

@@ -0,0 +1,12 @@
+export interface IOptions {
+    timeout?: number;
+    maxPending?: number;
+    domainReentrant?: boolean;
+    /**
+     * Defines whether async lock is scoped for global all instances of decorated class or only for single instance.
+     * So for instance scope if there are more instances of class and the key of lock is same, they are not affecting each other.
+     * Default is global.
+     */
+    scope?: 'global' | 'instance';
+}
+export declare function locked<TArgs extends unknown[], TThis extends object>(keyInitiator: string | string[] | ((this: TThis, ...args: TArgs) => string | string[]), options?: IOptions): (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/Lock/lockedDecorator.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locked = locked;
+var async_lock_1 = __importDefault(require("async-lock"));
+var util = __importStar(require("util"));
+var globalAsyncLock = new async_lock_1.default();
+var asyncLocksMap = new WeakMap();
+function acquireAsyncLock(options, instance) {
+    if ((options === null || options === void 0 ? void 0 : options.scope) === undefined || (options === null || options === void 0 ? void 0 : options.scope) === 'global') {
+        return globalAsyncLock;
+    }
+    else if ((options === null || options === void 0 ? void 0 : options.scope) === 'instance') {
+        if (asyncLocksMap.has(instance)) {
+            var lock = asyncLocksMap.get(instance);
+            lock.countRunning++;
+            return lock.asyncLock;
+        }
+        else {
+            var asyncLock = new async_lock_1.default();
+            asyncLocksMap.set(instance, { countRunning: 1, asyncLock: asyncLock });
+            return asyncLock;
+        }
+    }
+    throw new Error("Invalid option scope=".concat(options === null || options === void 0 ? void 0 : options.scope));
+}
+function releaseAsyncLock(options, instance) {
+    if ((options === null || options === void 0 ? void 0 : options.scope) === 'instance') {
+        var lock = asyncLocksMap.get(instance);
+        lock.countRunning--;
+        if (lock.countRunning === 0) {
+            asyncLocksMap.delete(instance);
+        }
+    }
+}
+function locked(keyInitiator, options) {
+    return function (_target, _propertyKey, descriptor) {
+        var originalMethod = descriptor.value;
+        descriptor.value = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return __awaiter(this, void 0, void 0, function () {
+                var key, currentAsyncLock;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            key = typeof keyInitiator === 'function' ? keyInitiator.call.apply(keyInitiator, __spreadArray([this], args, false)) : keyInitiator;
+                            currentAsyncLock = acquireAsyncLock(options, this);
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, , 3, 4]);
+                            return [4 /*yield*/, currentAsyncLock.acquire(key, function () { return __awaiter(_this, void 0, void 0, function () {
+                                    var returnValuePromise;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                returnValuePromise = originalMethod.apply(this, args);
+                                                if (!(returnValuePromise instanceof Promise)) {
+                                                    throw new Error("Synchronous methods must return Promise instance. But ".concat(util.inspect(returnValuePromise), " given."));
+                                                }
+                                                return [4 /*yield*/, returnValuePromise];
+                                            case 1: return [2 /*return*/, _a.sent()];
+                                        }
+                                    });
+                                }); }, options)];
+                        case 2: return [2 /*return*/, _a.sent()];
+                        case 3:
+                            releaseAsyncLock(options, this);
+                            return [7 /*endfinally*/];
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+    };
+}
+//# sourceMappingURL=lockedDecorator.js.map

package/dist/Lock/lockedDecorator.js.map

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

package/dist/Logging/console.d.ts

@@ -0,0 +1,8 @@
+import { ILogger } from './logger';
+/**
+ * This function will redirect all logs that are logged to the console to the logger.
+ *
+ * The goal is to collect all logs that are not logged through the central logger and make them go through the logger.
+ * That way we can control the format and destination of all logs no matter where they are logged.
+ */
+export declare function redirectConsoleToLogger(logger: ILogger): void;

package/dist/Logging/console.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redirectConsoleToLogger = redirectConsoleToLogger;
+var logMetrics_1 = require("../Metrics/logMetrics");
+/**
+ * This function will redirect all logs that are logged to the console to the logger.
+ *
+ * The goal is to collect all logs that are not logged through the central logger and make them go through the logger.
+ * That way we can control the format and destination of all logs no matter where they are logged.
+ */
+function redirectConsoleToLogger(logger) {
+    console.debug = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        logger.debug(message, { args: args });
+    };
+    console.log = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        logger.info(message, { args: args });
+    };
+    console.info = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        logger.info(message, { args: args });
+    };
+    console.warn = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        logger.warn(message, { args: args });
+        logMetrics_1.metrics.emit('warning_count');
+    };
+    console.error = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        logger.error(message, { args: args });
+        logMetrics_1.metrics.emit('error_count');
+    };
+}
+//# sourceMappingURL=console.js.map

package/dist/Logging/console.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.js","sourceRoot":"","sources":["../../src/Logging/console.ts"],"names":[],"mappings":";;AASA,0DAsBC;AA9BD,oDAAgD;AAEhD;;;;;GAKG;AACH,SAAgB,uBAAuB,CAAC,MAAe;IACtD,OAAO,CAAC,KAAK,GAAG,UAAC,OAAY;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QAC5C,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,IAAI,MAAA,EAAE,CAAC,CAAC;IACjC,CAAC,CAAC;IAEF,OAAO,CAAC,GAAG,GAAG,UAAC,OAAY;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QAC1C,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,MAAA,EAAE,CAAC,CAAC;IAChC,CAAC,CAAC;IAEF,OAAO,CAAC,IAAI,GAAG,UAAC,OAAY;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QAC3C,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,MAAA,EAAE,CAAC,CAAC;IAChC,CAAC,CAAC;IAEF,OAAO,CAAC,IAAI,GAAG,UAAC,OAAY;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QAC3C,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,MAAA,EAAE,CAAC,CAAC;QAC/B,oBAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC/B,CAAC,CAAC;IAEF,OAAO,CAAC,KAAK,GAAG,UAAC,OAAY;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QAC5C,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,IAAI,MAAA,EAAE,CAAC,CAAC;QAChC,oBAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC7B,CAAC,CAAC;AACH,CAAC"}

package/dist/Logging/debug.d.ts

@@ -0,0 +1,10 @@
+import { ILogger } from './logger';
+/**
+ * This function will redirect all logs that are logged through the debug library to the logger.
+ *
+ * We need to route all debug logs through winston as well.
+ * We have to perform a couple of tricks to make that work correctly:
+ *   1. Disable colors for debug logs, otherwise the special characters for colors get printed in the log message
+ *   2. Redirect the debug logs to the winston logger
+ */
+export declare function redirectDebugToLogger(logger: ILogger): void;

package/dist/Logging/debug.js

@@ -0,0 +1,61 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redirectDebugToLogger = redirectDebugToLogger;
+// need to require to be able to override Debug.log, import doesn't work
+var Debug = require('debug');
+/**
+ * This function will redirect all logs that are logged through the debug library to the logger.
+ *
+ * We need to route all debug logs through winston as well.
+ * We have to perform a couple of tricks to make that work correctly:
+ *   1. Disable colors for debug logs, otherwise the special characters for colors get printed in the log message
+ *   2. Redirect the debug logs to the winston logger
+ */
+function redirectDebugToLogger(logger) {
+    Debug.log = function (message) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var formatted = formatDebugLog.apply(void 0, __spreadArray([message], args, false));
+        logger.debug(formatted.message, { args: formatted.args });
+    };
+}
+function formatDebugLog(message) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    // Depending on the environment, debug might add color codes to the message and args.
+    // Since we're redirecting it to a central logger, we need to get rid of those and let logger control the output format and colors.
+    // Debug isn't implemented ideally and it's impossible to reliably disable colors other way than via env var DEBUG_COLORS=0
+    // So, it's more reliable to remove the color codes on the fly with a regex.
+    var messageWithoutColors = removeBashColors(message).trim();
+    // If debug has disabled colors (only controllable via env var DEBUG_COLORS=0), it will print the date in the beginning of the message.
+    // We need to remove that as well, so that the message is consistent with the rest of the logs.
+    // Logger will control the output format, including if the log should contain the date.
+    var finalMessage = removeDateFromStart(messageWithoutColors).trim();
+    // If the debug has enabled colors, it will also add an arg to the end of args
+    // that contains the duration since the previous log (i.e. "+25ms").
+    // This will also contain color codes that we have to get rid of.
+    if (args.length > 0 && typeof args[args.length - 1] === 'string') {
+        args[args.length - 1] = removeBashColors(args[args.length - 1]);
+    }
+    return { message: finalMessage, args: args };
+}
+function removeBashColors(str) {
+    return str.replace(/\u001b\[[0-9;]*m/g, '');
+}
+function removeDateFromStart(str) {
+    return str.replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/, '');
+}
+//# sourceMappingURL=debug.js.map

package/dist/Logging/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.js","sourceRoot":"","sources":["../../src/Logging/debug.ts"],"names":[],"mappings":";;;;;;;;;;;AAaA,sDAKC;AAhBD,wEAAwE;AACxE,IAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE/B;;;;;;;GAOG;AACH,SAAgB,qBAAqB,CAAC,MAAe;IACpD,KAAK,CAAC,GAAG,GAAG,UAAC,OAAe;QAAE,cAAc;aAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;YAAd,6BAAc;;QAC3C,IAAM,SAAS,GAAG,cAAc,8BAAC,OAAO,GAAK,IAAI,SAAC,CAAC;QACnD,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3D,CAAC,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,OAAe;IAAE,cAAc;SAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;QAAd,6BAAc;;IACtD,qFAAqF;IACrF,mIAAmI;IACnI,2HAA2H;IAC3H,4EAA4E;IAC5E,IAAM,oBAAoB,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;IAE9D,uIAAuI;IACvI,+FAA+F;IAC/F,uFAAuF;IACvF,IAAM,YAAY,GAAG,mBAAmB,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE,CAAC;IAEtE,8EAA8E;IAC9E,oEAAoE;IACpE,iEAAiE;IACjE,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,QAAQ,EAAE,CAAC;QAClE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,IAAI,MAAA,EAAE,CAAC;AACxC,CAAC;AAED,SAAS,gBAAgB,CAAC,GAAW;IACpC,OAAO,GAAG,CAAC,OAAO,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC;AAC7C,CAAC;AAED,SAAS,mBAAmB,CAAC,GAAW;IACvC,OAAO,GAAG,CAAC,OAAO,CAAC,6CAA6C,EAAE,EAAE,CAAC,CAAC;AACvE,CAAC"}

package/dist/Logging/format.d.ts

@@ -0,0 +1,10 @@
+import * as winston from 'winston';
+/**
+ * Recursively formats Error objects in the log data structure.
+ * Handles errors in direct properties, arrays, and nested objects.
+ * Includes protection against circular references.
+ *
+ * Without this step, the output of serialization of the Error object is an empty object.
+ * @see https://stackoverflow.com/questions/18391212/is-it-not-possible-to-stringify-an-error-using-json-stringify
+ */
+export declare const formatNestedErrors: winston.Logform.FormatWrap;