@resolveio/server-lib 12.5.54 → 12.5.56

package/managers/mongo.manager.js

@@ -0,0 +1,2221 @@
+"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 __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.objectIdHexString = exports.MongoManagerUserCollection = exports.MongoManagerCollection = exports.MongoManagerModel = exports.MongoManager = void 0;
+var simpl_schema_1 = require("simpl-schema");
+var mongodb_1 = require("mongodb");
+var index_1 = require("../index");
+var user_collection_1 = require("../collections/user.collection");
+var common_1 = require("../util/common");
+var log_collection_1 = require("../collections/log.collection");
+var NodeCache = require("node-cache");
+var crypto = require('crypto');
+var scmp = require('scmp');
+var monitor_manager_1 = require("./monitor.manager");
+var os_1 = require("os");
+var numCPUs = (0, os_1.cpus)().length;
+var v8 = require('v8');
+var MongoManager = /** @class */ (function () {
+    function MongoManager() {
+        var _this = this;
+        this._collections = [];
+        this._mongoQueue = [];
+        this._mongoQueueId = 0;
+        this._mongoQueueRunning = false;
+        this._mongoQueueCacheId = 1;
+        this._heapStats = v8.getHeapStatistics();
+        this._heapLimit = this._heapStats.heap_size_limit / numCPUs / 8;
+        this._serverCollections = [];
+        this._debugMongoQueueHits = 0;
+        this._debugRemoveCacheHits = 0;
+        this._debugMongoQueueCollections = [];
+        this._nodeCache = new NodeCache({ stdTTL: 0, checkperiod: 0 });
+        setInterval(function () {
+            if (index_1.ResolveIOServer.getMainServer().getSubscriptionManager().getEnableDebug()) {
+                console.log(new Date(), 'Mongo Manager', 'Collections', _this._collections.length);
+                console.log(new Date(), 'Mongo Manager', 'Mongo Queue', _this._mongoQueue.length, JSON.stringify(_this._mongoQueue.sort(function (a, b) { return a.name_collection.localeCompare(b.name_collection); }), null, 2));
+                console.log(new Date(), 'Mongo Manager', 'Server Collections', _this._serverCollections.length);
+                console.log(new Date(), 'Mongo Manager', 'Mongo Queue Hits', _this._debugMongoQueueHits);
+                console.log(new Date(), 'Mongo Manager', 'Mongo Queue Collections', _this._debugMongoQueueCollections.sort(function (a, b) { return a.collection.localeCompare(b.collection) || a.function.localeCompare(b.function); }));
+                console.log(new Date(), 'Mongo Manager', 'Cache Cleanup Hits', JSON.stringify(_this._debugRemoveCacheHits, null, 2));
+            }
+            _this._debugMongoQueueHits = 0;
+            _this._debugRemoveCacheHits = 0;
+            _this._debugMongoQueueCollections = [];
+        }, 60000);
+        this.initServerCollections();
+        this.runQueue();
+    }
+    MongoManager.prototype.initServerCollections = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var collections;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.ResolveIOServer.getMainDB().listCollections().toArray()];
+                    case 1:
+                        collections = _a.sent();
+                        this._serverCollections = collections;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MongoManager.prototype.getServerCollections = function () {
+        return this._serverCollections;
+    };
+    MongoManager.prototype.registerCollection = function (collection) {
+        var _this = this;
+        if (collection.collectionOptions && collection.collectionOptions.timeseries && collection.collectionOptions.timeseries.timeField && this._serverCollections.some(function (a) { return a.name === collection.collectionName && a.type === 'collection'; })) {
+            index_1.ResolveIOServer.getMainDB().dropCollection(collection.collectionName).then(function () {
+                _this.createCollection(collection);
+            });
+        }
+        this._collections.push(collection);
+    };
+    MongoManager.prototype.createCollection = function (collection) {
+        index_1.ResolveIOServer.getMainDB().createCollection(collection.collectionName, collection.collectionOptions);
+    };
+    MongoManager.prototype.collections = function () {
+        return this._collections;
+    };
+    MongoManager.prototype.collection = function (collectionName) {
+        return this._collections.filter(function (a) { return a.collectionName === collectionName; })[0];
+    };
+    MongoManager.prototype.addToQueue = function (mongoQueue) {
+        var _mongoQueue = this._mongoQueue.filter(function (a) { return a.name_collection === mongoQueue.name_collection && a.name_function === mongoQueue.name_function && a.name_function_addt === mongoQueue.name_function_addt && JSON.stringify(a.data_function) === JSON.stringify(mongoQueue.data_function) && JSON.stringify(a.data_function_addt) === JSON.stringify(mongoQueue.data_function_addt); })[0];
+        if (_mongoQueue) {
+            if (!_mongoQueue.running) {
+                _mongoQueue.cbs.push(mongoQueue.cbs[0]);
+            }
+            else {
+                _mongoQueue.cbs_next.push(mongoQueue.cbs[0]);
+            }
+        }
+        else {
+            mongoQueue._id = this._mongoQueueId;
+            this._mongoQueueId += 1;
+            this._mongoQueue.splice(0, 0, mongoQueue);
+        }
+    };
+    MongoManager.prototype.runQueue = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                setInterval(function () {
+                    if (!_this._mongoQueueRunning) {
+                        var queueArr = _this._mongoQueue.filter(function (a) { return !a.running && a.cbs.length; });
+                        if (queueArr.length) {
+                            _this._mongoQueueRunning = true;
+                            var _loop_1 = function (i) {
+                                var _a, _b, _c;
+                                _this._debugMongoQueueHits += 1;
+                                var mongoQueue = queueArr[i];
+                                if (!_this._debugMongoQueueCollections.some(function (a) { return a.collection === mongoQueue.name_collection && a.function === mongoQueue.name_function; })) {
+                                    _this._debugMongoQueueCollections.push({
+                                        collection: mongoQueue.name_collection,
+                                        function: mongoQueue.name_function,
+                                        hits: 1
+                                    });
+                                }
+                                else {
+                                    _this._debugMongoQueueCollections.filter(function (a) { return a.collection === mongoQueue.name_collection && a.function === mongoQueue.name_function; })[0].hits += 1;
+                                }
+                                mongoQueue.running = true;
+                                mongoQueue.invalidateFlag = false;
+                                if (mongoQueue.cacheId) {
+                                    try {
+                                        var res_1 = JSON.parse(_this._nodeCache.get(mongoQueue.cacheId), common_1.dateReviver);
+                                        mongoQueue.cbs.forEach(function (cb) {
+                                            cb(null, res_1, true);
+                                        });
+                                        mongoQueue.cbs = [];
+                                        mongoQueue.running = false;
+                                    }
+                                    catch (_d) {
+                                        mongoQueue.cacheId = 0;
+                                    }
+                                }
+                                if (!mongoQueue.cacheId) {
+                                    if (!mongoQueue.name_function_addt) {
+                                        var monitor_1 = new monitor_manager_1.MonitorMongo(mongoQueue.name_function, mongoQueue.name_collection, JSON.stringify(mongoQueue.data_function));
+                                        (_a = index_1.ResolveIOServer.getMainDB().collection(mongoQueue.name_collection))[mongoQueue.name_function].apply(_a, mongoQueue.data_function).then(function (res) {
+                                            monitor_1.finish();
+                                            if (!mongoQueue.invalidateFlag) {
+                                                mongoQueue.invalidateCount = 0;
+                                                var stringifyLength = 0;
+                                                var stringifyFail = false;
+                                                try {
+                                                    var stringify = JSON.stringify(res).replace(/[\[\]\,\"]/g, '');
+                                                    stringifyLength = stringify.length;
+                                                }
+                                                catch (e) {
+                                                    stringifyFail = true;
+                                                }
+                                                if (!stringifyFail && res !== null && res !== undefined && (!Array.isArray(res) || res.length) && stringifyLength < 10000000) {
+                                                    mongoQueue.cacheId = _this._mongoQueueCacheId;
+                                                    _this._mongoQueueCacheId += 1;
+                                                    _this.addToCache(mongoQueue.cacheId, res);
+                                                }
+                                                else {
+                                                    mongoQueue.cacheId = 0;
+                                                }
+                                                mongoQueue.cbs.forEach(function (cb) {
+                                                    cb(null, res, false);
+                                                });
+                                                if (mongoQueue.cbs_next.length) {
+                                                    mongoQueue.cbs = mongoQueue.cbs_next;
+                                                    mongoQueue.cbs_next = [];
+                                                }
+                                                else {
+                                                    mongoQueue.cbs = [];
+                                                }
+                                            }
+                                            else {
+                                                if (mongoQueue.invalidateCount >= 5) {
+                                                    mongoQueue.invalidateCount = 0;
+                                                    mongoQueue.cbs.forEach(function (cb) {
+                                                        cb(null, res, false);
+                                                    });
+                                                }
+                                                mongoQueue.cbs = mongoQueue.cbs.concat(mongoQueue.cbs_next);
+                                                mongoQueue.cbs_next = [];
+                                            }
+                                            mongoQueue.running = false;
+                                        }, function (err) {
+                                            monitor_1.finish();
+                                            console.log.apply(console, __spreadArray(__spreadArray([new Date(), 'Error ' + mongoQueue.name_function, mongoQueue.name_collection], mongoQueue.data_function, false), [err], false));
+                                            mongoQueue.cbs.forEach(function (cb) {
+                                                cb(err, null, false);
+                                            });
+                                            mongoQueue.cbs_next.forEach(function (cb) {
+                                                cb(err, null, false);
+                                            });
+                                            if (_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id) >= 0) {
+                                                _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id), 1);
+                                            }
+                                        });
+                                    }
+                                    else {
+                                        var monitor_2 = new monitor_manager_1.MonitorMongo(mongoQueue.name_function, mongoQueue.name_collection, JSON.stringify(__spreadArray(__spreadArray(__spreadArray([], mongoQueue.data_function, true), [mongoQueue.name_function_addt], false), mongoQueue.data_function_addt, true)));
+                                        (_b = (_c = index_1.ResolveIOServer.getMainDB().collection(mongoQueue.name_collection))[mongoQueue.name_function].apply(_c, mongoQueue.data_function))[mongoQueue.name_function_addt].apply(_b, mongoQueue.data_function_addt).then(function (res) {
+                                            monitor_2.finish();
+                                            if (!mongoQueue.invalidateFlag) {
+                                                mongoQueue.invalidateCount = 0;
+                                                var stringifyLength = 0;
+                                                var stringifyFail = false;
+                                                try {
+                                                    var stringify = JSON.stringify(res).replace(/[\[\]\,\"]/g, '');
+                                                    stringifyLength = stringify.length;
+                                                }
+                                                catch (e) {
+                                                    stringifyFail = true;
+                                                }
+                                                if (!stringifyFail && res !== null && res !== undefined && (!Array.isArray(res) || res.length) && stringifyLength < 10000000) {
+                                                    mongoQueue.cacheId = _this._mongoQueueCacheId;
+                                                    _this._mongoQueueCacheId += 1;
+                                                    _this.addToCache(mongoQueue.cacheId, res);
+                                                }
+                                                else {
+                                                    mongoQueue.cacheId = 0;
+                                                }
+                                                mongoQueue.cbs.forEach(function (cb) {
+                                                    cb(null, res, false);
+                                                });
+                                                if (mongoQueue.cbs_next.length) {
+                                                    mongoQueue.cbs = mongoQueue.cbs_next;
+                                                    mongoQueue.cbs_next = [];
+                                                }
+                                                else {
+                                                    mongoQueue.cbs = [];
+                                                }
+                                            }
+                                            else {
+                                                if (mongoQueue.invalidateCount >= 5) {
+                                                    mongoQueue.invalidateCount = 0;
+                                                    mongoQueue.cbs.forEach(function (cb) {
+                                                        cb(null, res, false);
+                                                    });
+                                                }
+                                                mongoQueue.cbs = mongoQueue.cbs.concat(mongoQueue.cbs_next);
+                                                mongoQueue.cbs_next = [];
+                                            }
+                                            mongoQueue.running = false;
+                                        }, function (err) {
+                                            monitor_2.finish();
+                                            mongoQueue.cbs.forEach(function (cb) {
+                                                cb(err, null, false);
+                                            });
+                                            mongoQueue.cbs_next.forEach(function (cb) {
+                                                cb(err, null, false);
+                                            });
+                                            if (_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id) >= 0) {
+                                                _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id), 1);
+                                            }
+                                        });
+                                    }
+                                }
+                            };
+                            for (var i = queueArr.length - 1; i >= 0; i--) {
+                                _loop_1(i);
+                            }
+                            _this._mongoQueueRunning = false;
+                        }
+                    }
+                }, 25);
+                return [2 /*return*/];
+            });
+        });
+    };
+    MongoManager.prototype.addToCache = function (id, data) {
+        var nodeCacheSize = this._nodeCache.getStats().vsize;
+        if (nodeCacheSize > this._heapLimit) {
+            var deleteCount = 0;
+            var queueArr = this._mongoQueue.filter(function (a) { return a.cacheId && !a.running && !a.cbs.length; });
+            for (var zz = queueArr.length - 1; zz >= 0; zz--) {
+                this._debugRemoveCacheHits += 1;
+                var queue = queueArr[zz];
+                this._nodeCache.del(queue.cacheId);
+                queue.cacheId = 0;
+                if (this._mongoQueue.map(function (a) { return a._id; }).indexOf(queue._id) >= 0) {
+                    this._mongoQueue.splice(this._mongoQueue.map(function (a) { return a._id; }).indexOf(queue._id), 1);
+                }
+                deleteCount += 1;
+                nodeCacheSize = this._nodeCache.getStats().vsize;
+                if (nodeCacheSize < this._heapLimit * 0.75) {
+                    break;
+                }
+            }
+            console.log('Query Cache: ' + 'Too Big, - Deleted: ' + deleteCount + ' - ' + nodeCacheSize);
+        }
+        this._nodeCache.set(id, JSON.stringify(data));
+    };
+    MongoManager.prototype.invalidateQueryCache = function (collection) {
+        var queueArr = this._mongoQueue.filter(function (a) { return (a.name_collection === collection || a.lookup_collections.includes(collection)); });
+        for (var i = queueArr.length - 1; i >= 0; i--) {
+            var queue = queueArr[i];
+            if (queue.cacheId) {
+                this._nodeCache.del(queue.cacheId);
+                queue.cacheId = 0;
+            }
+            if (queue.running) {
+                queue.invalidateFlag = true;
+                queue.invalidateCount += 1;
+            }
+            else if (!queue.cbs.length) {
+                if (this._mongoQueue.map(function (a) { return a._id; }).indexOf(queue._id) >= 0) {
+                    this._mongoQueue.splice(this._mongoQueue.map(function (a) { return a._id; }).indexOf(queue._id), 1);
+                }
+            }
+        }
+    };
+    return MongoManager;
+}());
+exports.MongoManager = MongoManager;
+var MongoManagerModel = /** @class */ (function () {
+    function MongoManagerModel(options) {
+        this.collection_main = null;
+        this.collection_version = null;
+        if (options.collectionName === 'users') {
+            this.collection_main = new MongoManagerUserCollection(options);
+        }
+        else {
+            this.collection_main = new MongoManagerCollection(options);
+        }
+        if (options.useVersionCollection) {
+            this.collection_main.useVersions = true;
+            var versionSchema = (0, common_1.deepCopy)(options.schema);
+            versionSchema._id.type = 'Object';
+            versionSchema._id.blackbox = true;
+            var versionOptions = {
+                collectionName: options.collectionName + '.versions',
+                schema: versionSchema,
+                useVersionCollection: false,
+                useReportBuilder: false,
+                reportBuilderLookupTables: [],
+                timestamps: true,
+                createLogs: false,
+                checkSchema: false,
+                collectionOptions: null
+            };
+            if (options.collectionName === 'users') {
+                this.collection_version = new MongoManagerUserCollection(versionOptions);
+            }
+            else {
+                this.collection_version = new MongoManagerCollection(versionOptions);
+            }
+            this.collection_version.createIndex({ '_id._id': 1, '_id.__v': 1 });
+            this.collection_main.versionCollection = options.collectionName + '.versions';
+        }
+    }
+    return MongoManagerModel;
+}());
+exports.MongoManagerModel = MongoManagerModel;
+var MongoManagerCollection = /** @class */ (function () {
+    function MongoManagerCollection(options) {
+        var _this = this;
+        this.collectionName = '';
+        this.checkSchema = false;
+        this.simplschema = null;
+        this.rbSchema = null;
+        this.timestamps = false;
+        this.useVersions = false;
+        this.versionCollection = '';
+        this.createLogs = true;
+        this.useRB = false;
+        this.collectionName = options.collectionName;
+        this.simplschema = new simpl_schema_1.default(options.schema);
+        this.timestamps = options.timestamps;
+        this.createLogs = options.createLogs;
+        this.checkSchema = options.checkSchema;
+        this.collectionOptions = options.collectionOptions;
+        if (options.useReportBuilder) {
+            this.useRB = true;
+            var schemaCopy = (0, common_1.deepCopy)(options.schema);
+            var rbSchema = (0, common_1.buildRbLookups)(options.reportBuilderLookupTables, schemaCopy, []);
+            this.rbSchema = (0, common_1.buildRbSchema)(rbSchema);
+        }
+        var interval = setInterval(function () {
+            if (index_1.ResolveIOServer && index_1.ResolveIOServer.getMainServer() && index_1.ResolveIOServer.getMongoManager() && index_1.ResolveIOServer.getMongoManager().getServerCollections().length) {
+                index_1.ResolveIOServer.getMongoManager().registerCollection(_this);
+                clearInterval(interval);
+            }
+        }, 1);
+    }
+    MongoManagerCollection.prototype.aggregate = function (pipeline, options, skipCache) {
+        var _this = this;
+        if (skipCache === void 0) { skipCache = false; }
+        return new Promise(function (resolve, reject) {
+            // if (!skipCache) {
+            // 	ResolveIOServer.getMongoManager().addToQueue({
+            // 		_id: 0,
+            // 		name_collection: this.collectionName,
+            // 		name_function: 'aggregate',
+            // 		name_function_addt: 'toArray',
+            // 		data_function: [pipeline, options],
+            // 		data_function_addt: [],
+            // 		cbs: [(err, res, cached) => {
+            // 			if (err) {
+            // 				reject(err);
+            // 			}
+            // 			else {
+            // 				resolve(res);
+            // 			}
+            // 		}],
+            // 		cbs_next: [],
+            // 		running: false,
+            // 		cacheId: 0,
+            // 		lookup_collections: pipeline.filter(a => a['$lookup'] && a['$lookup'].from).map(a => a['$lookup'].from).filter((elem, index, self) => {
+            // 			return index === self.indexOf(elem);
+            // 		}),
+            // 		invalidateFlag: false,
+            // 		invalidateCount: 0
+            // 	});
+            // }
+            // else {
+            // 	let monitor = new MonitorMongo('aggregate', this.collectionName, JSON.stringify([pipeline, options]));
+            // 	ResolveIOServer.getMainDB().collection<T>(this.collectionName, this.collectionOptions).aggregate(pipeline, options).toArray().then(res => {
+            // 		monitor.finish();
+            // 		resolve(res);
+            // 	}, err => {
+            // 		monitor.finish();
+            // 		console.log(new Date(), 'Error Aggregate', this.collectionName, pipeline, options, err);
+            // 		reject(err);
+            // 	});
+            // }
+            var monitor = new monitor_manager_1.MonitorMongo('aggregate', _this.collectionName, JSON.stringify([pipeline, options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).aggregate(pipeline, options).toArray().then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Aggregate', _this.collectionName, pipeline, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.aggregateCount = function (pipeline, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            index_1.ResolveIOServer.getMongoManager().addToQueue({
+                _id: 0,
+                name_collection: _this.collectionName,
+                name_function: 'aggregate',
+                name_function_addt: 'count',
+                data_function: [pipeline, options],
+                data_function_addt: [],
+                cbs: [function (err, res, cached) {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(res);
+                        }
+                    }],
+                cbs_next: [],
+                running: false,
+                cacheId: 0,
+                lookup_collections: pipeline.filter(function (a) { return a['$lookup'] && a['$lookup'].from; }).map(function (a) { return a['$lookup'].from; }).filter(function (elem, index, self) {
+                    return index === self.indexOf(elem);
+                }),
+                invalidateFlag: false,
+                invalidateCount: 0
+            });
+        });
+    };
+    MongoManagerCollection.prototype.aggregateCursor = function (pipeline, options) {
+        var monitor = new monitor_manager_1.MonitorMongo('aggregateCursor', this.collectionName, JSON.stringify([pipeline, options]));
+        var cursor = index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).aggregate(pipeline, options);
+        cursor.on('close', function (ev) {
+            monitor.finish();
+            return ev;
+        });
+        return cursor;
+    };
+    MongoManagerCollection.prototype.aggregateStream = function (pipeline, options, streamOptions) {
+        var monitor = new monitor_manager_1.MonitorMongo('aggregateStream', this.collectionName, JSON.stringify([pipeline, options, streamOptions]));
+        var stream = index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).aggregate(pipeline, options).stream(streamOptions);
+        stream.on('end', function (ev) {
+            monitor.finish();
+            return ev;
+        });
+        return stream;
+    };
+    // bulkWrite(operations: AnyBulkWriteOperation<T>[], options: BulkWriteOptions): Promise<BulkWriteResult> {
+    MongoManagerCollection.prototype.bulkWrite = function (operations, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('bulkWrite', _this.collectionName, JSON.stringify([operations.slice(-100), options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).bulkWrite(operations, options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Bulk Write', _this.collectionName, operations.slice(-100), options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.countDocuments = function (filter, options) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('countDocuments', _this.collectionName, JSON.stringify([filter, options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).countDocuments(filter, options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Count Documents', _this.collectionName, filter, options, err);
+                reject(err);
+            });
+        });
+    };
+    //Helper Function (1 or Many) - Not Real Mongo Function
+    MongoManagerCollection.prototype.create = function (f_docs, options) {
+        if (!Array.isArray(f_docs)) {
+            return this.insertOne(f_docs, options);
+        }
+        else if (f_docs.length === 1) {
+            return this.insertOne(f_docs[0], options);
+        }
+        return this.insertMany(f_docs, options);
+    };
+    MongoManagerCollection.prototype.createIndex = function (fieldOrSpec, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions)) {
+                var monitor_3 = new monitor_manager_1.MonitorMongo('createIndex', _this.collectionName, JSON.stringify([fieldOrSpec, options]));
+                index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).createIndex(fieldOrSpec, options).then(function (res) {
+                    monitor_3.finish();
+                    resolve(res);
+                }, function (err) {
+                    monitor_3.finish();
+                    console.log(new Date(), 'Error Setting Up Index for Collection', _this.collectionName, fieldOrSpec, options, err);
+                    reject(err);
+                });
+            }
+        });
+    };
+    MongoManagerCollection.prototype.createIndexes = function (indexSpecs, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions)) {
+                var monitor_4 = new monitor_manager_1.MonitorMongo('createIndexes', _this.collectionName, JSON.stringify([indexSpecs, options]));
+                index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).createIndexes(indexSpecs, options).then(function (res) {
+                    monitor_4.finish();
+                    resolve(res);
+                }, function (err) {
+                    monitor_4.finish();
+                    console.log(new Date(), 'Error Setting Up Indexes for Collection', _this.collectionName, indexSpecs, options, err);
+                    reject(err);
+                });
+            }
+        });
+    };
+    MongoManagerCollection.prototype.deleteMany = function (filter, options, bypassLogs) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var docs, i, doc, versionDoc, monitor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.createLogs && !bypassLogs)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.find(filter)];
+                    case 1:
+                        docs = _a.sent();
+                        for (i = 0; i < docs.length; i++) {
+                            doc = docs[i];
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: this.collectionName,
+                                id_document: doc._id,
+                                payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
+                                method: 'deleteMany',
+                                id_user: '',
+                                user: '',
+                                messageId: 0,
+                                route: ''
+                            });
+                            if (this.useVersions) {
+                                versionDoc = (0, common_1.deepCopy)(doc);
+                                versionDoc._id = { _id: doc._id, __v: doc.__v };
+                                index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne({ _id: { _id: doc._id, __v: doc.__v } }, versionDoc, { upsert: true });
+                                index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [{ '_id._id': doc._id }, { '_id.__v': { $lt: doc.__v - 1 } }] });
+                            }
+                        }
+                        _a.label = 2;
+                    case 2:
+                        monitor = new monitor_manager_1.MonitorMongo('deleteMany', this.collectionName, JSON.stringify([filter, options]));
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).deleteMany(filter, options).then(function (res) {
+                            monitor.finish();
+                            if (res.acknowledged) {
+                                index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                resolve(res.deletedCount);
+                            }
+                            else {
+                                reject(res.acknowledged);
+                            }
+                        }, function (err) {
+                            monitor.finish();
+                            console.log(new Date(), 'Error Delete Many', _this.collectionName, filter, options, err);
+                            reject(err);
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.deleteOne = function (filter, options, bypassLogs) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var monitor_5, monitor_6;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (this.createLogs && !bypassLogs) {
+                    monitor_5 = new monitor_manager_1.MonitorMongo('findOneAndDelete', this.collectionName, JSON.stringify([filter, options]));
+                    index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).findOneAndDelete(filter, options).then(function (returnVal) { return __awaiter(_this, void 0, void 0, function () {
+                        var doc, versionDoc;
+                        return __generator(this, function (_a) {
+                            monitor_5.finish();
+                            doc = returnVal.value;
+                            if (doc) {
+                                if (this.createLogs && !bypassLogs) {
+                                    log_collection_1.Logs.insertOne({
+                                        _id: objectIdHexString(),
+                                        type: 'document',
+                                        collection: this.collectionName,
+                                        id_document: doc._id,
+                                        payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
+                                        method: 'deleteOne',
+                                        id_user: '',
+                                        user: '',
+                                        messageId: 0,
+                                        route: ''
+                                    });
+                                }
+                                if (this.useVersions) {
+                                    versionDoc = (0, common_1.deepCopy)(doc);
+                                    versionDoc._id = { _id: doc._id, __v: doc.__v };
+                                    index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne({ _id: { _id: doc._id, __v: doc.__v } }, versionDoc, { upsert: true });
+                                    index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [{ '_id._id': doc._id }, { '_id.__v': { $lt: doc.__v - 1 } }] });
+                                }
+                                index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(this.collectionName);
+                                resolve(1);
+                            }
+                            else {
+                                resolve(0);
+                            }
+                            return [2 /*return*/];
+                        });
+                    }); }, function (err) {
+                        monitor_5.finish();
+                        console.log(new Date(), 'Error Find One And Delete', _this.collectionName, filter, options, err);
+                        reject(err);
+                    });
+                }
+                else {
+                    monitor_6 = new monitor_manager_1.MonitorMongo('deleteOne', this.collectionName, JSON.stringify([filter, options]));
+                    index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).deleteOne(filter, options).then(function (res) {
+                        monitor_6.finish();
+                        if (res.acknowledged) {
+                            index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                            resolve(res.deletedCount);
+                        }
+                        else {
+                            reject(res.acknowledged);
+                        }
+                    }, function (err) {
+                        monitor_6.finish();
+                        console.log(new Date(), 'Error Delete One', _this.collectionName, filter, options, err);
+                        reject(err);
+                    });
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.distinct = function (key, filter, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('distinct', _this.collectionName, JSON.stringify([key, filter, options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).distinct(key, filter, options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Distinct', _this.collectionName, filter, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.drop = function (options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('drop', _this.collectionName, JSON.stringify([options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).drop(options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Count Documents', _this.collectionName, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.dropIndex = function (indexName, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('dropIndex', _this.collectionName, JSON.stringify([indexName, options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).dropIndex(indexName, options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Drop Index', _this.collectionName, indexName, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.dropIndexes = function (options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('dropIndexes', _this.collectionName, JSON.stringify([options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).dropIndexes(options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Drop Indexes', _this.collectionName, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.find = function (filter, options, skipCache) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (skipCache === void 0) { skipCache = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var monitor_7;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!skipCache) {
+                    index_1.ResolveIOServer.getMongoManager().addToQueue({
+                        _id: 0,
+                        name_collection: this.collectionName,
+                        name_function: 'find',
+                        name_function_addt: 'toArray',
+                        data_function: [filter, options],
+                        data_function_addt: [],
+                        cbs: [function (err, res, cached) {
+                                if (err) {
+                                    reject(err);
+                                }
+                                else {
+                                    resolve(res);
+                                }
+                            }],
+                        cbs_next: [],
+                        running: false,
+                        cacheId: 0,
+                        lookup_collections: [],
+                        invalidateFlag: false,
+                        invalidateCount: 0
+                    });
+                }
+                else {
+                    monitor_7 = new monitor_manager_1.MonitorMongo('find', this.collectionName, JSON.stringify([filter, options]));
+                    index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).find(filter, options).toArray().then(function (res) {
+                        monitor_7.finish();
+                        resolve(res);
+                    }, function (err) {
+                        monitor_7.finish();
+                        console.log(new Date(), 'Error Find', _this.collectionName, filter, options, err);
+                        reject(err);
+                    });
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.findById = function (id, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('findById', _this.collectionName, JSON.stringify([{ _id: id }, options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).findOne({ _id: id }, options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Find By Id', _this.collectionName, { _id: id }, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.findCount = function (filter, options) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('findCount', _this.collectionName, JSON.stringify([filter, options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).find(filter, options).count().then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Find Count', _this.collectionName, filter, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.findCursor = function (filter, options) {
+        if (filter === void 0) { filter = {}; }
+        var monitor = new monitor_manager_1.MonitorMongo('findCursor', this.collectionName, JSON.stringify([filter, options]));
+        var cursor = index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).find(filter, options);
+        cursor.on('close', function (ev) {
+            monitor.finish();
+            return ev;
+        });
+        return cursor;
+    };
+    MongoManagerCollection.prototype.findStream = function (filter, options, streamOptions) {
+        if (filter === void 0) { filter = {}; }
+        var monitor = new monitor_manager_1.MonitorMongo('findStream', this.collectionName, JSON.stringify([filter, options, streamOptions]));
+        var stream = index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).find(filter, options).stream(streamOptions);
+        stream.on('end', function (ev) {
+            monitor.finish();
+            return ev;
+        });
+        return stream;
+    };
+    MongoManagerCollection.prototype.findOne = function (filter, options, skipCache) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (skipCache === void 0) { skipCache = false; }
+        return new Promise(function (resolve, reject) {
+            if (!skipCache) {
+                index_1.ResolveIOServer.getMongoManager().addToQueue({
+                    _id: 0,
+                    name_collection: _this.collectionName,
+                    name_function: 'findOne',
+                    name_function_addt: '',
+                    data_function: [filter, options],
+                    data_function_addt: [],
+                    cbs: [function (err, res, cached) {
+                            if (err) {
+                                reject(err);
+                            }
+                            else {
+                                resolve(res);
+                            }
+                        }],
+                    cbs_next: [],
+                    running: false,
+                    cacheId: 0,
+                    lookup_collections: [],
+                    invalidateFlag: false,
+                    invalidateCount: 0
+                });
+            }
+            else {
+                var monitor_8 = new monitor_manager_1.MonitorMongo('findOne', _this.collectionName, JSON.stringify([filter, options]));
+                index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).findOne(filter, options).then(function (res) {
+                    monitor_8.finish();
+                    resolve(res);
+                }, function (err) {
+                    monitor_8.finish();
+                    console.log(new Date(), 'Error Find One', _this.collectionName, filter, options, err);
+                    reject(err);
+                });
+            }
+        });
+    };
+    MongoManagerCollection.prototype.findOneAndDelete = function (filter, options, bypassLogs) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var monitor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                monitor = new monitor_manager_1.MonitorMongo('findOneAndDelete', this.collectionName, JSON.stringify([filter, options]));
+                index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).findOneAndDelete(filter, options).then(function (res) {
+                    monitor.finish();
+                    var doc = res.value;
+                    if (doc) {
+                        if (_this.createLogs && !bypassLogs) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: _this.collectionName,
+                                id_document: doc._id,
+                                payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
+                                method: 'findOneAndDelete',
+                                id_user: '',
+                                user: '',
+                                messageId: 0,
+                                route: ''
+                            });
+                        }
+                        if (_this.useVersions) {
+                            var versionDoc = (0, common_1.deepCopy)(doc);
+                            versionDoc._id = { _id: doc._id, __v: doc.__v };
+                            index_1.ResolveIOServer.getMongoManager().collection(_this.versionCollection).replaceOne({ _id: { _id: doc._id, __v: doc.__v } }, versionDoc, { upsert: true });
+                        }
+                        index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                        resolve(doc);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }, function (err) {
+                    monitor.finish();
+                    console.log(new Date(), 'Error Find One And Delete', _this.collectionName, filter, options, err);
+                    reject(err);
+                });
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.findOneAndReplace = function (filter, replacement, options, bypassLogs, bypassCheckSchema) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        if (bypassCheckSchema === void 0) { bypassCheckSchema = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, isValid, date, monitor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (this.checkSchema && !bypassCheckSchema) {
+                    validation = this.simplschema.newContext();
+                    isValid = validation.validate(replacement);
+                    if (!isValid) {
+                        console.log(new Date(), this.collectionName, 'Schema Errors - findOneAndReplace', validation.validationErrors());
+                        index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(index_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on findOneAndReplace - ' + this.collectionName, [validation.validationErrors(), replacement]);
+                        reject(validation.validationErrors());
+                        return [2 /*return*/];
+                    }
+                }
+                date = new Date();
+                if (this.timestamps) {
+                    replacement.updatedAt = date;
+                }
+                if (options && options.upsert) {
+                    if (!replacement._id) {
+                        replacement._id = objectIdHexString();
+                    }
+                    if (this.useVersions) {
+                        replacement.__v = 0;
+                    }
+                    if (this.timestamps && !replacement.createdAt) {
+                        replacement.createdAt = date;
+                    }
+                }
+                monitor = new monitor_manager_1.MonitorMongo('findOneAndReplace', this.collectionName, JSON.stringify([filter, replacement, options]));
+                index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).findOneAndReplace(filter, replacement, options).then(function (res) {
+                    monitor.finish();
+                    var doc = res.value;
+                    if (doc) {
+                        if (_this.createLogs && !bypassLogs) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: _this.collectionName,
+                                id_document: doc._id,
+                                payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
+                                method: 'findOneAndReplace',
+                                id_user: '',
+                                user: '',
+                                messageId: 0,
+                                route: ''
+                            });
+                        }
+                        if (_this.useVersions) {
+                            var versionDoc = (0, common_1.deepCopy)(doc);
+                            versionDoc._id = { _id: doc._id, __v: doc.__v };
+                            index_1.ResolveIOServer.getMongoManager().collection(_this.versionCollection).replaceOne({ _id: { _id: doc._id, __v: doc.__v } }, versionDoc, { upsert: true });
+                        }
+                        index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                        resolve(doc);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }, function (err) {
+                    monitor.finish();
+                    console.log(new Date(), 'Error Find One And Replace', _this.collectionName, filter, options, err);
+                    reject(err);
+                });
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.findOneAndUpdate = function (filter, update, options, bypassLogs, bypassCheckSchema) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        if (bypassCheckSchema === void 0) { bypassCheckSchema = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, isValid, date, monitor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (this.checkSchema && !bypassCheckSchema) {
+                    validation = this.simplschema.newContext();
+                    isValid = validation.validate(update, { modifier: true });
+                    if (!isValid) {
+                        console.log(new Date(), this.collectionName, 'Schema Errors - findOneAndUpdate', validation.validationErrors());
+                        index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(index_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on findOneAndUpdate - ' + this.collectionName, [validation.validationErrors(), update]);
+                        reject(validation.validationErrors());
+                        return [2 /*return*/];
+                    }
+                }
+                if (this.timestamps) {
+                    date = new Date();
+                    if (!update.$set) {
+                        update.$set = { updatedAt: date };
+                    }
+                    else {
+                        update.$set.updatedAt = date;
+                    }
+                }
+                if (options && options.upsert) {
+                    if (!update.$setOnInsert) {
+                        if (this.timestamps) {
+                            update.$setOnInsert = {
+                                _id: objectIdHexString(),
+                                createdAt: new Date()
+                            };
+                        }
+                        else {
+                            update.$setOnInsert = {
+                                _id: objectIdHexString()
+                            };
+                        }
+                    }
+                    else {
+                        if (!update.$setOnInsert._id) {
+                            update.$setOnInsert._id = objectIdHexString();
+                        }
+                        if (this.timestamps) {
+                            update.$setOnInsert.createdAt = new Date();
+                        }
+                    }
+                }
+                monitor = new monitor_manager_1.MonitorMongo('findOneAndUpdate', this.collectionName, JSON.stringify([filter, update, options]));
+                index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).findOneAndUpdate(filter, update, options).then(function (res) {
+                    monitor.finish();
+                    var doc = res.value;
+                    if (doc) {
+                        if (_this.createLogs && !bypassLogs) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: _this.collectionName,
+                                id_document: doc._id,
+                                payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
+                                method: 'findOneAndUpdate',
+                                id_user: '',
+                                user: '',
+                                messageId: 0,
+                                route: ''
+                            });
+                        }
+                        if (_this.useVersions) {
+                            var versionDoc = (0, common_1.deepCopy)(doc);
+                            versionDoc._id = { _id: doc._id, __v: doc.__v };
+                            index_1.ResolveIOServer.getMongoManager().collection(_this.versionCollection).replaceOne({ _id: { _id: doc._id, __v: doc.__v } }, versionDoc, { upsert: true });
+                        }
+                        index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                        resolve(doc);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }, function (err) {
+                    monitor.finish();
+                    console.log(new Date(), 'Error Find One And Update', _this.collectionName, filter, options, err);
+                    reject(err);
+                });
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.indexes = function (options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('indexes', _this.collectionName, JSON.stringify([options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).indexes(options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Indexes', _this.collectionName, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.indexExists = function (indexes, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('indexExists', _this.collectionName, JSON.stringify([indexes, options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).indexExists(indexes, options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Index Exists', _this.collectionName, indexes, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.insertMany = function (docs, options, bypassLogs, bypassCheckSchema, bypassMonitor) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        if (bypassCheckSchema === void 0) { bypassCheckSchema = false; }
+        if (bypassMonitor === void 0) { bypassMonitor = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validationResults, validDocs, i, doc, date, monitor_9;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!docs.length) {
+                    resolve([]);
+                    return [2 /*return*/];
+                }
+                validationResults = [];
+                if (this.checkSchema && !bypassCheckSchema) {
+                    docs.forEach(function (doc) {
+                        var validation = _this.simplschema.newContext();
+                        var isValid = validation.validate(doc);
+                        if (!isValid) {
+                            console.log(new Date(), _this.collectionName, 'Schema Errors - insertMany', validation.validationErrors());
+                            index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(index_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on insertMany - ' + _this.collectionName, [validation.validationErrors(), doc]);
+                            validationResults.push(false);
+                        }
+                        else {
+                            validationResults.push(true);
+                        }
+                    });
+                }
+                validDocs = this.checkSchema ? docs.filter(function (a, idx) { return validationResults[idx]; }) : docs;
+                for (i = 0; i < validDocs.length; i++) {
+                    doc = validDocs[i];
+                    if (!doc._id) {
+                        doc._id = objectIdHexString();
+                    }
+                    if (this.timestamps) {
+                        date = new Date();
+                        doc.createdAt = date;
+                        doc.updatedAt = date;
+                    }
+                    if (this.createLogs && !bypassLogs) {
+                        log_collection_1.Logs.insertOne({
+                            _id: objectIdHexString(),
+                            type: 'document',
+                            collection: this.collectionName,
+                            id_document: doc._id,
+                            payload: (0, common_1.getBinarySize)(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
+                            method: 'insertMany',
+                            id_user: '',
+                            user: '',
+                            messageId: 0,
+                            route: ''
+                        });
+                    }
+                }
+                if (validDocs.length) {
+                    monitor_9 = null;
+                    if (!bypassMonitor) {
+                        monitor_9 = new monitor_manager_1.MonitorMongo('insertMany', this.collectionName, JSON.stringify([validDocs, options]));
+                    }
+                    index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).insertMany(validDocs, options).then(function (res) {
+                        if (monitor_9) {
+                            monitor_9.finish();
+                        }
+                        if (res.acknowledged) {
+                            index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                            resolve(validDocs);
+                        }
+                        else {
+                            reject(res.acknowledged);
+                        }
+                    }, function (err) {
+                        if (monitor_9) {
+                            monitor_9.finish();
+                        }
+                        console.log(new Date(), 'Error Insert Many', _this.collectionName, validDocs, options, err);
+                        reject(err);
+                    });
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.insertOne = function (doc, options, bypassLogs, bypassCheckSchema) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        if (bypassCheckSchema === void 0) { bypassCheckSchema = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, isValid, date, monitor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!doc._id) {
+                    doc._id = objectIdHexString();
+                }
+                if (this.checkSchema && !bypassCheckSchema) {
+                    validation = this.simplschema.newContext();
+                    isValid = validation.validate(doc);
+                    if (!isValid) {
+                        console.log(new Date(), this.collectionName, 'Schema Errors - insertOne', validation.validationErrors());
+                        index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(index_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on insertOne - ' + this.collectionName, [validation.validationErrors(), doc]);
+                        reject(validation.validationErrors());
+                        return [2 /*return*/];
+                    }
+                }
+                if (this.timestamps) {
+                    date = new Date();
+                    doc.createdAt = date;
+                    doc.updatedAt = date;
+                }
+                if (this.createLogs && !bypassLogs) {
+                    log_collection_1.Logs.insertOne({
+                        _id: objectIdHexString(),
+                        type: 'document',
+                        collection: this.collectionName,
+                        id_document: doc._id,
+                        payload: (0, common_1.getBinarySize)(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
+                        method: 'insertOne',
+                        id_user: '',
+                        user: '',
+                        messageId: 0,
+                        route: ''
+                    });
+                }
+                if (this.useVersions && !doc.hasOwnProperty('__v')) {
+                    doc.__v = 0;
+                }
+                monitor = new monitor_manager_1.MonitorMongo('insertOne', this.collectionName, JSON.stringify([doc, options]));
+                index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).insertOne(doc, options).then(function (res) {
+                    monitor.finish();
+                    if (res.acknowledged) {
+                        index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                        resolve(doc);
+                    }
+                    else {
+                        reject(res.acknowledged);
+                    }
+                }, function (err) {
+                    monitor.finish();
+                    console.log(new Date(), 'Error Insert One', _this.collectionName, doc, options, err);
+                    reject(err);
+                });
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.listIndexes = function (options) {
+        var monitor = new monitor_manager_1.MonitorMongo('listIndexes', this.collectionName, JSON.stringify([options]));
+        var cursor = index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).listIndexes(options);
+        cursor.on('close', function (ev) {
+            monitor.finish();
+            return ev;
+        });
+        return cursor;
+    };
+    MongoManagerCollection.prototype.rename = function (newName, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('rename', _this.collectionName, JSON.stringify([newName, options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).rename(newName, options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Rename', _this.collectionName, newName, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.replaceOne = function (filter, replacement, options, bypassLogs, bypassCheckSchema, doc) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        if (bypassCheckSchema === void 0) { bypassCheckSchema = false; }
+        if (doc === void 0) { doc = null; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, isValid, date, versionDoc, monitor_10, prevDoc, docId, docVersion, updatedDoc_1, monitor_11, monitor_12, monitor_13, monitor_14;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.checkSchema && !bypassCheckSchema) {
+                            validation = this.simplschema.newContext();
+                            isValid = validation.validate(replacement);
+                            if (!isValid) {
+                                console.log(new Date(), this.collectionName, 'Schema Errors - replaceOne', validation.validationErrors());
+                                index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(index_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on replaceOne - ' + this.collectionName, [validation.validationErrors(), replacement]);
+                                reject(validation.validationErrors());
+                                return [2 /*return*/];
+                            }
+                        }
+                        date = new Date();
+                        if (this.timestamps) {
+                            replacement.updatedAt = date;
+                        }
+                        if (!this.useVersions) return [3 /*break*/, 8];
+                        if (!!doc) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.findOne(filter, null, true)];
+                    case 1:
+                        doc = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!doc) return [3 /*break*/, 6];
+                        if (this.timestamps && !replacement.createdAt && doc.createdAt) {
+                            replacement.createdAt = doc.createdAt;
+                        }
+                        if (!(doc.__v === replacement.__v)) return [3 /*break*/, 3];
+                        replacement.__v += 1;
+                        versionDoc = (0, common_1.deepCopy)(doc);
+                        versionDoc._id = { _id: doc._id, __v: doc.__v };
+                        index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne({ _id: { _id: doc._id, __v: doc.__v } }, versionDoc, { upsert: true });
+                        if (doc.__v >= 4) {
+                            index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [{ '_id._id': doc._id }, { '_id.__v': { $lt: doc.__v - 4 } }] });
+                        }
+                        if (this.createLogs && !bypassLogs) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: this.collectionName,
+                                id_document: doc._id,
+                                payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
+                                method: 'replaceOne',
+                                id_user: '',
+                                user: '',
+                                messageId: 0,
+                                route: ''
+                            });
+                        }
+                        monitor_10 = new monitor_manager_1.MonitorMongo('replaceOne', this.collectionName, JSON.stringify([filter, replacement, options]));
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).replaceOne(filter, replacement, options).then(function (res) {
+                            monitor_10.finish();
+                            if (res.acknowledged) {
+                                index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                resolve(res.modifiedCount);
+                            }
+                            else {
+                                reject(res.acknowledged);
+                            }
+                        }, function (err) {
+                            monitor_10.finish();
+                            console.log(new Date(), 'Error Replace One', _this.collectionName, filter, replacement, options, err);
+                            reject(err);
+                        });
+                        return [3 /*break*/, 5];
+                    case 3:
+                        console.log('invalid version - ' + this.collectionName, doc.__v, replacement.__v);
+                        return [4 /*yield*/, index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).findOne({
+                                _id: {
+                                    _id: doc._id,
+                                    __v: replacement.__v
+                                }
+                            }, null, true)];
+                    case 4:
+                        prevDoc = _a.sent();
+                        if (prevDoc) {
+                            docId = doc._id;
+                            docVersion = doc.__v;
+                            updatedDoc_1 = (0, common_1.getMongoMergeUpdatedDoc)(replacement, doc, prevDoc);
+                            updatedDoc_1._id = docId;
+                            updatedDoc_1.__v = docVersion + 1;
+                            if (this.createLogs && !bypassLogs) {
+                                log_collection_1.Logs.insertOne({
+                                    _id: objectIdHexString(),
+                                    type: 'document',
+                                    collection: this.collectionName,
+                                    id_document: docId,
+                                    payload: (0, common_1.getBinarySize)(JSON.stringify(['invalidVersion - merge', doc, filter, updatedDoc_1, options])) < 200000 ? JSON.stringify(['invalidVersion - merge', doc, filter, updatedDoc_1, options], null, 2) : 'Too Big',
+                                    method: 'replaceOne',
+                                    id_user: '',
+                                    user: '',
+                                    messageId: 0,
+                                    route: ''
+                                });
+                            }
+                            monitor_11 = new monitor_manager_1.MonitorMongo('replaceOne', this.collectionName, JSON.stringify([filter, updatedDoc_1, options]));
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).replaceOne(filter, updatedDoc_1, options).then(function (res) {
+                                monitor_11.finish();
+                                if (res.acknowledged) {
+                                    index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                    resolve(res.modifiedCount);
+                                }
+                                else {
+                                    reject(res.acknowledged);
+                                }
+                            }, function (err) {
+                                monitor_11.finish();
+                                console.log(new Date(), 'Error Replace One', _this.collectionName, filter, updatedDoc_1, options, err);
+                                reject(err);
+                            });
+                        }
+                        else {
+                            reject('Invalid Version And Could Not Find History - DB: ' + doc.__v + ', Trying to update with :' + replacement.__v);
+                        }
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        if (options && options.upsert) {
+                            if (this.timestamps) {
+                                replacement.createdAt = date;
+                            }
+                            if (!replacement._id) {
+                                replacement._id = objectIdHexString();
+                            }
+                            replacement.__v = 0;
+                            if (this.createLogs && !bypassLogs) {
+                                log_collection_1.Logs.insertOne({
+                                    _id: objectIdHexString(),
+                                    type: 'document',
+                                    collection: this.collectionName,
+                                    id_document: replacement._id,
+                                    payload: (0, common_1.getBinarySize)(JSON.stringify(['upsert', filter, replacement, options])) < 200000 ? JSON.stringify(['upsert', filter, replacement, options], null, 2) : 'Too Big',
+                                    method: 'replaceOne',
+                                    id_user: '',
+                                    user: '',
+                                    messageId: 0,
+                                    route: ''
+                                });
+                            }
+                            monitor_12 = new monitor_manager_1.MonitorMongo('replaceOne', this.collectionName, JSON.stringify([filter, replacement, options]));
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).replaceOne(filter, replacement, options).then(function (res) {
+                                monitor_12.finish();
+                                if (res.acknowledged) {
+                                    index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                    resolve(res.modifiedCount);
+                                }
+                                else {
+                                    reject(res.acknowledged);
+                                }
+                            }, function (err) {
+                                monitor_12.finish();
+                                console.log(new Date(), 'Error Replace One', _this.collectionName, filter, replacement, options, err);
+                                reject(err);
+                            });
+                        }
+                        else {
+                            reject('No Document');
+                        }
+                        _a.label = 7;
+                    case 7: return [3 /*break*/, 9];
+                    case 8:
+                        if (options && options.upsert) {
+                            if (this.timestamps && !replacement.createdAt) {
+                                replacement.createdAt = date;
+                            }
+                            if (!replacement._id) {
+                                replacement._id = objectIdHexString();
+                            }
+                            replacement.__v = 0;
+                        }
+                        if (this.createLogs && !bypassLogs) {
+                            if (!options) {
+                                options = { returnDocument: 'before' };
+                            }
+                            else {
+                                options.returnDocument = 'before';
+                            }
+                            monitor_13 = new monitor_manager_1.MonitorMongo('findOneAndReplace', this.collectionName, JSON.stringify([filter, replacement, options]));
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).findOneAndReplace(filter, replacement, options).then(function (res) {
+                                monitor_13.finish();
+                                var doc = res.value;
+                                if (doc) {
+                                    log_collection_1.Logs.insertOne({
+                                        _id: objectIdHexString(),
+                                        type: 'document',
+                                        collection: _this.collectionName,
+                                        id_document: doc._id,
+                                        payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
+                                        method: 'replaceOne',
+                                        id_user: '',
+                                        user: '',
+                                        messageId: 0,
+                                        route: ''
+                                    });
+                                }
+                                else {
+                                    log_collection_1.Logs.insertOne({
+                                        _id: objectIdHexString(),
+                                        type: 'document',
+                                        collection: _this.collectionName,
+                                        id_document: replacement._id,
+                                        payload: (0, common_1.getBinarySize)(JSON.stringify(['upsert', filter, replacement, options])) < 200000 ? JSON.stringify(['upsert', filter, replacement, options], null, 2) : 'Too Big',
+                                        method: 'replaceOne',
+                                        id_user: '',
+                                        user: '',
+                                        messageId: 0,
+                                        route: ''
+                                    });
+                                }
+                                index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                resolve(res.ok);
+                            }, function (err) {
+                                monitor_13.finish();
+                                console.log(new Date(), 'Error Find One And Replace', _this.collectionName, filter, replacement, options, err);
+                                reject(err);
+                            });
+                        }
+                        else {
+                            monitor_14 = new monitor_manager_1.MonitorMongo('replaceOne', this.collectionName, JSON.stringify([filter, replacement, options]));
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).replaceOne(filter, replacement, options).then(function (res) {
+                                monitor_14.finish();
+                                if (res.acknowledged) {
+                                    index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                    resolve(res.modifiedCount);
+                                }
+                                else {
+                                    reject(res.acknowledged);
+                                }
+                            }, function (err) {
+                                monitor_14.finish();
+                                console.log(new Date(), 'Error Replace One', _this.collectionName, filter, replacement, options, err);
+                                reject(err);
+                            });
+                        }
+                        _a.label = 9;
+                    case 9: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.stats = function (options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var monitor = new monitor_manager_1.MonitorMongo('stats', _this.collectionName, JSON.stringify([options]));
+            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName, _this.collectionOptions).stats(options).then(function (res) {
+                monitor.finish();
+                resolve(res);
+            }, function (err) {
+                monitor.finish();
+                console.log(new Date(), 'Error Stats', _this.collectionName, options, err);
+                reject(err);
+            });
+        });
+    };
+    MongoManagerCollection.prototype.updateMany = function (filter, update, options, bypassLogs, bypassCheckSchema, bypassVersions) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        if (bypassCheckSchema === void 0) { bypassCheckSchema = false; }
+        if (bypassVersions === void 0) { bypassVersions = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var date, validation, isValid, docs, i, doc, versionDoc, monitor;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if ((!update.$inc || JSON.stringify(update.$inc) === '{}') && (!update.$set || JSON.stringify(update.$set) === '{}') && (!update.$setOnInsert || JSON.stringify(update.$setOnInsert) === '{}') && (!update.$unset || JSON.stringify(update.$unset) === '{}')) {
+                            resolve(1);
+                            return [2 /*return*/];
+                        }
+                        if (this.timestamps) {
+                            date = new Date();
+                            if (!update.$set) {
+                                update.$set = { updatedAt: date };
+                            }
+                            else {
+                                update.$set.updatedAt = date;
+                            }
+                        }
+                        if (this.checkSchema && !bypassCheckSchema) {
+                            validation = this.simplschema.newContext();
+                            isValid = validation.validate(update, { modifier: true });
+                            if (!isValid) {
+                                console.log(new Date(), this.collectionName, 'Schema Errors - updateMany', validation.validationErrors());
+                                index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(index_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on updateMany - ' + this.collectionName, [validation.validationErrors(), update]);
+                                reject(validation.validationErrors());
+                                return [2 /*return*/];
+                            }
+                        }
+                        if (!((this.useVersions && !bypassVersions) || (this.createLogs && !bypassLogs))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.find(filter)];
+                    case 1:
+                        docs = _a.sent();
+                        for (i = 0; i < docs.length; i++) {
+                            doc = docs[i];
+                            if (this.createLogs && !bypassLogs) {
+                                log_collection_1.Logs.insertOne({
+                                    _id: objectIdHexString(),
+                                    type: 'document',
+                                    collection: this.collectionName,
+                                    id_document: doc._id,
+                                    payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
+                                    method: 'updateMany',
+                                    id_user: '',
+                                    user: '',
+                                    messageId: 0,
+                                    route: ''
+                                });
+                            }
+                            if (this.useVersions) {
+                                versionDoc = (0, common_1.deepCopy)(doc);
+                                versionDoc._id = { _id: doc._id, __v: doc.__v };
+                                index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne({ _id: { _id: doc._id, __v: doc.__v } }, versionDoc, { upsert: true });
+                                if (doc.__v >= 4) {
+                                    index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [{ '_id._id': doc._id }, { '_id.__v': { $lt: doc.__v - 4 } }] });
+                                }
+                                if (!objectContainsPropertyDeep(update, '__v')) {
+                                    if (!update.$inc) {
+                                        update.$inc = { __v: 1 };
+                                    }
+                                    else if (!update.$inc.__v) {
+                                        update.$inc.__v = 1;
+                                    }
+                                }
+                            }
+                        }
+                        _a.label = 2;
+                    case 2:
+                        monitor = new monitor_manager_1.MonitorMongo('updateMany', this.collectionName, JSON.stringify([filter, update, options]));
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateMany(filter, update, options).then(function (res) {
+                            monitor.finish();
+                            if (res.acknowledged) {
+                                index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                resolve(res.modifiedCount);
+                            }
+                            else {
+                                reject(res.acknowledged);
+                            }
+                        }, function (err) {
+                            monitor.finish();
+                            console.log(new Date(), 'Error Update Many', _this.collectionName, filter, update, options, err);
+                            reject(err);
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.updateOne = function (filter, update, options, bypassLogs, bypassCheckSchema) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        if (bypassCheckSchema === void 0) { bypassCheckSchema = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, isValid, date, doc, versionDoc, monitor_15, monitor_16, monitor_17, monitor_18;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.checkSchema && !bypassCheckSchema) {
+                            validation = this.simplschema.newContext();
+                            isValid = validation.validate(update, { modifier: true });
+                            if (!isValid) {
+                                console.log(new Date(), this.collectionName, 'Schema Errors - updateOne', validation.validationErrors());
+                                index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal.call(index_1.ResolveIOServer.getMainServer().getMethodManager(), 'insertErrorLog', 'Schema Failed on updateOne - ' + this.collectionName, [validation.validationErrors(), update]);
+                                reject(validation.validationErrors());
+                                return [2 /*return*/];
+                            }
+                        }
+                        if ((!update.$inc || JSON.stringify(update.$inc) === '{}') && (!update.$set || JSON.stringify(update.$set) === '{}') && (!update.$setOnInsert || JSON.stringify(update.$setOnInsert) === '{}') && (!update.$unset || JSON.stringify(update.$unset) === '{}')) {
+                            resolve(1);
+                            return [2 /*return*/];
+                        }
+                        date = new Date();
+                        if (this.timestamps) {
+                            if (!update.$set) {
+                                update.$set = { updatedAt: date };
+                            }
+                            else {
+                                update.$set.updatedAt = date;
+                            }
+                        }
+                        if (!this.useVersions) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.findOne(filter, null, true)];
+                    case 1:
+                        doc = _a.sent();
+                        if (doc) {
+                            if (this.createLogs && !bypassLogs) {
+                                log_collection_1.Logs.insertOne({
+                                    _id: objectIdHexString(),
+                                    type: 'document',
+                                    collection: this.collectionName,
+                                    id_document: doc._id,
+                                    payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
+                                    method: 'updateOne',
+                                    id_user: '',
+                                    user: '',
+                                    messageId: 0,
+                                    route: ''
+                                });
+                            }
+                            versionDoc = (0, common_1.deepCopy)(doc);
+                            versionDoc._id = { _id: doc._id, __v: doc.__v };
+                            index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).replaceOne({ _id: { _id: doc._id, __v: doc.__v } }, versionDoc, { upsert: true });
+                            if (doc.__v >= 4) {
+                                index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [{ '_id._id': doc._id }, { '_id.__v': { $lt: doc.__v - 4 } }] });
+                            }
+                            if (!objectContainsPropertyDeep(update, '__v')) {
+                                if (!update.$inc) {
+                                    update.$inc = { __v: 1 };
+                                }
+                                else if (!update.$inc.__v) {
+                                    update.$inc.__v = 1;
+                                }
+                            }
+                            monitor_15 = new monitor_manager_1.MonitorMongo('updateOne', this.collectionName, JSON.stringify([filter, update, options]));
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(filter, update, options).then(function (res) {
+                                monitor_15.finish();
+                                if (res.acknowledged) {
+                                    index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                    resolve(res.modifiedCount);
+                                }
+                                else {
+                                    reject(res.acknowledged);
+                                }
+                            }, function (err) {
+                                monitor_15.finish();
+                                console.log(new Date(), 'Error Update One', _this.collectionName, filter, update, options, err);
+                                reject(err);
+                            });
+                        }
+                        else if (options && options.upsert) {
+                            if (!update.$setOnInsert) {
+                                if (this.timestamps) {
+                                    update.$setOnInsert = {
+                                        _id: objectIdHexString(),
+                                        __v: 0,
+                                        createdAt: new Date()
+                                    };
+                                }
+                                else {
+                                    update.$setOnInsert = {
+                                        _id: objectIdHexString(),
+                                        __v: 0
+                                    };
+                                }
+                            }
+                            else {
+                                if (!update.$setOnInsert._id) {
+                                    update.$setOnInsert._id = objectIdHexString();
+                                }
+                                if (this.timestamps) {
+                                    update.$setOnInsert.createdAt = new Date();
+                                }
+                            }
+                            if (this.createLogs && !bypassLogs) {
+                                log_collection_1.Logs.insertOne({
+                                    _id: objectIdHexString(),
+                                    type: 'document',
+                                    collection: this.collectionName,
+                                    id_document: update.$setOnInsert._id,
+                                    payload: (0, common_1.getBinarySize)(JSON.stringify(['upsert', filter, update, options])) < 200000 ? JSON.stringify(['upsert', filter, update, options], null, 2) : 'Too Big',
+                                    method: 'updateOne',
+                                    id_user: '',
+                                    user: '',
+                                    messageId: 0,
+                                    route: ''
+                                });
+                            }
+                            monitor_16 = new monitor_manager_1.MonitorMongo('updateOne', this.collectionName, JSON.stringify([filter, update, options]));
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(filter, update, options).then(function (res) {
+                                monitor_16.finish();
+                                if (res.acknowledged) {
+                                    index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                    resolve(res.modifiedCount);
+                                }
+                                else {
+                                    reject(res.acknowledged);
+                                }
+                            }, function (err) {
+                                monitor_16.finish();
+                                console.log(new Date(), 'Error Update One', _this.collectionName, filter, update, options, err);
+                                reject(err);
+                            });
+                        }
+                        else {
+                            reject('No Document');
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        if (options && options.upsert) {
+                            if (!update.$setOnInsert) {
+                                if (this.timestamps) {
+                                    update.$setOnInsert = {
+                                        _id: objectIdHexString(),
+                                        createdAt: new Date()
+                                    };
+                                }
+                                else {
+                                    update.$setOnInsert = {
+                                        _id: objectIdHexString()
+                                    };
+                                }
+                            }
+                            else {
+                                if (!update.$setOnInsert._id) {
+                                    update.$setOnInsert._id = objectIdHexString();
+                                }
+                                if (this.timestamps) {
+                                    update.$setOnInsert.createdAt = new Date();
+                                }
+                            }
+                        }
+                        if (this.createLogs && !bypassLogs) {
+                            if (!options) {
+                                options = { returnDocument: 'before' };
+                            }
+                            else {
+                                options.returnDocument = 'before';
+                            }
+                            monitor_17 = new monitor_manager_1.MonitorMongo('findOneAndUpdate', this.collectionName, JSON.stringify([filter, update, options]));
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).findOneAndUpdate(filter, update, options).then(function (res) {
+                                monitor_17.finish();
+                                var doc = res.value;
+                                if (doc) {
+                                    log_collection_1.Logs.insertOne({
+                                        _id: objectIdHexString(),
+                                        type: 'document',
+                                        collection: _this.collectionName,
+                                        id_document: doc._id,
+                                        payload: (0, common_1.getBinarySize)(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
+                                        method: 'updateOne',
+                                        id_user: '',
+                                        user: '',
+                                        messageId: 0,
+                                        route: ''
+                                    });
+                                    resolve(res.ok);
+                                }
+                                else if (update.$setOnInsert) {
+                                    log_collection_1.Logs.insertOne({
+                                        _id: objectIdHexString(),
+                                        type: 'document',
+                                        collection: _this.collectionName,
+                                        id_document: update.$setOnInsert._id,
+                                        payload: (0, common_1.getBinarySize)(JSON.stringify(['upsert', filter, update, options])) < 200000 ? JSON.stringify(['upsert', filter, update, options], null, 2) : 'Too Big',
+                                        method: 'updateOne',
+                                        id_user: '',
+                                        user: '',
+                                        messageId: 0,
+                                        route: ''
+                                    });
+                                    index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                    resolve(res.ok);
+                                }
+                                else {
+                                    resolve(0);
+                                }
+                            }, function (err) {
+                                monitor_17.finish();
+                                console.log(new Date(), 'Error Find One And Update', _this.collectionName, filter, update, options, err);
+                                reject(err);
+                            });
+                        }
+                        else {
+                            monitor_18 = new monitor_manager_1.MonitorMongo('updateOne', this.collectionName, JSON.stringify([filter, update, options]));
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).updateOne(filter, update, options).then(function (res) {
+                                monitor_18.finish();
+                                if (res.acknowledged) {
+                                    index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+                                    resolve(res.modifiedCount);
+                                }
+                                else {
+                                    reject(res.acknowledged);
+                                }
+                            }, function (err) {
+                                monitor_18.finish();
+                                console.log(new Date(), 'Error Update One', _this.collectionName, filter, update, options, err);
+                                reject(err);
+                            });
+                        }
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    MongoManagerCollection.prototype.watchCollection = function (pipeline, options) {
+        var _this = this;
+        if (pipeline === void 0) { pipeline = []; }
+        var stream = index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).watch(pipeline, options);
+        stream.on('change', function (evData) {
+            index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+            return evData;
+        });
+        return stream;
+    };
+    MongoManagerCollection.prototype.watchCollectionWithAggregate = function (pipeline, options) {
+        var _this = this;
+        if (pipeline === void 0) { pipeline = []; }
+        var stream = index_1.ResolveIOServer.getMainDB().collection(this.collectionName, this.collectionOptions).watch(pipeline, options);
+        stream.on('change', function (evData) {
+            index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(_this.collectionName);
+            return evData;
+        });
+        return stream;
+    };
+    return MongoManagerCollection;
+}());
+exports.MongoManagerCollection = MongoManagerCollection;
+var MongoManagerUserCollection = /** @class */ (function (_super) {
+    __extends(MongoManagerUserCollection, _super);
+    function MongoManagerUserCollection() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MongoManagerUserCollection.prototype.authenticateStrategy = function () {
+        var _this = this;
+        return function (username, password, cb) { return __awaiter(_this, void 0, void 0, function () {
+            var user;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, user_collection_1.Users.findOne({ username: username })];
+                    case 1:
+                        user = _a.sent();
+                        this.authenticate(user, password).then(function (authUser) {
+                            if (authUser.data) {
+                                cb(null, user, null);
+                            }
+                            else {
+                                cb(null, null, authUser.error);
+                            }
+                        }, function (err) {
+                            cb(err, null, null);
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+    };
+    MongoManagerUserCollection.prototype.authenticate = function (user, password) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var attemptsInterval, calculatedInterval;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        attemptsInterval = Math.pow(100, Math.log(user.attempts + 1));
+                        calculatedInterval = attemptsInterval < 300000 ? attemptsInterval : 300000;
+                        if (!user.last) return [3 /*break*/, 3];
+                        if (!(Date.now() - user.last.getTime() < calculatedInterval)) return [3 /*break*/, 2];
+                        user.last = new Date();
+                        return [4 /*yield*/, user_collection_1.Users.updateOne({ _id: user._id }, { $set: { last: user.last } })];
+                    case 1:
+                        _a.sent();
+                        resolve({
+                            data: null,
+                            error: 'Attempt Too Soon'
+                        });
+                        return [2 /*return*/];
+                    case 2: return [3 /*break*/, 4];
+                    case 3:
+                        user.last = new Date();
+                        _a.label = 4;
+                    case 4:
+                        if (user.attempts >= 5) {
+                            resolve({
+                                data: null,
+                                error: 'Too Many Attempts'
+                            });
+                            return [2 /*return*/];
+                        }
+                        if (!user.salt) {
+                            resolve({
+                                data: null,
+                                error: 'No Salt Value Stored'
+                            });
+                            return [2 /*return*/];
+                        }
+                        pbkdf2(password, user.salt, {
+                            iterations: 25000,
+                            keylen: 512,
+                            digestAlgorithm: 'sha256'
+                        }, function (err, hashBuffer) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (err) {
+                                            return [2 /*return*/, reject(err)];
+                                        }
+                                        if (!scmp(hashBuffer, Buffer.from(user.hash, 'hex'))) return [3 /*break*/, 2];
+                                        user.last = new Date();
+                                        user.attempts = 0;
+                                        return [4 /*yield*/, user_collection_1.Users.updateOne({ _id: user._id }, { $set: { last: user.last, attempts: user.attempts } })];
+                                    case 1:
+                                        _a.sent();
+                                        resolve({
+                                            data: user,
+                                            error: ''
+                                        });
+                                        return [3 /*break*/, 4];
+                                    case 2:
+                                        user.last = new Date();
+                                        user.attempts = user.attempts + 1;
+                                        return [4 /*yield*/, user_collection_1.Users.updateOne({ _id: user._id }, { $set: { last: user.last, attempts: user.attempts } })];
+                                    case 3:
+                                        _a.sent();
+                                        if (user.attempts >= 5) {
+                                            resolve({
+                                                data: null,
+                                                error: 'Too Many Attempts'
+                                            });
+                                        }
+                                        else {
+                                            resolve({
+                                                data: null,
+                                                error: 'Invalid Username And Password'
+                                            });
+                                        }
+                                        _a.label = 4;
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    MongoManagerUserCollection.prototype.serializeUser = function () {
+        return function (user, cb) {
+            cb(null, user.username);
+        };
+    };
+    MongoManagerUserCollection.prototype.deserializeUser = function () {
+        return function (username, cb) {
+            user_collection_1.Users.findOne({ username: username }).then(function (res) {
+                cb(null, res);
+            }, function (err) {
+                cb(err, null);
+            });
+        };
+    };
+    MongoManagerUserCollection.prototype.setPassword = function (user, password) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var saltBuffer, salt, hashRaw, hash;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!user) return [3 /*break*/, 1];
+                        reject('No User');
+                        return [3 /*break*/, 5];
+                    case 1:
+                        if (!!password) return [3 /*break*/, 2];
+                        reject('No Password');
+                        return [3 /*break*/, 5];
+                    case 2: return [4 /*yield*/, randomBytes(32)];
+                    case 3:
+                        saltBuffer = _a.sent();
+                        salt = saltBuffer.toString('hex');
+                        return [4 /*yield*/, pbkdf2Promisified(password, salt, {
+                                iterations: 25000,
+                                keylen: 512,
+                                digestAlgorithm: 'sha256'
+                            })];
+                    case 4:
+                        hashRaw = _a.sent();
+                        hash = Buffer.from(hashRaw, 'binary').toString('hex');
+                        user_collection_1.Users.updateOne({ _id: user._id }, { $set: { hash: hash, salt: salt, services: {}, attempts: 0 } }).then(function (res) { return resolve(res); }, function (rej) { return reject(rej); });
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    ;
+    MongoManagerUserCollection.prototype.changePassword = function (user, oldPassword, newPassword) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var authUser;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!user) return [3 /*break*/, 1];
+                        reject('Missing User');
+                        return [3 /*break*/, 4];
+                    case 1:
+                        if (!(!oldPassword || !newPassword)) return [3 /*break*/, 2];
+                        reject('Missing Password');
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.authenticate(user, oldPassword)];
+                    case 3:
+                        authUser = _a.sent();
+                        if (!authUser['data']) {
+                            reject(authUser['error']);
+                        }
+                        else {
+                            this.setPassword(user, newPassword).then(function (res) { return resolve(res); }, function (rej) { return reject(rej); });
+                        }
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    MongoManagerUserCollection.prototype.register = function (user, password) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var dbUser;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!user.username) return [3 /*break*/, 1];
+                        reject('Missing Username');
+                        return [3 /*break*/, 5];
+                    case 1: return [4 /*yield*/, user_collection_1.Users.findOne({ username: user.username })];
+                    case 2:
+                        dbUser = _a.sent();
+                        if (!dbUser) return [3 /*break*/, 3];
+                        reject('Username Exists');
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, user_collection_1.Users.findOne({ email: user.email })];
+                    case 4:
+                        dbUser = _a.sent();
+                        if (dbUser) {
+                            reject('Email Exists');
+                        }
+                        else {
+                            user.setPassword(password);
+                            resolve(user);
+                        }
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    MongoManagerUserCollection.prototype.resetAttempts = function (user) {
+        return user_collection_1.Users.updateOne({ _id: user._id }, { $set: { attempts: 0 } });
+    };
+    return MongoManagerUserCollection;
+}(MongoManagerCollection));
+exports.MongoManagerUserCollection = MongoManagerUserCollection;
+function objectIdHexString() {
+    var objectId = new mongodb_1.ObjectId();
+    return objectId.toHexString();
+}
+exports.objectIdHexString = objectIdHexString;
+function pbkdf2(password, salt, options, callback) {
+    crypto.pbkdf2(password, salt, options.iterations, options.keylen, options.digestAlgorithm, callback);
+}
+;
+function pbkdf2Promisified(password, salt, options) {
+    return new Promise(function (resolve, reject) { return pbkdf2(password, salt, options, function (err, hashRaw) { return (err ? reject(err) : resolve(hashRaw)); }); });
+}
+function randomBytes(saltlen) {
+    return new Promise(function (resolve, reject) { return crypto.randomBytes(saltlen, function (err, saltBuffer) { return (err ? reject(err) : resolve(saltBuffer)); }); });
+}
+function objectContainsPropertyDeep(obj, prop) {
+    var keys = Object.keys(obj);
+    if (keys.some(function (a) { return a === prop; })) {
+        return true;
+    }
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (obj[key] && typeof obj[key] === 'object' && objectContainsPropertyDeep(obj[key], prop)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+//# sourceMappingURL=mongo.manager.js.map