@signageos/lib 23.8.1 → 23.8.2-master.4405

package/dist/MongoDB/ProprietaryCluster/SelectionStrategy/ordinary.js

@@ -0,0 +1,80 @@
+"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.ordinary = ordinary;
+var helper_1 = require("../helper");
+var timeout_1 = require("../../../Timer/timeout");
+var CONNECTION_TIMEOUT = 5e3;
+function ordinary(parsedDsn, originalDsn) {
+    return __awaiter(this, void 0, void 0, function () {
+        var firstAvailableHost, _i, _a, host, error_1, selectedDsn;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    firstAvailableHost = undefined;
+                    _i = 0, _a = parsedDsn.hosts;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < _a.length)) return [3 /*break*/, 6];
+                    host = _a[_i];
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, (0, timeout_1.withTimeout)((0, helper_1.tryConnection)(host, parsedDsn), CONNECTION_TIMEOUT)];
+                case 3:
+                    _b.sent();
+                    firstAvailableHost = host;
+                    return [3 /*break*/, 6];
+                case 4:
+                    error_1 = _b.sent();
+                    console.error('Not available host', host, error_1);
+                    return [3 /*break*/, 5];
+                case 5:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 6:
+                    if (!firstAvailableHost) {
+                        throw new Error("No available connection string (DSN) found: ".concat(originalDsn));
+                    }
+                    selectedDsn = (0, helper_1.getDsn)(firstAvailableHost, parsedDsn);
+                    return [2 /*return*/, selectedDsn];
+            }
+        });
+    });
+}
+//# sourceMappingURL=ordinary.js.map

package/dist/MongoDB/ProprietaryCluster/SelectionStrategy/ordinary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordinary.js","sourceRoot":"","sources":["../../../../src/MongoDB/ProprietaryCluster/SelectionStrategy/ordinary.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,4BAiBC;AAtBD,oCAAkD;AAClD,kDAAqD;AAErD,IAAM,kBAAkB,GAAG,GAAG,CAAC;AAE/B,SAAsB,QAAQ,CAAC,SAAsC,EAAE,WAAmB;;;;;;oBACrF,kBAAkB,GAAsC,SAAS,CAAC;0BACpC,EAAf,KAAA,SAAS,CAAC,KAAK;;;yBAAf,CAAA,cAAe,CAAA;oBAAvB,IAAI;;;;oBAEb,qBAAM,IAAA,qBAAW,EAAC,IAAA,sBAAa,EAAC,IAAI,EAAE,SAAS,CAAC,EAAE,kBAAkB,CAAC,EAAA;;oBAArE,SAAqE,CAAC;oBACtE,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,wBAAM;;;oBAEN,OAAO,CAAC,KAAK,CAAC,oBAAoB,EAAE,IAAI,EAAE,OAAK,CAAC,CAAC;;;oBANhC,IAAe,CAAA;;;oBASlC,IAAI,CAAC,kBAAkB,EAAE,CAAC;wBACzB,MAAM,IAAI,KAAK,CAAC,sDAA+C,WAAW,CAAE,CAAC,CAAC;oBAC/E,CAAC;oBAEK,WAAW,GAAG,IAAA,eAAM,EAAC,kBAAkB,EAAE,SAAS,CAAC,CAAC;oBAC1D,sBAAO,WAAW,EAAC;;;;CACnB"}

package/dist/MongoDB/ProprietaryCluster/SelectionStrategy/random.d.ts

@@ -0,0 +1,2 @@
+import { IConnectionStringParameters } from 'connection-string-parser';
+export declare function random(parsedDsn: IConnectionStringParameters, _originalDsn: string): Promise<string>;

package/dist/MongoDB/ProprietaryCluster/SelectionStrategy/random.js

@@ -0,0 +1,51 @@
+"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.random = random;
+var helper_1 = require("../helper");
+function random(parsedDsn, _originalDsn) {
+    return __awaiter(this, void 0, void 0, function () {
+        var selectedHost, selectedDsn;
+        return __generator(this, function (_a) {
+            selectedHost = parsedDsn.hosts[Math.round(Math.random() * new Date().valueOf()) % parsedDsn.hosts.length];
+            selectedDsn = (0, helper_1.getDsn)(selectedHost, parsedDsn);
+            return [2 /*return*/, selectedDsn];
+        });
+    });
+}
+//# sourceMappingURL=random.js.map

