@resolveio/server-lib 9.0.34 → 9.0.35

package/managers/mongo.manager.js

@@ -1,29 +1,81 @@
-import SimpleSchema from 'simpl-schema';
-import { ObjectId } from 'mongodb';
-import { ResolveIOServer } from '../index';
-import { Users } from '../collections/user.collection';
-import { buildRbLookups, buildRbSchema, deepCopy, getBinarySize, getMongoMergeUpdatedDoc } from '../util/common';
-import { Logs } from '../collections/log.collection';
-const crypto = require('crypto');
-const scmp = require('scmp');
-export class MongoManager {
-    constructor() {
+"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) {
+        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 (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectIdHexString = exports.UserCollection = exports.Collection = exports.Model = 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 crypto = require('crypto');
+var scmp = require('scmp');
+var MongoManager = /** @class */ (function () {
+    function MongoManager() {
         this._collections = [];
         this._mongoQueue = [];
         this._mongoQueueId = 0;
         this.runQueue();
     }
-    registerCollection(collection) {
+    MongoManager.prototype.registerCollection = function (collection) {
         this._collections.push(collection);
-    }
-    collections() {
+    };
+    MongoManager.prototype.collections = function () {
         return this._collections;
-    }
-    collection(collectionName) {
-        return this._collections.filter(a => a.collectionName === collectionName)[0];
-    }
-    addToQueue(mongoQueue) {
-        let _mongoQueue = this._mongoQueue.filter(a => 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];
+    };
+    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]);
@@ -37,64 +89,78 @@ export class MongoManager {
             this._mongoQueueId += 1;
             this._mongoQueue.push(mongoQueue);
         }
-    }
-    async runQueue() {
-        setInterval(() => {
-            if (this._mongoQueue.filter(a => !a.running).length) {
-                let mongoQueue = this._mongoQueue.filter(a => !a.running)[0];
-                mongoQueue.running = true;
-                if (!mongoQueue.name_function_addt) {
-                    ResolveIOServer.getMainDB().collection(mongoQueue.name_collection)[mongoQueue.name_function](...mongoQueue.data_function).then(res => {
-                        mongoQueue.cbs.forEach(cb => {
-                            cb(null, res);
-                        });
-                        if (mongoQueue.cbs_next.length) {
-                            mongoQueue.running = false;
-                            mongoQueue.cbs = mongoQueue.cbs_next;
-                            mongoQueue.cbs_next = [];
-                        }
-                        else {
-                            this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id), 1);
-                        }
-                    }, err => {
-                        mongoQueue.cbs.forEach(cb => {
-                            cb(err, null);
-                        });
-                        mongoQueue.cbs_next.forEach(cb => {
-                            cb(err, null);
-                        });
-                        this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id), 1);
-                    });
-                }
-                else {
-                    ResolveIOServer.getMainDB().collection(mongoQueue.name_collection)[mongoQueue.name_function](...mongoQueue.data_function)[mongoQueue.name_function_addt](...mongoQueue.data_function_addt).then(res => {
-                        mongoQueue.cbs.forEach(cb => {
-                            cb(null, res);
-                        });
-                        if (mongoQueue.cbs_next.length) {
-                            mongoQueue.running = false;
-                            mongoQueue.cbs = mongoQueue.cbs_next;
-                            mongoQueue.cbs_next = []; // BUG???
+    };
+    MongoManager.prototype.runQueue = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                setInterval(function () {
+                    var _a, _b, _c;
+                    if (_this._mongoQueue.filter(function (a) { return !a.running; }).length) {
+                        var mongoQueue_1 = _this._mongoQueue.filter(function (a) { return !a.running; })[0];
+                        mongoQueue_1.running = true;
+                        if (!mongoQueue_1.name_function_addt) {
+                            (_a = index_1.ResolveIOServer.getMainDB().collection(mongoQueue_1.name_collection))[mongoQueue_1.name_function].apply(_a, mongoQueue_1.data_function).then(function (res) {
+                                mongoQueue_1.cbs.forEach(function (cb) {
+                                    cb(null, res);
+                                });
+                                if (mongoQueue_1.cbs_next.length) {
+                                    mongoQueue_1.running = false;
+                                    mongoQueue_1.cbs = mongoQueue_1.cbs_next;
+                                    mongoQueue_1.cbs_next = [];
+                                }
+                                else {
+                                    _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue_1._id), 1);
+                                }
+                            }, function (err) {
+                                mongoQueue_1.cbs.forEach(function (cb) {
+                                    cb(err, null);
+                                });
+                                mongoQueue_1.cbs_next.forEach(function (cb) {
+                                    cb(err, null);
+                                });
+                                _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue_1._id), 1);
+                            });
                         }
                         else {
-                            this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id), 1);
+                            (_b = (_c = index_1.ResolveIOServer.getMainDB().collection(mongoQueue_1.name_collection))[mongoQueue_1.name_function].apply(_c, mongoQueue_1.data_function))[mongoQueue_1.name_function_addt].apply(_b, mongoQueue_1.data_function_addt).then(function (res) {
+                                mongoQueue_1.cbs.forEach(function (cb) {
+                                    cb(null, res);
+                                });
+                                if (mongoQueue_1.cbs_next.length) {
+                                    mongoQueue_1.running = false;
+                                    mongoQueue_1.cbs = mongoQueue_1.cbs_next;
+                                    mongoQueue_1.cbs_next = []; // BUG???
+                                }
+                                else {
+                                    _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue_1._id), 1);
+                                }
+                            }, function (err) {
+                                mongoQueue_1.cbs.forEach(function (cb) {
+                                    cb(err, null);
+                                });
+                                mongoQueue_1.cbs_next.forEach(function (cb) {
+                                    cb(err, null);
+                                });
+                                _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue_1._id), 1);
+                            });
                         }