package/dist/MongoDB/ProprietaryCluster/SelectionStrategy/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","sourceRoot":"","sources":["../../../../src/MongoDB/ProprietaryCluster/SelectionStrategy/random.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAIC;AAND,oCAAmC;AAEnC,SAAsB,MAAM,CAAC,SAAsC,EAAE,YAAoB;;;;YAClF,YAAY,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAC1G,WAAW,GAAG,IAAA,eAAM,EAAC,YAAY,EAAE,SAAS,CAAC,CAAC;YACpD,sBAAO,WAAW,EAAC;;;CACnB"}

package/dist/MongoDB/ProprietaryCluster/helper.d.ts

@@ -0,0 +1,13 @@
+import * as mongodb from 'mongodb';
+import { IConnectionStringHost, IConnectionStringParameters } from 'connection-string-parser';
+export declare function tryConnection(host: IConnectionStringHost, parameters: IConnectionStringParameters): Promise<mongodb.BSON.Document>;
+export declare function getDsn(host: IConnectionStringHost, parameters: IConnectionStringParameters, omitParamNames?: string[]): string;
+export declare function withoutOptions(parameters: IConnectionStringParameters, omitParamNames?: string[]): {
+    options: Pick<any, number | symbol>;
+    scheme: string;
+    username?: string;
+    password?: string;
+    hosts: IConnectionStringHost[];
+    endpoint?: string;
+};
+export declare function doConnectionCallback<T>(host: IConnectionStringHost, parameters: IConnectionStringParameters, callback: (conn: mongodb.MongoClient) => Promise<T>): Promise<T>;

package/dist/MongoDB/ProprietaryCluster/helper.js

@@ -0,0 +1,147 @@
+"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 __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.tryConnection = tryConnection;
+exports.getDsn = getDsn;
+exports.withoutOptions = withoutOptions;
+exports.doConnectionCallback = doConnectionCallback;
+var _ = __importStar(require("lodash"));
+var mongodb = __importStar(require("mongodb"));
+var connection_string_parser_1 = require("connection-string-parser");
+var debug_1 = __importDefault(require("debug"));
+var debug = (0, debug_1.default)('@signageos/lib:MongoDB:proprietaryCluster');
+var connectionStringParser = new connection_string_parser_1.ConnectionStringParser({
+    scheme: 'mongodb',
+    hosts: [],
+});
+function tryConnection(host, parameters) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            return [2 /*return*/, doConnectionCallback(host, parameters, function (connection) { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, connection.db(parameters.endpoint).stats()];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    });
+                }); })];
+        });
+    });
+}
+function getDsn(host, parameters, omitParamNames) {
+    if (omitParamNames === void 0) { omitParamNames = []; }
+    return connectionStringParser.format(withoutOptions(__assign(__assign({}, parameters), { hosts: [host] }), omitParamNames));
+}
+function withoutOptions(parameters, omitParamNames) {
+    if (omitParamNames === void 0) { omitParamNames = []; }
+    return __assign(__assign({}, parameters), { options: _.omit.apply(_, __spreadArray([parameters.options, 'proprietaryServerSelectionStrategy', 'proprietaryReplicaSet'], omitParamNames, false)) });
+}
+function doConnectionCallback(host, parameters, callback) {
+    return __awaiter(this, void 0, void 0, function () {
+        var dsn, connection, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dsn = getDsn(host, parameters);
+                    return [4 /*yield*/, mongodb.MongoClient.connect(dsn, {
+                            connectTimeoutMS: 5e3, // keep short timeout for connection because slow connections has latency bad as well
+                            socketTimeoutMS: 5e3,
+                            serverSelectionTimeoutMS: 5e3, // in proprietary replica set, host should have 1 node, so this is not usually used
+                        })];
+                case 1:
+                    connection = _a.sent();
+                    return [4 /*yield*/, callback(connection)];
+                case 2:
+                    result = _a.sent();
+                    debug('connection callback result', host, parameters, result);
+                    return [4 /*yield*/, connection.close()];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/, result];
+            }
+        });
+    });
+}
+//# sourceMappingURL=helper.js.map

package/dist/MongoDB/ProprietaryCluster/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../../../src/MongoDB/ProprietaryCluster/helper.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,sCAIC;AAED,wBAUC;AAED,wCAKC;AAED,oDAeC;AAnDD,wCAA4B;AAC5B,+CAAmC;AACnC,qEAAsH;AACtH,gDAA0B;AAC1B,IAAM,KAAK,GAAG,IAAA,eAAK,EAAC,2CAA2C,CAAC,CAAC;AAEjE,IAAM,sBAAsB,GAAG,IAAI,iDAAsB,CAAC;IACzD,MAAM,EAAE,SAAS;IACjB,KAAK,EAAE,EAAE;CACT,CAAC,CAAC;AAEH,SAAsB,aAAa,CAAC,IAA2B,EAAE,UAAuC;;;;YACvG,sBAAO,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAO,UAAU;;;oCACvD,qBAAM,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAA;oCAAvD,sBAAO,SAAgD,EAAC;;;qBACxD,CAAC,EAAC;;;CACH;AAED,SAAgB,MAAM,CAAC,IAA2B,EAAE,UAAuC,EAAE,cAA6B;IAA7B,+BAAA,EAAA,mBAA6B;IACzH,OAAO,sBAAsB,CAAC,MAAM,CACnC,cAAc,uBAET,UAAU,KACb,KAAK,EAAE,CAAC,IAAI,CAAC,KAEd,cAAc,CACd,CACD,CAAC;AACH,CAAC;AAED,SAAgB,cAAc,CAAC,UAAuC,EAAE,cAA6B;IAA7B,+BAAA,EAAA,mBAA6B;IACpG,6BACI,UAAU,KACb,OAAO,EAAE,CAAC,CAAC,IAAI,OAAN,CAAC,iBAAM,UAAU,CAAC,OAAO,EAAE,oCAAoC,EAAE,uBAAuB,GAAK,cAAc,aACnH;AACH,CAAC;AAED,SAAsB,oBAAoB,CACzC,IAA2B,EAC3B,UAAuC,EACvC,QAAmD;;;;;;oBAE7C,GAAG,GAAG,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;oBAClB,qBAAM,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,EAAE;4BACzD,gBAAgB,EAAE,GAAG,EAAE,qFAAqF;4BAC5G,eAAe,EAAE,GAAG;4BACpB,wBAAwB,EAAE,GAAG,EAAE,mFAAmF;yBAClH,CAAC,EAAA;;oBAJI,UAAU,GAAG,SAIjB;oBACa,qBAAM,QAAQ,CAAC,UAAU,CAAC,EAAA;;oBAAnC,MAAM,GAAG,SAA0B;oBACzC,KAAK,CAAC,4BAA4B,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBAC9D,qBAAM,UAAU,CAAC,KAAK,EAAE,EAAA;;oBAAxB,SAAwB,CAAC;oBACzB,sBAAO,MAAM,EAAC;;;;CACd"}

package/dist/MongoDB/cursorIterator.d.ts

@@ -0,0 +1,5 @@
+export interface IForwardCursor<T> {
+    hasNext(): Promise<boolean>;
+    next(): Promise<T | null>;
+}
+export declare function cursorAsyncIterator<T>(dbCursor: IForwardCursor<T>): AsyncIterableIterator<T | null>;

package/dist/MongoDB/cursorIterator.js