-                    }, err => {
-                        mongoQueue.cbs.forEach(cb => {
-                            cb(err, null);
-                        });
-                        mongoQueue.cbs_next.forEach(cb => {
-                            cb(err, null);
-                        });
-                        this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id), 1);
-                    });
-                }
-            }
-        }, 10);
-    }
-}
-export class Model {
-    constructor(collectionName, schema, useVersionCollection = false, useReportBuilder = true, reportBuilderLookupTables = [], timestamps = true, createLogs = true) {
+                    }
+                }, 10);
+                return [2 /*return*/];
+            });
+        });
+    };
+    return MongoManager;
+}());
+exports.MongoManager = MongoManager;
+var Model = /** @class */ (function () {
+    function Model(collectionName, schema, useVersionCollection, useReportBuilder, reportBuilderLookupTables, timestamps, createLogs) {
+        if (useVersionCollection === void 0) { useVersionCollection = false; }
+        if (useReportBuilder === void 0) { useReportBuilder = true; }
+        if (reportBuilderLookupTables === void 0) { reportBuilderLookupTables = []; }
+        if (timestamps === void 0) { timestamps = true; }
+        if (createLogs === void 0) { createLogs = true; }
         this.collection_main = null;
         this.collection_version = null;
         if (collectionName === 'users') {
@@ -105,7 +171,7 @@ export class Model {
         }
         if (useVersionCollection) {
             this.collection_main.useVersions = true;
-            let versionSchema = deepCopy(schema);
+            var versionSchema = common_1.deepCopy(schema);
             versionSchema['_id'].type = 'Object';
             versionSchema['_id'].blackbox = true;
             if (collectionName === 'users') {
@@ -118,9 +184,12 @@ export class Model {
             this.collection_main.versionCollection = collectionName + '.versions';
         }
     }
-}
-export class Collection {
-    constructor(collectionName, schema, useReportBuilder, reportBuilderLookupTables, timestamps, createLogs) {
+    return Model;
+}());
+exports.Model = Model;
+var Collection = /** @class */ (function () {
+    function Collection(collectionName, schema, useReportBuilder, reportBuilderLookupTables, timestamps, createLogs) {
+        var _this = this;
         this.collectionName = '';
         this.simplschema = null;
         this.rbSchema = null;
@@ -130,32 +199,33 @@ export class Collection {
         this.createLogs = true;
         this.useRB = false;
         this.collectionName = collectionName;
-        this.simplschema = new SimpleSchema(schema);
+        this.simplschema = new simpl_schema_1.default(schema);
         this.timestamps = timestamps;
         this.createLogs = createLogs;
         if (useReportBuilder) {
             this.useRB = true;
-            let schemaCopy = deepCopy(schema);
-            let rbSchema = buildRbLookups(reportBuilderLookupTables, schemaCopy, []);
-            this.rbSchema = buildRbSchema(rbSchema);
+            var schemaCopy = common_1.deepCopy(schema);
+            var rbSchema = common_1.buildRbLookups(reportBuilderLookupTables, schemaCopy, []);
+            this.rbSchema = common_1.buildRbSchema(rbSchema);
         }
-        let interval = setInterval(() => {
-            if (ResolveIOServer && ResolveIOServer.getMainServer() && ResolveIOServer.getMongoManager()) {
-                ResolveIOServer.getMongoManager().registerCollection(this);
+        var interval = setInterval(function () {
+            if (index_1.ResolveIOServer && index_1.ResolveIOServer.getMainServer() && index_1.ResolveIOServer.getMongoManager()) {
+                index_1.ResolveIOServer.getMongoManager().registerCollection(_this);
                 clearInterval(interval);
             }
         }, 1);
     }
-    aggregate(pipeline, options) {
-        return new Promise((resolve, reject) => {
-            ResolveIOServer.getMongoManager().addToQueue({
+    Collection.prototype.aggregate = function (pipeline, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            index_1.ResolveIOServer.getMongoManager().addToQueue({
                 _id: 0,
-                name_collection: this.collectionName,
+                name_collection: _this.collectionName,
                 name_function: 'aggregate',
                 name_function_addt: 'toArray',
                 data_function: [pipeline, options],
                 data_function_addt: [],
-                cbs: [(err, res) => {
+                cbs: [function (err, res) {
                         if (err) {
                             reject(err);
                         }
@@ -167,17 +237,18 @@ export class Collection {
                 running: false
             });
         });
-    }
-    aggregateCount(pipeline, options) {
-        return new Promise((resolve, reject) => {
-            ResolveIOServer.getMongoManager().addToQueue({
+    };
+    Collection.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_collection: _this.collectionName,
                 name_function: 'aggregate',
                 name_function_addt: 'count',
                 data_function: [pipeline, options],
                 data_function_addt: [],
-                cbs: [(err, res) => {
+                cbs: [function (err, res) {
                         if (err) {
                             reject(err);
                         }
@@ -189,116 +260,147 @@ export class Collection {
                 running: false
             });
         });
-    }
-    aggregateCursor(pipeline, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).aggregate(pipeline, options);
-    }
-    aggregateStream(pipeline, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).aggregate(pipeline, options).stream();
-    }
-    countDocuments(filter = {}, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).countDocuments(filter, options);
-    }
-    create(f_docs, options) {
-        let docs = [];
+    };
+    Collection.prototype.aggregateCursor = function (pipeline, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).aggregate(pipeline, options);
+    };
+    Collection.prototype.aggregateStream = function (pipeline, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).aggregate(pipeline, options).stream();
+    };
+    Collection.prototype.countDocuments = function (filter, options) {
+        if (filter === void 0) { filter = {}; }
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).countDocuments(filter, options);
+    };
+    Collection.prototype.create = function (f_docs, options) {
+        var docs = [];
         if (!Array.isArray(f_docs)) {
             return this.insertOne(f_docs, options);
         }
         return this.insertMany(f_docs, options);
-    }
-    createIndex(fieldOrSpec, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).createIndex(fieldOrSpec, options);
-    }
-    createIndexes(indexSpecs, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).createIndexes(indexSpecs, options);
-    }
-    deleteMany(filter = {}, options, bypassLogs = false) {
-        return new Promise(async (resolve, reject) => {
-            if (this.createLogs && !bypassLogs) {
-                let docs = await this.find(filter);
-                docs.forEach(doc => {
-                    Logs.insertOne({
-                        _id: objectIdHexString(),
-                        type: 'document',
-                        collection: this.collectionName,
-                        id_document: doc['_id'],
-                        payload: getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
-                        method: 'deleteMany',
-                        id_user: '',
-                        user: '',
-                        messageId: '',
-                        route: ''
-                    });
-                    if (this.useVersions) {
-                        doc['_id'] = { _id: doc['_id'], __v: doc['__v'] };
-                        ResolveIOServer.getMongoManager().collection(this.versionCollection).insertOne(doc);
-                    }
-                });
-            }
-            ResolveIOServer.getMainDB().collection(this.collectionName).deleteMany(filter, options).then(res => {
-                if (res.result.ok) {
-                    resolve(res.deletedCount);
-                }
-                else {
-                    reject(res.result.ok);
-                }
-            }, err => reject(err));
-        });
-    }
-    deleteOne(filter = {}, options, bypassLogs = false) {
-        return new Promise(async (resolve, reject) => {
-            if (this.createLogs && !bypassLogs) {
-                let doc = await this.findOne(filter);
-                if (doc) {
-                    Logs.insertOne({
-                        _id: objectIdHexString(),
-                        type: 'document',
-                        collection: this.collectionName,
-                        id_document: doc['_id'],
-                        payload: getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
-                        method: 'deleteOne',
-                        id_user: '',
-                        user: '',
-                        messageId: '',
-                        route: ''
-                    });
-                    if (this.useVersions) {
-                        doc['_id'] = { _id: doc['_id'], __v: doc['__v'] };
-                        ResolveIOServer.getMongoManager().collection(this.versionCollection).insertOne(doc);
-                    }
-                }
-            }
-            ResolveIOServer.getMainDB().collection(this.collectionName).deleteOne(filter, options).then(res => {
-                if (res.result.ok) {
-                    resolve(res.deletedCount);
+    };
+    Collection.prototype.createIndex = function (fieldOrSpec, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).createIndex(fieldOrSpec, options);
+    };
+    Collection.prototype.createIndexes = function (indexSpecs, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).createIndexes(indexSpecs, options);
+    };
+    Collection.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;
+            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();
+                        docs.forEach(function (doc) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: _this.collectionName,
+                                id_document: doc['_id'],
+                                payload: common_1.getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
+                                method: 'deleteMany',
+                                id_user: '',
+                                user: '',
+                                messageId: '',
+                                route: ''
+                            });
+                            if (_this.useVersions) {
+                                doc['_id'] = { _id: doc['_id'], __v: doc['__v'] };
+                                index_1.ResolveIOServer.getMongoManager().collection(_this.versionCollection).insertOne(doc);
+                            }
+                        });
+                        _a.label = 2;
+                    case 2:
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).deleteMany(filter, options).then(function (res) {
+                            if (res.result.ok) {
+                                resolve(res.deletedCount);
+                            }
+                            else {
+                                reject(res.result.ok);
+                            }
+                        }, function (err) { return reject(err); });
+                        return [2 /*return*/];
                 }
-                else {
-                    reject(res.result.ok);
+            });
+        }); });
+    };
+    Collection.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 doc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.createLogs && !bypassLogs)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.findOne(filter)];
+                    case 1:
+                        doc = _a.sent();
+                        if (doc) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: this.collectionName,
+                                id_document: doc['_id'],
+                                payload: common_1.getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
+                                method: 'deleteOne',
+                                id_user: '',
+                                user: '',
+                                messageId: '',
+                                route: ''
+                            });
+                            if (this.useVersions) {
+                                doc['_id'] = { _id: doc['_id'], __v: doc['__v'] };
+                                index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).insertOne(doc);
+                            }
+                        }
+                        _a.label = 2;
+                    case 2:
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).deleteOne(filter, options).then(function (res) {
+                            if (res.result.ok) {
+                                resolve(res.deletedCount);
+                            }
+                            else {
+                                reject(res.result.ok);
+                            }
+                        }, function (err) { return reject(err); });
+                        return [2 /*return*/];
                 }
-            }, err => reject(err));
-        });
-    }
-    distinct(key, filter, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).distinct(key, filter, options);
-    }
-    drop(options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).drop(options);
-    }
-    dropIndex(indexName, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).dropIndex(indexName, options);
-    }
-    dropIndexes(options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).dropIndexes(options);
-    }
-    find(filter = {}, options, bypassLogs = false) {
-        return new Promise((resolve, reject) => {
-            if (this.createLogs && !bypassLogs) {
-                Logs.insertOne({
+            });
+        }); });
+    };
+    Collection.prototype.distinct = function (key, filter, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).distinct(key, filter, options);
+    };
+    Collection.prototype.drop = function (options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).drop(options);
+    };
+    Collection.prototype.dropIndex = function (indexName, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).dropIndex(indexName, options);
+    };
+    Collection.prototype.dropIndexes = function (options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).dropIndexes(options);
+    };
+    Collection.prototype.find = function (filter, options, bypassLogs) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) {
+            if (_this.createLogs && !bypassLogs) {
+                log_collection_1.Logs.insertOne({
                     _id: objectIdHexString(),
                     type: 'query',
-                    collection: this.collectionName,
+                    collection: _this.collectionName,
                     id_document: '',
-                    payload: getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
+                    payload: common_1.getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
                     method: 'find',
                     id_user: '',
                     user: '',
@@ -306,14 +408,14 @@ export class Collection {
                     route: ''
                 });
             }
-            ResolveIOServer.getMongoManager().addToQueue({
+            index_1.ResolveIOServer.getMongoManager().addToQueue({
                 _id: 0,
-                name_collection: this.collectionName,
+                name_collection: _this.collectionName,
                 name_function: 'find',
                 name_function_addt: 'toArray',
                 data_function: [filter, options],
                 data_function_addt: [],
-                cbs: [(err, res) => {
+                cbs: [function (err, res) {
                         if (err) {
                             reject(err);
                         }
@@ -325,18 +427,20 @@ export class Collection {
                 running: false
             });
         });
-    }
-    findById(id, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).findOne({ _id: id }, options);
-    }
-    findCount(filter = {}, options, bypassLogs = false) {
+    };
+    Collection.prototype.findById = function (id, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).findOne({ _id: id }, options);
+    };
+    Collection.prototype.findCount = function (filter, options, bypassLogs) {
+        if (filter === void 0) { filter = {}; }
+        if (bypassLogs === void 0) { bypassLogs = false; }
         if (this.createLogs && !bypassLogs) {
-            Logs.insertOne({
+            log_collection_1.Logs.insertOne({
                 _id: objectIdHexString(),
                 type: 'query',
                 collection: this.collectionName,
                 id_document: '',
-                payload: getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
+                payload: common_1.getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
                 method: 'findCount',
                 id_user: '',
                 user: '',
@@ -344,23 +448,28 @@ export class Collection {
                 route: ''
             });
         }
-        return ResolveIOServer.getMainDB().collection(this.collectionName).find(filter, options).count();
-    }
-    findCursor(filter = {}, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).find(filter, options);
-    }
-    findStream(filter = {}, options, streamOptions) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).find(filter, options).stream(streamOptions);
-    }
-    findOne(filter = {}, options, bypassLogs = false) {
-        return new Promise((resolve, reject) => {
-            if (this.createLogs && !bypassLogs) {
-                Logs.insertOne({
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).find(filter, options).count();
+    };
+    Collection.prototype.findCursor = function (filter, options) {
+        if (filter === void 0) { filter = {}; }
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).find(filter, options);
+    };
+    Collection.prototype.findStream = function (filter, options, streamOptions) {
+        if (filter === void 0) { filter = {}; }
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).find(filter, options).stream(streamOptions);
+    };
+    Collection.prototype.findOne = function (filter, options, bypassLogs) {
+        var _this = this;
+        if (filter === void 0) { filter = {}; }
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) {
+            if (_this.createLogs && !bypassLogs) {
+                log_collection_1.Logs.insertOne({
                     _id: objectIdHexString(),
                     type: 'query',
-                    collection: this.collectionName,
+                    collection: _this.collectionName,
                     id_document: '',
-                    payload: getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
+                    payload: common_1.getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
                     method: 'findOne',
                     id_user: '',
                     user: '',
@@ -368,14 +477,14 @@ export class Collection {
                     route: ''
                 });
             }
-            ResolveIOServer.getMongoManager().addToQueue({
+            index_1.ResolveIOServer.getMongoManager().addToQueue({
                 _id: 0,
-                name_collection: this.collectionName,
+                name_collection: _this.collectionName,
                 name_function: 'findOne',
                 name_function_addt: '',
                 data_function: [filter, options],
                 data_function_addt: [],
-                cbs: [(err, res) => {
+                cbs: [function (err, res) {
                         if (err) {
                             reject(err);
                         }
@@ -387,158 +496,199 @@ export class Collection {
                 running: false
             });
         });
-    }
-    findOneAndDelete(filter = {}, options, bypassLogs = false) {
-        return new Promise(async (resolve, reject) => {
-            if (this.createLogs && !bypassLogs) {
-                let doc = await this.findOne(filter);
-                if (doc) {
-                    Logs.insertOne({
-                        _id: objectIdHexString(),
-                        type: 'document',
-                        collection: this.collectionName,
-                        id_document: doc['_id'],
-                        payload: getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
-                        method: 'findOneAndDelete',
-                        id_user: '',
-                        user: '',
-                        messageId: '',
-                        route: ''
-                    });
-                }
-            }
-            ResolveIOServer.getMainDB().collection(this.collectionName).findOneAndDelete(filter, options).then(res => {
-                if (res.ok) {
-                    resolve(res.value);
-                }
-                else {
-                    reject(res.lastErrorObject);
-                }
-            }, err => reject(err));
-        });
-    }
-    findOneAndReplace(filter = {}, replacement, options, bypassLogs = false) {
-        return new Promise(async (resolve, reject) => {
-            const validation = this.simplschema.newContext().validate(replacement);
-            if (!validation.isValid()) {
-                console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
-                ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on findOneAndReplace - ' + this.collectionName, [validation.validationErrors(), replacement]);
-                reject(validation.validationErrors());
-            }
-            else {
-                if (this.timestamps) {
-                    replacement['updatedAt'] = new Date();
-                }
-                if (this.createLogs && !bypassLogs) {
-                    let doc = await this.findOne(filter);
-                    if (doc) {
-                        Logs.insertOne({
-                            _id: objectIdHexString(),
-                            type: 'document',
-                            collection: this.collectionName,
-                            id_document: doc['_id'],
-                            payload: getBinarySize(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
-                            method: 'findOneAndReplace',
-                            id_user: '',
-                            user: '',
-                            messageId: '',
-                            route: ''
-                        });
-                    }
+    };
+    Collection.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 doc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.createLogs && !bypassLogs)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.findOne(filter)];
+                    case 1:
+                        doc = _a.sent();
+                        if (doc) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: this.collectionName,
+                                id_document: doc['_id'],
+                                payload: common_1.getBinarySize(JSON.stringify([doc, filter, options])) < 200000 ? JSON.stringify([doc, filter, options], null, 2) : 'Too Big',
+                                method: 'findOneAndDelete',
+                                id_user: '',
+                                user: '',
+                                messageId: '',
+                                route: ''
+                            });
+                        }
+                        _a.label = 2;
+                    case 2:
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).findOneAndDelete(filter, options).then(function (res) {
+                            if (res.ok) {
+                                resolve(res.value);
+                            }
+                            else {
+                                reject(res.lastErrorObject);
+                            }
+                        }, function (err) { return reject(err); });
+                        return [2 /*return*/];
                 }
-                ResolveIOServer.getMainDB().collection(this.collectionName).findOneAndReplace(filter, replacement, options).then(res => {
-                    if (res.ok) {
-                        resolve(res.value);
-                    }
-                    else {
-                        reject(res.lastErrorObject);
-                    }
-                }, err => reject(err));
-            }
-        });
-    }
-    findOneAndUpdate(filter = {}, update, options, bypassLogs = false) {
-        return new Promise(async (resolve, reject) => {
-            const validation = this.simplschema.newContext().validate(update, { modifier: true });
-            if (!validation.isValid()) {
-                console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
-                ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on findOneAndUpdate - ' + this.collectionName, [validation.validationErrors(), update]);
-                reject(validation.validationErrors());
-            }
-            else {
-                if (this.timestamps) {
-                    if (!update['$set']) {
-                        update['$set'] = { updatedAt: new Date() };
-                    }
-                    else {
-                        update['$set']['updatedAt'] = new Date();
-                    }
+            });
+        }); });
+    };
+    Collection.prototype.findOneAndReplace = function (filter, replacement, 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 validation, doc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        validation = this.simplschema.newContext().validate(replacement);
+                        if (!!validation.isValid()) return [3 /*break*/, 1];
+                        console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
+                        index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on findOneAndReplace - ' + this.collectionName, [validation.validationErrors(), replacement]);
+                        reject(validation.validationErrors());
+                        return [3 /*break*/, 4];
+                    case 1:
+                        if (this.timestamps) {
+                            replacement['updatedAt'] = new Date();
+                        }
+                        if (!(this.createLogs && !bypassLogs)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.findOne(filter)];
+                    case 2:
+                        doc = _a.sent();
+                        if (doc) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: this.collectionName,
+                                id_document: doc['_id'],
+                                payload: 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: '',
+                                route: ''
+                            });
+                        }
+                        _a.label = 3;
+                    case 3:
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).findOneAndReplace(filter, replacement, options).then(function (res) {
+                            if (res.ok) {
+                                resolve(res.value);
+                            }
+                            else {
+                                reject(res.lastErrorObject);
+                            }
+                        }, function (err) { return reject(err); });
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
                 }