@@ -0,0 +1,63 @@
+"use strict";
+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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cursorAsyncIterator = cursorAsyncIterator;
+function cursorAsyncIterator(dbCursor) {
+    return __asyncGenerator(this, arguments, function cursorAsyncIterator_1() {
+        var next;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, __await(dbCursor.hasNext())];
+                case 1:
+                    if (!_a.sent()) return [3 /*break*/, 4];
+                    next = dbCursor.next();
+                    return [4 /*yield*/, __await(next)];
+                case 2: return [4 /*yield*/, _a.sent()];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 0];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+//# sourceMappingURL=cursorIterator.js.map

package/dist/MongoDB/cursorIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursorIterator.js","sourceRoot":"","sources":["../../src/MongoDB/cursorIterator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,kDAKC;AALD,SAAuB,mBAAmB,CAAI,QAA2B;;;;;wBACjE,6BAAM,QAAQ,CAAC,OAAO,EAAE,GAAA;;yBAAxB,SAAwB;oBACxB,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;iDACvB,IAAI;wBAAV,gCAAU;;oBAAV,SAAU,CAAC;;;;;;CAEZ"}

package/dist/MongoDB/escape.d.ts

@@ -0,0 +1,4 @@
+export declare function escapeObject(object: any): any;
+export declare function unescapeObject(object: any): any;
+export declare function escape(key: string): string;
+export declare function unescape(key: string): string;

package/dist/MongoDB/escape.js

@@ -0,0 +1,54 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeObject = escapeObject;
+exports.unescapeObject = unescapeObject;
+exports.escape = escape;
+exports.unescape = unescape;
+var lodash_1 = require("lodash");
+function escapeObject(object) {
+    return recureObject(object, escape);
+}
+function unescapeObject(object) {
+    return recureObject(object, unescape);
+}
+function recureObject(recuringObject, callback) {
+    return (0, lodash_1.isPlainObject)(recuringObject)
+        ? Object.keys(recuringObject).reduce(function (reductionObject, key) {
+            var _a;
+            var updatedKey = callback(key);
+            var subObject = reductionObject[key];
+            var updatedSubObject = recureObject(subObject, callback);
+            if (key !== updatedKey || subObject !== updatedSubObject) {
+                var omittedObject = (0, lodash_1.omit)(reductionObject, key);
+                return __assign(__assign({}, omittedObject), (_a = {}, _a[updatedKey] = updatedSubObject, _a));
+            }
+            else {
+                return reductionObject;
+            }
+        }, recuringObject)
+        : recuringObject;
+}
+function escape(key) {
+    return isEscapable(key) ? key.replace(/\$/g, '\uFF04').replace(/\./g, '\uFF0E') : key;
+}
+function unescape(key) {
+    return isUnescapable(key) ? key.replace(/\uFF04/g, '$').replace(/\uFF0E/g, '.') : key;
+}
+function isEscapable(key) {
+    return key.indexOf('$') !== -1 || key.indexOf('.') !== -1;
+}
+function isUnescapable(key) {
+    return key.indexOf('\uFF04') !== -1 || key.indexOf('\uFF0E') !== -1;
+}
+//# sourceMappingURL=escape.js.map

package/dist/MongoDB/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.js","sourceRoot":"","sources":["../../src/MongoDB/escape.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAEA,oCAEC;AAED,wCAEC;AAqBD,wBAEC;AAED,4BAEC;AAnCD,iCAA6C;AAE7C,SAAgB,YAAY,CAAC,MAAW;IACvC,OAAO,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AACrC,CAAC;AAED,SAAgB,cAAc,CAAC,MAAW;IACzC,OAAO,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AACvC,CAAC;AAED,SAAS,YAAY,CAAyC,cAAuB,EAAE,QAAiC;IACvH,OAAO,IAAA,sBAAa,EAAC,cAAc,CAAC;QACnC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,MAAM,CAAU,UAAC,eAAwB,EAAE,GAAW;;YAClF,IAAM,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;YACjC,IAAM,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;YACvC,IAAM,gBAAgB,GAAG,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC3D,IAAI,GAAG,KAAK,UAAU,IAAI,SAAS,KAAK,gBAAgB,EAAE,CAAC;gBAC1D,IAAM,aAAa,GAAG,IAAA,aAAI,EAAC,eAAe,EAAE,GAAG,CAAC,CAAC;gBACjD,OAAO,sBACH,aAAa,gBACf,UAAU,IAAG,gBAAgB,MACnB,CAAC;YACd,CAAC;iBAAM,CAAC;gBACP,OAAO,eAAe,CAAC;YACxB,CAAC;QACF,CAAC,EAAE,cAAc,CAAC;QACnB,CAAC,CAAC,cAAc,CAAC;AACnB,CAAC;AAED,SAAgB,MAAM,CAAC,GAAW;IACjC,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACvF,CAAC;AAED,SAAgB,QAAQ,CAAC,GAAW;IACnC,OAAO,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACvF,CAAC;AAED,SAAS,WAAW,CAAC,GAAW;IAC/B,OAAO,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED,SAAS,aAAa,CAAC,GAAW;IACjC,OAAO,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;AACrE,CAAC"}

package/dist/MongoDB/mongoDBConnectionFactory.d.ts

@@ -0,0 +1,13 @@
+import mongoose from 'mongoose';
+import * as mongodb from 'mongodb';
+import { IMongoDBDriverExporter } from '../Metrics/mongoDBMetrics';
+import { IConnection } from '../ThirdParty/connection';
+export interface IMongodbConnection extends IConnection<IMongoDBDriverExporter> {
+    connection: mongoose.Connection | null;
+    session?: mongodb.ClientSession;
+    monitor: (connectionName: string, exporter: IMongoDBDriverExporter) => void;
+}
+/**
+ * @deprecated use MongoDBConnection class directly
+ */
+export declare function createMongodbConnection(mongoDbDsn: string, options?: mongoose.ConnectOptions): IMongodbConnection;

package/dist/MongoDB/mongoDBConnectionFactory.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongodbConnection = createMongodbConnection;
+var MongoDBConnection_1 = require("./MongoDBConnection");
+/**
+ * @deprecated use MongoDBConnection class directly
+ */
+function createMongodbConnection(mongoDbDsn, options) {
+    return new MongoDBConnection_1.MongoDBConnection(mongoDbDsn, options);
+}
+//# sourceMappingURL=mongoDBConnectionFactory.js.map

package/dist/MongoDB/mongoDBConnectionFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoDBConnectionFactory.js","sourceRoot":"","sources":["../../src/MongoDB/mongoDBConnectionFactory.ts"],"names":[],"mappings":";;AAeA,0DAEC;AAdD,yDAAwD;AASxD;;GAEG;AACH,SAAgB,uBAAuB,CAAC,UAAkB,EAAE,OAAiC;IAC5F,OAAO,IAAI,qCAAiB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AACnD,CAAC"}

package/dist/MongoDB/proprietaryCluster.d.ts

@@ -0,0 +1 @@
+export declare function updateDsnIfProprietaryCluster(originalDsn: string): Promise<string>;

package/dist/MongoDB/proprietaryCluster.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.updateDsnIfProprietaryCluster = updateDsnIfProprietaryCluster;
+var connection_string_parser_1 = require("connection-string-parser");
+var random_1 = require("./ProprietaryCluster/SelectionStrategy/random");
+var ordinary_1 = require("./ProprietaryCluster/SelectionStrategy/ordinary");
+var dynamicPriority_1 = require("./ProprietaryCluster/SelectionStrategy/dynamicPriority");
+var lowReadLatency_1 = require("./ProprietaryCluster/SelectionStrategy/lowReadLatency");
+var connectionStringParser = new connection_string_parser_1.ConnectionStringParser({
+    scheme: 'mongodb',
+    hosts: [],
+});
+var selectionStrategies = {
+    random: random_1.random,
+    ordinary: ordinary_1.ordinary,
+    dynamicPriority: dynamicPriority_1.dynamicPriority,
+    lowReadLatency: lowReadLatency_1.lowReadLatency,
+};
+function updateDsnIfProprietaryCluster(originalDsn) {
+    return __awaiter(this, void 0, void 0, function () {
+        var parsedDsn, serverSelectionStrategy, selectionStrategy;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    parsedDsn = connectionStringParser.parse(originalDsn);
+                    if (!(parsedDsn.options && parsedDsn.options.proprietaryReplicaSet)) return [3 /*break*/, 4];
+                    serverSelectionStrategy = parsedDsn.options.proprietaryServerSelectionStrategy;
+                    selectionStrategy = selectionStrategies[serverSelectionStrategy];
+                    if (!selectionStrategy) return [3 /*break*/, 2];
+                    return [4 /*yield*/, selectionStrategy(parsedDsn, originalDsn)];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2: throw new Error("Unknown proprietaryServerSelectionStrategy: ".concat(serverSelectionStrategy));
+                case 3: return [3 /*break*/, 5];
+                case 4: return [2 /*return*/, originalDsn];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+//# sourceMappingURL=proprietaryCluster.js.map

package/dist/MongoDB/proprietaryCluster.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proprietaryCluster.js","sourceRoot":"","sources":["../../src/MongoDB/proprietaryCluster.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,sEAaC;AA/BD,qEAAkE;AAClE,wEAAuE;AACvE,4EAA2E;AAC3E,0FAAyF;AACzF,wFAAuF;AAEvF,IAAM,sBAAsB,GAAG,IAAI,iDAAsB,CAAC;IACzD,MAAM,EAAE,SAAS;IACjB,KAAK,EAAE,EAAE;CACT,CAAC,CAAC;AAEH,IAAM,mBAAmB,GAAG;IAC3B,MAAM,iBAAA;IACN,QAAQ,qBAAA;IACR,eAAe,mCAAA;IACf,cAAc,iCAAA;CACd,CAAC;AAEF,SAAsB,6BAA6B,CAAC,WAAmB;;;;;;oBAChE,SAAS,GAAG,sBAAsB,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;yBACxD,CAAA,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,qBAAqB,CAAA,EAA5D,wBAA4D;oBACzD,uBAAuB,GAAqC,SAAS,CAAC,OAAO,CAAC,kCAAkC,CAAC;oBACjH,iBAAiB,GAAG,mBAAmB,CAAC,uBAAuB,CAAC,CAAC;yBACnE,iBAAiB,EAAjB,wBAAiB;oBACb,qBAAM,iBAAiB,CAAC,SAAS,EAAE,WAAW,CAAC,EAAA;wBAAtD,sBAAO,SAA+C,EAAC;wBAEvD,MAAM,IAAI,KAAK,CAAC,sDAA+C,uBAAuB,CAAE,CAAC,CAAC;;wBAG3F,sBAAO,WAAW,EAAC;;;;;CAEpB"}

package/dist/Npm/INpmClient.d.ts

@@ -0,0 +1,25 @@
+export interface DownloadPackageArgs {
+    packageName: string;
+    downloadPath: string;
+    version?: string;
+}
+export interface PublishPackageArgs {
+    packageName: string;
+    packagePath: string;
+}
+/**
+ * Npm client interface
+ *
+ * Provides a common abstractions for programmatic access to npm registry
+ */
+export interface INpmClient {
+    /** Returns all package versions from the registry */
+    getPackageVersions(packageName: string): Promise<string[]>;
+    /**
+     * Downloads package tarball to a specified path
+     *
+     * @params version if not specified, will download the latest version
+     * @returns path to the downloaded tarball
+     */
+    downloadPackage(args: DownloadPackageArgs): Promise<string>;
+}

package/dist/Npm/INpmClient.js

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

package/dist/Npm/INpmClient.js.map

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

package/dist/Npm/MockNpmClient.d.ts

@@ -0,0 +1,17 @@
+import { DownloadPackageArgs, INpmClient } from './INpmClient';
+/**
+ * Mock implementation of INpmClient
+ *
+ * Useful for testing code that depends on INpmClient
+ */
+export declare class MockNpmClient implements INpmClient {
+    private packages;
+    addPackageVersion({ packageName, version, tarballPath }: {
+        packageName: string;
+        version: string;
+        tarballPath: string;
+    }): void;
+    getPackageVersions(packageName: string): Promise<string[]>;
+    downloadPackage({ packageName, downloadPath, version }: DownloadPackageArgs): Promise<string>;
+    private getLatestVersion;
+}