-                if (this.createLogs && !bypassLogs) {
-                    let doc = await this.findOne(filter);
-                    if (doc) {
-                        Logs.insertOne({
-                            _id: objectIdHexString(),
-                            type: 'document',
-                            collection: this.collectionName,
-                            id_document: doc['_id'],
-                            payload: getBinarySize(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
-                            method: 'findOneAndUpdate',
-                            id_user: '',
-                            user: '',
-                            messageId: '',
-                            route: ''
-                        });
-                    }
+            });
+        }); });
+    };
+    Collection.prototype.findOneAndUpdate = function (filter, update, 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 validation, doc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        validation = this.simplschema.newContext().validate(update, { modifier: true });
+                        if (!!validation.isValid()) return [3 /*break*/, 1];
+                        console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
+                        index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on findOneAndUpdate - ' + this.collectionName, [validation.validationErrors(), update]);
+                        reject(validation.validationErrors());
+                        return [3 /*break*/, 4];
+                    case 1:
+                        if (this.timestamps) {
+                            if (!update['$set']) {
+                                update['$set'] = { updatedAt: new Date() };
+                            }
+                            else {
+                                update['$set']['updatedAt'] = new Date();
+                            }
+                        }
+                        if (!(this.createLogs && !bypassLogs)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.findOne(filter)];
+                    case 2:
+                        doc = _a.sent();
+                        if (doc) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: this.collectionName,
+                                id_document: doc['_id'],
+                                payload: 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: '',
+                                route: ''
+                            });
+                        }
+                        _a.label = 3;
+                    case 3:
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).findOneAndUpdate(filter, update, options).then(function (res) {
+                            if (res.ok) {
+                                resolve(res.value);
+                            }
+                            else {
+                                reject(res.lastErrorObject);
+                            }
+                        }, function (err) { return reject(err); });
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
                 }
-                ResolveIOServer.getMainDB().collection(this.collectionName).findOneAndUpdate(filter, update, options).then(res => {
-                    if (res.ok) {
-                        resolve(res.value);
-                    }
-                    else {
-                        reject(res.lastErrorObject);
-                    }
-                }, err => reject(err));
-            }
-        });
-    }
-    indexes(options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).indexes(options);
-    }
-    indexExists(indexes, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).indexExists(indexes, options);
-    }
-    insertMany(docs, options, bypassLogs = false) {
-        return new Promise((resolve, reject) => {
+            });
+        }); });
+    };
+    Collection.prototype.indexes = function (options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).indexes(options);
+    };
+    Collection.prototype.indexExists = function (indexes, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).indexExists(indexes, options);
+    };
+    Collection.prototype.insertMany = function (docs, options, bypassLogs) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) {
             if (!docs.length) {
                 reject('No Documents');
                 return;
             }
-            let validationResults = [];
-            docs.forEach(doc => {
-                const validation = this.simplschema.newContext().validate(doc);
+            var validationResults = [];
+            docs.forEach(function (doc) {
+                var validation = _this.simplschema.newContext().validate(doc);
                 if (!validation.isValid()) {
-                    console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
-                    ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on insertMany - ' + this.collectionName, [validation.validationErrors(), doc]);
+                    console.log(new Date(), _this.collectionName, 'Schema Errors', validation.validationErrors());
+                    index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on insertMany - ' + _this.collectionName, [validation.validationErrors(), doc]);
                     validationResults.push(false);
                 }
                 else {
                     validationResults.push(true);
                 }
             });
-            let validDocs = docs.filter((a, idx) => validationResults[idx]);
-            validDocs.forEach(doc => {
-                if (this.timestamps) {
+            var validDocs = docs.filter(function (a, idx) { return validationResults[idx]; });
+            validDocs.forEach(function (doc) {
+                if (_this.timestamps) {
                     doc['createdAt'] = new Date();
                     doc['updatedAt'] = new Date();
                 }
-                if (this.createLogs && !bypassLogs) {
-                    Logs.insertOne({
+                if (_this.createLogs && !bypassLogs) {
+                    log_collection_1.Logs.insertOne({
                         _id: objectIdHexString(),
                         type: 'document',
-                        collection: this.collectionName,
+                        collection: _this.collectionName,
                         id_document: doc['_id'],
-                        payload: getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
+                        payload: common_1.getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
                         method: 'insertMany',
                         id_user: '',
                         user: '',
@@ -548,39 +698,41 @@ export class Collection {
                 }
             });
             if (validDocs.length) {
-                ResolveIOServer.getMainDB().collection(this.collectionName).insertMany(validDocs, options).then(res => {
+                index_1.ResolveIOServer.getMainDB().collection(_this.collectionName).insertMany(validDocs, options).then(function (res) {
                     if (res.result.ok) {
                         resolve(validDocs);
                     }
                     else {
                         reject(res.result.ok);
                     }
-                }, err => {
+                }, function (err) {
                     reject(err);
                 });
             }
         });
-    }
-    insertOne(doc, options, bypassLogs = false) {
-        return new Promise((resolve, reject) => {
-            const validation = this.simplschema.newContext().validate(doc);
+    };
+    Collection.prototype.insertOne = function (doc, options, bypassLogs) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) {
+            var validation = _this.simplschema.newContext().validate(doc);
             if (!validation.isValid()) {
-                console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
-                ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on insertOne - ' + this.collectionName, [validation.validationErrors(), doc]);
+                console.log(new Date(), _this.collectionName, 'Schema Errors', validation.validationErrors());
+                index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on insertOne - ' + _this.collectionName, [validation.validationErrors(), doc]);
                 reject(validation.validationErrors());
             }
             else {
-                if (this.timestamps) {
+                if (_this.timestamps) {
                     doc['createdAt'] = new Date();
                     doc['updatedAt'] = new Date();
                 }
-                if (this.createLogs && !bypassLogs) {
-                    Logs.insertOne({
+                if (_this.createLogs && !bypassLogs) {
+                    log_collection_1.Logs.insertOne({
                         _id: objectIdHexString(),
                         type: 'document',
-                        collection: this.collectionName,
+                        collection: _this.collectionName,
                         id_document: doc['_id'],
-                        payload: getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
+                        payload: common_1.getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
                         method: 'insertOne',
                         id_user: '',
                         user: '',
@@ -588,50 +740,59 @@ export class Collection {
                         route: ''
                     });
                 }
-                ResolveIOServer.getMainDB().collection(this.collectionName).insertOne(doc, options).then(res => {
+                index_1.ResolveIOServer.getMainDB().collection(_this.collectionName).insertOne(doc, options).then(function (res) {
                     if (res.result.ok) {
                         resolve(doc);
                     }
                     else {
                         reject(res.result.ok);
                     }
-                }, err => {
+                }, function (err) {
                     reject(err);
                 });
             }
         });
-    }
-    listIndexes(options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).listIndexes(options);
-    }
-    reIndex(options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).reIndex(options);
-    }
-    rename(newName, options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).rename(newName, options);
-    }
-    replaceOne(filter, replacement, options, bypassLogs = false, bypassDocument = false) {
-        return new Promise(async (resolve, reject) => {
-            const validation = this.simplschema.newContext().validate(replacement);
-            if (!validation.isValid()) {
-                console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
-                ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on replaceOne - ' + this.collectionName, [validation.validationErrors(), replacement]);
-                reject(validation.validationErrors());
-            }
-            else {
-                if (this.timestamps) {
-                    replacement['updatedAt'] = new Date();
-                }
-                if (!bypassDocument) {
-                    let doc = await this.findOne(filter);
-                    if (doc) {
+    };
+    Collection.prototype.listIndexes = function (options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).listIndexes(options);
+    };
+    Collection.prototype.reIndex = function (options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).reIndex(options);
+    };
+    Collection.prototype.rename = function (newName, options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).rename(newName, options);
+    };
+    Collection.prototype.replaceOne = function (filter, replacement, options, bypassLogs, bypassDocument) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        if (bypassDocument === void 0) { bypassDocument = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, doc, versionDoc, prevDoc, docId, docVersion, updatedDoc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        validation = this.simplschema.newContext().validate(replacement);
+                        if (!!validation.isValid()) return [3 /*break*/, 1];
+                        console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
+                        index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on replaceOne - ' + this.collectionName, [validation.validationErrors(), replacement]);
+                        reject(validation.validationErrors());
+                        return [3 /*break*/, 11];
+                    case 1:
+                        if (this.timestamps) {
+                            replacement['updatedAt'] = new Date();
+                        }
+                        if (!!bypassDocument) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.findOne(filter)];
+                    case 2:
+                        doc = _a.sent();
+                        if (!doc) return [3 /*break*/, 8];
                         if (this.createLogs && !bypassLogs) {
-                            Logs.insertOne({
+                            log_collection_1.Logs.insertOne({
                                 _id: objectIdHexString(),
                                 type: 'document',
                                 collection: this.collectionName,
                                 id_document: doc['_id'],
-                                payload: getBinarySize(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
+                                payload: 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: '',
@@ -639,402 +800,503 @@ export class Collection {
                                 route: ''
                             });
                         }
-                        if (this.useVersions) {
-                            let versionDoc = deepCopy(doc);
-                            versionDoc['_id'] = { _id: doc['_id'], __v: doc['__v'] };
-                            ResolveIOServer.getMongoManager().collection(this.versionCollection).insertOne(versionDoc);
-                            if (doc['__v'] >= 4) {
-                                ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [
-                                        { '_id._id': doc['_id'] },
-                                        { '_id.__v': { $lte: doc['__v'] - 4 } }
-                                    ] });
-                            }
-                            if (doc['__v'] === replacement['__v']) {
-                                replacement['__v'] += 1;
-                                ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, replacement, options).then(res => {
-                                    if (res.result.ok) {
-                                        resolve(res.result.nModified);
-                                    }
-                                    else {
-                                        reject(res.result.ok);
-                                    }
-                                }, err => {
-                                    reject(err);
-                                });
+                        if (!this.useVersions) return [3 /*break*/, 6];
+                        versionDoc = common_1.deepCopy(doc);
+                        versionDoc['_id'] = { _id: doc['_id'], __v: doc['__v'] };
+                        index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).insertOne(versionDoc);
+                        if (doc['__v'] >= 4) {
+                            index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [
+                                    { '_id._id': doc['_id'] },
+                                    { '_id.__v': { $lte: doc['__v'] - 4 } }
+                                ] });
+                        }
+                        if (!(doc['__v'] === replacement['__v'])) return [3 /*break*/, 3];
+                        replacement['__v'] += 1;
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, replacement, options).then(function (res) {
+                            if (res.result.ok) {
+                                resolve(res.result.nModified);
                             }
                             else {
-                                console.log('invalid version - ' + this.collectionName, doc['__v'], replacement['__v']);
-                                let prevDoc = await ResolveIOServer.getMongoManager().collection(this.versionCollection).findOne({
-                                    $and: [
-                                        { '_id._id': doc['_id'] },
-                                        { '_id.__v': replacement['__v'] }
-                                    ]
-                                });
-                                if (prevDoc) {
-                                    let docId = doc['_id'];
-                                    let docVersion = doc['__v'];
-                                    let updatedDoc = getMongoMergeUpdatedDoc(replacement, doc, prevDoc);
-                                    updatedDoc['_id'] = docId;
-                                    updatedDoc['__v'] = docVersion + 1;
-                                    updatedDoc['updatedAt'] = new Date();
-                                    ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, updatedDoc, options).then(res => {
-                                        if (res.result.ok) {
-                                            resolve(res.result.nModified);
-                                        }
-                                        else {
-                                            reject(res.result.ok);
-                                        }
-                                    }, err => {
-                                        reject(err);
-                                    });
-                                }
-                                else {
-                                    reject('Invalid Version And Could Not Find History - DB: ' + doc['__v'] + ', Trying to update with :' + replacement['__v']);
-                                }
+                                reject(res.result.ok);
                             }
-                        }
-                        else {
-                            ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, replacement, options).then(res => {
+                        }, function (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({
+                                $and: [
+                                    { '_id._id': doc['_id'] },
+                                    { '_id.__v': replacement['__v'] }
+                                ]
+                            })];
+                    case 4:
+                        prevDoc = _a.sent();
+                        if (prevDoc) {
+                            docId = doc['_id'];
+                            docVersion = doc['__v'];
+                            updatedDoc = common_1.getMongoMergeUpdatedDoc(replacement, doc, prevDoc);
+                            updatedDoc['_id'] = docId;
+                            updatedDoc['__v'] = docVersion + 1;
+                            updatedDoc['updatedAt'] = new Date();
+                            index_1.ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, updatedDoc, options).then(function (res) {
                                 if (res.result.ok) {
                                     resolve(res.result.nModified);
                                 }
                                 else {
                                     reject(res.result.ok);
                                 }
-                            }, err => {
+                            }, function (err) {
                                 reject(err);
                             });
                         }
-                    }
-                    else {
-                        reject('No Document');
-                    }
-                }
-                else {
-                    ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, replacement, options).then(res => {
-                        if (res.result.ok) {
-                            resolve(res.result.nModified);
-                        }
                         else {
-                            reject(res.result.ok);
-                        }
-                    }, err => {
-                        reject(err);
-                    });
-                }
-            }
-        });
-    }
-    stats(options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).stats(options);
-    }
-    updateMany(filter, update, options, bypassLogs = false) {
-        return new Promise(async (resolve, reject) => {
-            if (this.timestamps) {
-                if (!update.$set) {
-                    update.$set = { updatedAt: new Date() };
-                }
-                else {
-                    update.$set['updatedAt'] = new Date();
-                }
-            }
-            const validation = this.simplschema.newContext().validate(update, { modifier: true });
-            if (!validation.isValid()) {
-                console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
-                ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on updateMany - ' + this.collectionName, [validation.validationErrors(), update]);
-                reject(validation.validationErrors());
-            }
-            else {
-                if (this.createLogs && !bypassLogs) {
-                    let docs = await this.find(filter);
-                    docs.forEach(doc => {
-                        Logs.insertOne({
-                            _id: objectIdHexString(),
-                            type: 'document',
-                            collection: this.collectionName,
-                            id_document: doc['_id'],
-                            payload: getBinarySize(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
-                            method: 'updateMany',
-                            id_user: '',
-                            user: '',
-                            messageId: '',
-                            route: ''
-                        });
-                    });
-                }
-                ResolveIOServer.getMainDB().collection(this.collectionName).updateMany(filter, update, options).then(res => {
-                    if (res.result.ok) {
-                        resolve(res.result.nModified);
-                    }
-                    else {
-                        reject(res.result.ok);
-                    }
-                }, err => reject(err));
-            }
-        });
-    }
-    updateOne(filter, update, options, bypassLogs = false) {
-        return new Promise(async (resolve, reject) => {
-            if (this.timestamps) {
-                if (!update.$set) {
-                    update.$set = { updatedAt: new Date() };
-                }
-                else {
-                    update.$set['updatedAt'] = new Date();
-                }
-            }
-            const validation = this.simplschema.newContext().validate(update, { modifier: true });
-            if (!validation.isValid()) {
-                console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
-                ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on updateOne - ' + this.collectionName, [validation.validationErrors(), update]);
-                reject(validation.validationErrors());
-            }
-            else {
-                let doc = await this.findOne(filter);
-                if (doc) {
-                    if (this.createLogs && !bypassLogs) {
-                        Logs.insertOne({
-                            _id: objectIdHexString(),
-                            type: 'document',
-                            collection: this.collectionName,
-                            id_document: doc['_id'],
-                            payload: getBinarySize(JSON.stringify([doc, filter, update, options])) < 200000 ? JSON.stringify([doc, filter, update, options], null, 2) : 'Too Big',
-                            method: 'updateOne',
-                            id_user: '',
-                            user: '',
-                            messageId: '',
-                            route: ''
-                        });
-                    }
-                    if (this.useVersions) {
-                        let versionDoc = deepCopy(doc);
-                        versionDoc['_id'] = { _id: doc['_id'], __v: doc['__v'] };
-                        ResolveIOServer.getMongoManager().collection(this.versionCollection).insertOne(versionDoc);
-                        if (doc['__v'] >= 4) {
-                            ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [
-                                    { '_id._id': doc['_id'] },
-                                    { '_id.__v': { $lte: doc['__v'] - 4 } }
-                                ] });
-                        }
-                        if (!update.$inc) {
-                            update.$inc = { __v: 1 };
-                        }
-                        else if (!update.$inc.__v) {
-                            update.$inc.__v = 1;
+                            reject('Invalid Version And Could Not Find History - DB: ' + doc['__v'] + ', Trying to update with :' + replacement['__v']);
                         }
-                        ResolveIOServer.getMainDB().collection(this.collectionName).updateOne(filter, update, options).then(res => {
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, replacement, options).then(function (res) {
                             if (res.result.ok) {
                                 resolve(res.result.nModified);
                             }
                             else {
                                 reject(res.result.ok);
                             }
-                        }, err => reject(err));
-                    }
-                    else {
-                        ResolveIOServer.getMainDB().collection(this.collectionName).updateOne(filter, update, options).then(res => {
+                        }, function (err) {
+                            reject(err);
+                        });
+                        _a.label = 7;
+                    case 7: return [3 /*break*/, 9];
+                    case 8:
+                        reject('No Document');
+                        _a.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, replacement, options).then(function (res) {
                             if (res.result.ok) {
                                 resolve(res.result.nModified);
                             }
                             else {
                                 reject(res.result.ok);
                             }
-                        }, err => reject(err));
-                    }
-                }
-                else {
-                    reject('No Document');
+                        }, function (err) {
+                            reject(err);
+                        });
+                        _a.label = 11;
+                    case 11: return [2 /*return*/];
                 }
-            }
-        });
-    }
-    watchCollection(pipeline = [], options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).watch(pipeline, options);
-    }
-    watchCollectionWithAggregate(pipeline = [], options) {
-        return ResolveIOServer.getMainDB().collection(this.collectionName).watch(pipeline, options);
-    }
-}
-export class UserCollection extends Collection {
-    authenticateStrategy() {
-        return async (username, password, cb) => {
-            let user = await Users.findOne({ username: username });
-            this.authenticate(user, password).then(authUser => {
-                if (authUser.data) {
-                    cb(null, user, null);
+            });
+        }); });
+    };
+    Collection.prototype.stats = function (options) {
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).stats(options);
+    };
+    Collection.prototype.updateMany = function (filter, update, options, bypassLogs) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, docs;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.timestamps) {
+                            if (!update.$set) {
+                                update.$set = { updatedAt: new Date() };
+                            }
+                            else {
+                                update.$set['updatedAt'] = new Date();
+                            }
+                        }
+                        validation = this.simplschema.newContext().validate(update, { modifier: true });
+                        if (!!validation.isValid()) return [3 /*break*/, 1];
+                        console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
+                        index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on updateMany - ' + this.collectionName, [validation.validationErrors(), update]);
+                        reject(validation.validationErrors());
+                        return [3 /*break*/, 4];
+                    case 1:
+                        if (!(this.createLogs && !bypassLogs)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.find(filter)];
+                    case 2:
+                        docs = _a.sent();
+                        docs.forEach(function (doc) {
+                            log_collection_1.Logs.insertOne({
+                                _id: objectIdHexString(),
+                                type: 'document',
+                                collection: _this.collectionName,
+                                id_document: doc['_id'],
+                                payload: 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: '',
+                                route: ''
+                            });
+                        });
+                        _a.label = 3;
+                    case 3:
+                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).updateMany(filter, update, options).then(function (res) {
+                            if (res.result.ok) {
+                                resolve(res.result.nModified);
+                            }
+                            else {
+                                reject(res.result.ok);
+                            }
+                        }, function (err) { return reject(err); });
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
                 }
-                else {
-                    cb(null, null, authUser.error);
+            });
+        }); });
+    };
+    Collection.prototype.updateOne = function (filter, update, options, bypassLogs) {
+        var _this = this;
+        if (bypassLogs === void 0) { bypassLogs = false; }
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var validation, doc, versionDoc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.timestamps) {
+                            if (!update.$set) {
+                                update.$set = { updatedAt: new Date() };
+                            }
+                            else {
+                                update.$set['updatedAt'] = new Date();
+                            }
+                        }
+                        validation = this.simplschema.newContext().validate(update, { modifier: true });
+                        if (!!validation.isValid()) return [3 /*break*/, 1];
+                        console.log(new Date(), this.collectionName, 'Schema Errors', validation.validationErrors());
+                        index_1.ResolveIOServer.getMainServer().getMethodManager().callMethodInternal('insertErrorLog', 'Schema Failed on updateOne - ' + this.collectionName, [validation.validationErrors(), update]);
+                        reject(validation.validationErrors());
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.findOne(filter)];
+                    case 2:
+                        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: 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: '',
+                                    route: ''
+                                });
+                            }
+                            if (this.useVersions) {
+                                versionDoc = common_1.deepCopy(doc);
+                                versionDoc['_id'] = { _id: doc['_id'], __v: doc['__v'] };
+                                index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).insertOne(versionDoc);
+                                if (doc['__v'] >= 4) {
+                                    index_1.ResolveIOServer.getMongoManager().collection(this.versionCollection).deleteMany({ $and: [
+                                            { '_id._id': doc['_id'] },
+                                            { '_id.__v': { $lte: doc['__v'] - 4 } }
+                                        ] });
+                                }
+                                if (!update.$inc) {
+                                    update.$inc = { __v: 1 };
+                                }
+                                else if (!update.$inc.__v) {
+                                    update.$inc.__v = 1;
+                                }
+                                index_1.ResolveIOServer.getMainDB().collection(this.collectionName).updateOne(filter, update, options).then(function (res) {
+                                    if (res.result.ok) {
+                                        resolve(res.result.nModified);
+                                    }
+                                    else {
+                                        reject(res.result.ok);
+                                    }
+                                }, function (err) { return reject(err); });
+                            }
+                            else {
+                                index_1.ResolveIOServer.getMainDB().collection(this.collectionName).updateOne(filter, update, options).then(function (res) {
+                                    if (res.result.ok) {
+                                        resolve(res.result.nModified);
+                                    }
+                                    else {
+                                        reject(res.result.ok);
+                                    }
+                                }, function (err) { return reject(err); });
+                            }
+                        }
+                        else {
+                            reject('No Document');
+                        }
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
                 }
-            }, err => {
-                cb(err, null, null);
             });
-        };
+        }); });
+    };
+    Collection.prototype.watchCollection = function (pipeline, options) {
+        if (pipeline === void 0) { pipeline = []; }
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).watch(pipeline, options);
+    };
+    Collection.prototype.watchCollectionWithAggregate = function (pipeline, options) {
+        if (pipeline === void 0) { pipeline = []; }
+        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).watch(pipeline, options);
+    };
+    return Collection;
+}());
+exports.Collection = Collection;
+var UserCollection = /** @class */ (function (_super) {
+    __extends(UserCollection, _super);
+    function UserCollection() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    authenticate(user, password) {
-        return new Promise(async (resolve, reject) => {
-            const attemptsInterval = Math.pow(100, Math.log(user.attempts + 1));
-            const calculatedInterval = attemptsInterval < 300000 ? attemptsInterval : 300000;
-            if (user.last) {
-                if (Date.now() - user.last.getTime() < calculatedInterval) {
-                    user.last = new Date();
-                    await Users.updateOne({ _id: user._id }, { $set: { last: user.last } });
-                    resolve({
-                        data: null,
-                        error: 'Attempt Too Soon'
-                    });
-                    return;
-                }
-            }
-            else {
-                user.last = new Date();
-            }
-            if (user.attempts >= 5) {
-                resolve({
-                    data: null,
-                    error: 'Too Many Attempts'
-                });
-                return;
-            }
-            if (!user.salt) {
-                resolve({
-                    data: null,
-                    error: 'No Salt Value Stored'
-                });
-                return;
-            }
-            pbkdf2(password, user.salt, {
-                iterations: 25000,
-                keylen: 512,
-                digestAlgorithm: 'sha256'
-            }, async (err, hashBuffer) => {
-                if (err) {
-                    return reject(err);
-                }
-                if (scmp(hashBuffer, Buffer.from(user.hash, 'hex'))) {
-                    user.last = new Date();
-                    user.attempts = 0;
-                    await Users.updateOne({ _id: user._id }, { $set: { last: user.last, attempts: user.attempts } });
-                    resolve({
-                        data: user,
-                        error: ''
-                    });
-                }
-                else {
-                    user.last = new Date();
-                    user.attempts = user.attempts + 1;
-                    await Users.updateOne({ _id: user._id }, { $set: { last: user.last, attempts: user.attempts } });
-                    if (user.attempts >= 5) {
-                        resolve({
-                            data: null,
-                            error: 'Too Many Attempts'
+    UserCollection.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);
                         });
-                    }
-                    else {
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+    };
+    UserCollection.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: 'Invalid Username And Password'
+                            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*/];
                 }
             });
-        });
-    }
-    serializeUser() {
-        return (user, cb) => {
+        }); });
+    };
+    UserCollection.prototype.serializeUser = function () {
+        return function (user, cb) {
             cb(null, user.username);
         };
-    }
-    deserializeUser() {
-        return (username, cb) => {
-            Users.findOne({ username: username }).then(res => {
+    };
+    UserCollection.prototype.deserializeUser = function () {
+        return function (username, cb) {
+            user_collection_1.Users.findOne({ username: username }).then(function (res) {
                 cb(null, res);
-            }, err => {
+            }, function (err) {
                 cb(err, null);
             });
         };
-    }
-    setPassword(user, password) {
-        return new Promise(async (resolve, reject) => {
-            if (!user) {
-                reject('No User');
-            }
-            else if (!password) {
-                reject('No Password');
-            }
-            else {
-                let saltBuffer = await randomBytes(32);
-                let salt = saltBuffer.toString('hex');
-                let hashRaw = await pbkdf2Promisified(password, salt, {
-                    iterations: 25000,
-                    keylen: 512,
-                    digestAlgorithm: 'sha256'
-                });
-                let hash = Buffer.from(hashRaw, 'binary').toString('hex');
-                await Users.updateOne({ _id: user._id }, { $set: { hash: hash, salt: salt, services: {} } });
-            }
-        });
-    }
-    ;
-    changePassword(user, oldPassword, newPassword) {
-        return new Promise(async (resolve, reject) => {
-            if (!user) {
-                reject('Missing User');
-            }
-            else if (!oldPassword || !newPassword) {
-                reject('Missing Password');
-            }
-            else {
-                let authUser = await this.authenticate(user, oldPassword);
-                if (!authUser['data']) {
-                    reject(authUser['error']);
-                }
-                else {
-                    this.setPassword(user, newPassword);
+    };
+    UserCollection.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*/, 6];
+                    case 1:
+                        if (!!password) return [3 /*break*/, 2];
+                        reject('No Password');
+                        return [3 /*break*/, 6];
+                    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');
+                        return [4 /*yield*/, user_collection_1.Users.updateOne({ _id: user._id }, { $set: { hash: hash, salt: salt, services: {} } })];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
                 }
-            }
-        });
-    }
-    register(user, password) {
-        return new Promise(async (resolve, reject) => {
-            if (!user.username) {
-                reject('Missing Username');
-            }
-            else {
-                let dbUser = await Users.findOne({ username: user.username });
-                if (dbUser) {
-                    reject('Username Exists');
+            });
+        }); });
+    };
+    ;
+    UserCollection.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);
+                        }
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
                 }
-                else {
-                    dbUser = await Users.findOne({ email: user.email });
-                    if (dbUser) {
-                        reject('Email Exists');
-                    }
-                    else {
-                        user.setPassword(password);
-                        resolve(user);
-                    }
+            });
+        }); });
+    };
+    UserCollection.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*/];
                 }
-            }
-        });
-    }
-    resetAttempts(user) {
-        return Users.updateOne({ _id: user._id }, { $set: { attempts: 0 } });
-    }
-}
-export function objectIdHexString() {
-    let objectId = new ObjectId();
+            });
+        }); });
+    };
+    UserCollection.prototype.resetAttempts = function (user) {
+        return user_collection_1.Users.updateOne({ _id: user._id }, { $set: { attempts: 0 } });
+    };
+    return UserCollection;
+}(Collection));
+exports.UserCollection = UserCollection;
+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((resolve, reject) => pbkdf2(password, salt, options, (err, hashRaw) => (err ? reject(err) : resolve(hashRaw))));
+    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((resolve, reject) => crypto.randomBytes(saltlen, (err, saltBuffer) => (err ? reject(err) : resolve(saltBuffer))));
+    return new Promise(function (resolve, reject) { return crypto.randomBytes(saltlen, function (err, saltBuffer) { return (err ? reject(err) : resolve(saltBuffer)); }); });
 }
 
 //# sourceMappingURL=mongo.manager.js.map