@resolveio/server-lib 9.0.32 → 9.0.34

package/managers/mongo.manager.js

@@ -1,81 +1,29 @@
-"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() {
+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() {
         this._collections = [];
         this._mongoQueue = [];
         this._mongoQueueId = 0;
         this.runQueue();
     }
-    MongoManager.prototype.registerCollection = function (collection) {
+    registerCollection(collection) {
         this._collections.push(collection);
-    };
-    MongoManager.prototype.collections = function () {
+    }
+    collections() {
         return this._collections;
-    };
-    MongoManager.prototype.collection = function (collectionName) {
-        return this._collections.filter(function (a) { return a.collectionName === collectionName; })[0];
-    };
-    MongoManager.prototype.addToQueue = function (mongoQueue) {
-        var _mongoQueue = this._mongoQueue.filter(function (a) { return a.name_collection === mongoQueue.name_collection && a.name_function === mongoQueue.name_function && a.name_function_addt === mongoQueue.name_function_addt && JSON.stringify(a.data_function) === JSON.stringify(mongoQueue.data_function) && JSON.stringify(a.data_function_addt) === JSON.stringify(mongoQueue.data_function_addt); })[0];
+    }
+    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];
         if (_mongoQueue) {
             if (!_mongoQueue.running) {
                 _mongoQueue.cbs.push(mongoQueue.cbs[0]);
@@ -89,78 +37,64 @@ var MongoManager = /** @class */ (function () {
             this._mongoQueueId += 1;
             this._mongoQueue.push(mongoQueue);
         }
-    };
-    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);
-                            });
+    }
+    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 {
-                            (_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);
-                            });
+                            this._mongoQueue.splice(this._mongoQueue.map(a => a._id).indexOf(mongoQueue._id), 1);
                         }
-                    }
-                }, 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; }
+                    }, 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???
+                        }
+                        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);
+                    });
+                }
+            }
+        }, 10);
+    }
+}
+export class Model {
+    constructor(collectionName, schema, useVersionCollection = false, useReportBuilder = true, reportBuilderLookupTables = [], timestamps = true, createLogs = true) {
         this.collection_main = null;
         this.collection_version = null;
         if (collectionName === 'users') {
@@ -170,7 +104,8 @@ var Model = /** @class */ (function () {
             this.collection_main = new Collection(collectionName, schema, useReportBuilder, reportBuilderLookupTables, timestamps, createLogs);
         }
         if (useVersionCollection) {
-            var versionSchema = common_1.deepCopy(schema);
+            this.collection_main.useVersions = true;
+            let versionSchema = deepCopy(schema);
             versionSchema['_id'].type = 'Object';
             versionSchema['_id'].blackbox = true;
             if (collectionName === 'users') {
@@ -183,48 +118,44 @@ var Model = /** @class */ (function () {
             this.collection_main.versionCollection = collectionName + '.versions';
         }
     }
-    return Model;
-}());
-exports.Model = Model;
-var Collection = /** @class */ (function () {
-    function Collection(collectionName, schema, useReportBuilder, reportBuilderLookupTables, timestamps, createLogs) {
-        var _this = this;
+}
+export class Collection {
+    constructor(collectionName, schema, useReportBuilder, reportBuilderLookupTables, timestamps, createLogs) {
         this.collectionName = '';
         this.simplschema = null;
         this.rbSchema = null;
         this.timestamps = false;
-        this.versionKey = '';
+        this.useVersions = false;
         this.versionCollection = '';
         this.createLogs = true;
         this.useRB = false;
         this.collectionName = collectionName;
-        this.simplschema = new simpl_schema_1.default(schema);
+        this.simplschema = new SimpleSchema(schema);
         this.timestamps = timestamps;
         this.createLogs = createLogs;
         if (useReportBuilder) {
             this.useRB = true;
-            var schemaCopy = common_1.deepCopy(schema);
-            var rbSchema = common_1.buildRbLookups(reportBuilderLookupTables, schemaCopy, []);
-            this.rbSchema = common_1.buildRbSchema(rbSchema);
+            let schemaCopy = deepCopy(schema);
+            let rbSchema = buildRbLookups(reportBuilderLookupTables, schemaCopy, []);
+            this.rbSchema = buildRbSchema(rbSchema);
         }
-        var interval = setInterval(function () {
-            if (index_1.ResolveIOServer && index_1.ResolveIOServer.getMainServer() && index_1.ResolveIOServer.getMongoManager()) {
-                index_1.ResolveIOServer.getMongoManager().registerCollection(_this);
+        let interval = setInterval(() => {
+            if (ResolveIOServer && ResolveIOServer.getMainServer() && ResolveIOServer.getMongoManager()) {
+                ResolveIOServer.getMongoManager().registerCollection(this);
                 clearInterval(interval);
             }
         }, 1);
     }
-    Collection.prototype.aggregate = function (pipeline, options) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            index_1.ResolveIOServer.getMongoManager().addToQueue({
+    aggregate(pipeline, options) {
+        return new Promise((resolve, reject) => {
+            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: [function (err, res) {
+                cbs: [(err, res) => {
                         if (err) {
                             reject(err);
                         }
@@ -236,18 +167,17 @@ var Collection = /** @class */ (function () {
                 running: false
             });
         });
-    };
-    Collection.prototype.aggregateCount = function (pipeline, options) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            index_1.ResolveIOServer.getMongoManager().addToQueue({
+    }
+    aggregateCount(pipeline, options) {
+        return new Promise((resolve, reject) => {
+            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: [function (err, res) {
+                cbs: [(err, res) => {
                         if (err) {
                             reject(err);
                         }
@@ -259,136 +189,116 @@ var Collection = /** @class */ (function () {
                 running: false
             });
         });
-    };
-    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 = [];
+    }
+    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 = [];
         if (!Array.isArray(f_docs)) {
             return this.insertOne(f_docs, options);
         }
         return this.insertMany(f_docs, options);
-    };
-    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) {
-        var _this = this;
-        if (filter === void 0) { filter = {}; }
-        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) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.find(filter)];
-                    case 1:
-                        docs = _a.sent();
-                        docs.forEach(function (doc) {
-                            log_collection_1.Logs.create({
-                                _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: ''
-                            });
-                        });
-                        _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*/];
+    }
+    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);
                 }
-            });
-        }); });
-    };
-    Collection.prototype.deleteOne = function (filter, options) {
-        var _this = this;
-        if (filter === void 0) { filter = {}; }
-        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) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.findOne(filter)];
-                    case 1:
-                        doc = _a.sent();
-                        if (doc) {
-                            log_collection_1.Logs.create({
-                                _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: ''
-                            });
-                        }
-                        _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*/];
+                else {
+                    reject(res.result.ok);
                 }
-            });
-        }); });
-    };
-    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) {
-        var _this = this;
-        if (filter === void 0) { filter = {}; }
-        return new Promise(function (resolve, reject) {
-            if (_this.createLogs) {
-                log_collection_1.Logs.create({
+            }, 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);
+                }
+                else {
+                    reject(res.result.ok);
+                }
+            }, 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({
                     _id: objectIdHexString(),
                     type: 'query',
-                    collection: _this.collectionName,
+                    collection: this.collectionName,
                     id_document: '',
-                    payload: common_1.getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
+                    payload: getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
                     method: 'find',
                     id_user: '',
                     user: '',
@@ -396,14 +306,14 @@ var Collection = /** @class */ (function () {
                     route: ''
                 });
             }
-            index_1.ResolveIOServer.getMongoManager().addToQueue({
+            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: [function (err, res) {
+                cbs: [(err, res) => {
                         if (err) {
                             reject(err);
                         }
@@ -415,19 +325,18 @@ var Collection = /** @class */ (function () {
                 running: 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) {
-        if (filter === void 0) { filter = {}; }
-        if (this.createLogs) {
-            log_collection_1.Logs.create({
+    }
+    findById(id, options) {
+        return ResolveIOServer.getMainDB().collection(this.collectionName).findOne({ _id: id }, options);
+    }
+    findCount(filter = {}, options, bypassLogs = false) {
+        if (this.createLogs && !bypassLogs) {
+            Logs.insertOne({
                 _id: objectIdHexString(),
                 type: 'query',
                 collection: this.collectionName,
                 id_document: '',
-                payload: common_1.getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
+                payload: getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
                 method: 'findCount',
                 id_user: '',
                 user: '',
@@ -435,27 +344,23 @@ var Collection = /** @class */ (function () {
                 route: ''
             });
         }
-        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) {
-        var _this = this;
-        if (filter === void 0) { filter = {}; }
-        return new Promise(function (resolve, reject) {
-            if (_this.createLogs) {
-                log_collection_1.Logs.create({
+        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({
                     _id: objectIdHexString(),
                     type: 'query',
-                    collection: _this.collectionName,
+                    collection: this.collectionName,
                     id_document: '',
-                    payload: common_1.getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
+                    payload: getBinarySize(JSON.stringify([filter, options])) < 200000 ? JSON.stringify([filter, options], null, 2) : 'Too Big',
                     method: 'findOne',
                     id_user: '',
                     user: '',
@@ -463,14 +368,14 @@ var Collection = /** @class */ (function () {
                     route: ''
                 });
             }
-            index_1.ResolveIOServer.getMongoManager().addToQueue({
+            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: [function (err, res) {
+                cbs: [(err, res) => {
                         if (err) {
                             reject(err);
                         }
@@ -482,248 +387,251 @@ var Collection = /** @class */ (function () {
                 running: false
             });
         });
-    };
-    Collection.prototype.findOneAndDelete = function (filter, options) {
-        var _this = this;
-        if (filter === void 0) { filter = {}; }
-        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) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.findOne(filter)];
-                    case 1:
-                        doc = _a.sent();
-                        if (doc) {
-                            log_collection_1.Logs.create({
-                                _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*/];
+    }
+    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: ''
+                    });
                 }
-            });
-        }); });
-    };
-    Collection.prototype.findOneAndReplace = function (filter, replacement, options) {
-        var _this = this;
-        if (filter === void 0) { filter = {}; }
-        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:
-                        replacement['updatedAt'] = new Date();
-                        if (!this.createLogs) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.findOne(filter)];
-                    case 1:
-                        doc = _a.sent();
-                        if (doc) {
-                            log_collection_1.Logs.create({
-                                _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 = 2;
-                    case 2:
-                        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); });
-                        return [2 /*return*/];
+            }
+            ResolveIOServer.getMainDB().collection(this.collectionName).findOneAndDelete(filter, options).then(res => {
+                if (res.ok) {
+                    resolve(res.value);
                 }
-            });
-        }); });
-    };
-    Collection.prototype.findOneAndUpdate = function (filter, update, options) {
-        var _this = this;
-        if (filter === void 0) { filter = {}; }
-        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 (!update['$set']) {
-                            update['$set'] = { updatedAt: new Date() };
-                        }
-                        else {
-                            update['$set']['updatedAt'] = new Date();
-                        }
-                        if (!this.createLogs) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.findOne(filter)];
-                    case 1:
-                        doc = _a.sent();
-                        if (doc) {
-                            log_collection_1.Logs.create({
-                                _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 = 2;
-                    case 2:
-                        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); });
-                        return [2 /*return*/];
+                else {
+                    reject(res.lastErrorObject);
                 }
-            });
-        }); });
-    };
-    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) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (!docs || !docs.length) {
-                reject('No documents');
+            }, 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: ''
+                        });
+                    }
+                }
+                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();
+                    }
+                }
+                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: ''
+                        });
+                    }
+                }
+                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) => {
+            if (!docs.length) {
+                reject('No Documents');
                 return;
             }
-            if (_this.timestamps) {
-                docs.forEach(function (doc) {
+            let validationResults = [];
+            docs.forEach(doc => {
+                const 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]);
+                    validationResults.push(false);
+                }
+                else {
+                    validationResults.push(true);
+                }
+            });
+            let validDocs = docs.filter((a, idx) => validationResults[idx]);
+            validDocs.forEach(doc => {
+                if (this.timestamps) {
                     doc['createdAt'] = new Date();
                     doc['updatedAt'] = new Date();
-                });
-            }
-            if (_this.createLogs) {
-                docs.forEach(function (doc) {
-                    log_collection_1.Logs.create({
+                }
+                if (this.createLogs && !bypassLogs) {
+                    Logs.insertOne({
                         _id: objectIdHexString(),
                         type: 'document',
-                        collection: _this.collectionName,
+                        collection: this.collectionName,
                         id_document: doc['_id'],
-                        payload: common_1.getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
+                        payload: getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
                         method: 'insertMany',
                         id_user: '',
                         user: '',
                         messageId: '',
                         route: ''
                     });
-                });
-            }
-            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName).insertMany(docs, options).then(function (res) {
-                if (res.result.ok) {
-                    resolve(docs);
-                }
-                else {
-                    reject(res.result.ok);
                 }
-            }, function (err) {
-                reject(err);
             });
-        });
-    };
-    Collection.prototype.insertOne = function (doc, options) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (!doc) {
-                reject('No document');
-                return;
-            }
-            if (_this.timestamps) {
-                doc['createdAt'] = new Date();
-                doc['updatedAt'] = new Date();
-            }
-            if (_this.createLogs) {
-                log_collection_1.Logs.create({
-                    _id: objectIdHexString(),
-                    type: 'document',
-                    collection: _this.collectionName,
-                    id_document: doc['_id'],
-                    payload: common_1.getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
-                    method: 'insertOne',
-                    id_user: '',
-                    user: '',
-                    messageId: '',
-                    route: ''
+            if (validDocs.length) {
+                ResolveIOServer.getMainDB().collection(this.collectionName).insertMany(validDocs, options).then(res => {
+                    if (res.result.ok) {
+                        resolve(validDocs);
+                    }
+                    else {
+                        reject(res.result.ok);
+                    }
+                }, err => {
+                    reject(err);
                 });
             }
-            index_1.ResolveIOServer.getMainDB().collection(_this.collectionName).insertOne(doc, options).then(function (res) {
-                if (res.result.ok) {
-                    resolve(doc);
+        });
+    }
+    insertOne(doc, options, bypassLogs = false) {
+        return new Promise((resolve, reject) => {
+            const 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]);
+                reject(validation.validationErrors());
+            }
+            else {
+                if (this.timestamps) {
+                    doc['createdAt'] = new Date();
+                    doc['updatedAt'] = new Date();
                 }
-                else {
-                    reject(res.result.ok);
+                if (this.createLogs && !bypassLogs) {
+                    Logs.insertOne({
+                        _id: objectIdHexString(),
+                        type: 'document',
+                        collection: this.collectionName,
+                        id_document: doc['_id'],
+                        payload: getBinarySize(JSON.stringify([doc, options])) < 200000 ? JSON.stringify([doc, options], null, 2) : 'Too Big',
+                        method: 'insertOne',
+                        id_user: '',
+                        user: '',
+                        messageId: '',
+                        route: ''
+                    });
                 }
-            }, function (err) {
-                reject(err);
-            });
+                ResolveIOServer.getMainDB().collection(this.collectionName).insertOne(doc, options).then(res => {
+                    if (res.result.ok) {
+                        resolve(doc);
+                    }
+                    else {
+                        reject(res.result.ok);
+                    }
+                }, err => {
+                    reject(err);
+                });
+            }
         });
-    };
-    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) {
-        var _this = this;
-        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) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.findOne(filter)];
-                    case 1:
-                        doc = _a.sent();
-                        if (doc) {
-                            log_collection_1.Logs.create({
+    }
+    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) {
+                        if (this.createLogs && !bypassLogs) {
+                            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',
+                                payload: getBinarySize(JSON.stringify([doc, filter, replacement, options])) < 200000 ? JSON.stringify([doc, filter, replacement, options], null, 2) : 'Too Big',
                                 method: 'replaceOne',
                                 id_user: '',
                                 user: '',
@@ -731,381 +639,402 @@ var Collection = /** @class */ (function () {
                                 route: ''
                             });
                         }
-                        _a.label = 2;
-                    case 2:
-                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, replacement, options).then(function (res) {
-                            if (res.result.ok) {
-                                resolve(res.result.nModified);
+                        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);
+                                });
                             }
                             else {
-                                reject(res.result.ok);
+                                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']);
+                                }
                             }
-                        }, function (err) {
-                            reject(err);
-                        });
-                        return [2 /*return*/];
+                        }
+                        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);
+                            });
+                        }
+                    }
+                    else {
+                        reject('No Document');
+                    }
                 }
-            });
-        }); });
-    };
-    Collection.prototype.stats = function (options) {
-        return index_1.ResolveIOServer.getMainDB().collection(this.collectionName).stats(options);
-    };
-    Collection.prototype.updateMany = function (filter, update, options) {
-        var _this = this;
-        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 (!update['$set']) {
-                            update['$set'] = { updatedAt: new Date() };
+                else {
+                    ResolveIOServer.getMainDB().collection(this.collectionName).replaceOne(filter, replacement, options).then(res => {
+                        if (res.result.ok) {
+                            resolve(res.result.nModified);
                         }
                         else {
-                            update['$set']['updatedAt'] = new Date();
+                            reject(res.result.ok);
                         }
-                        if (!this.createLogs) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.find(filter)];
-                    case 1:
-                        docs = _a.sent();
-                        docs.forEach(function (doc) {
-                            log_collection_1.Logs.create({
-                                _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: ''
-                            });
+                    }, 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: ''
                         });
-                        _a.label = 2;
-                    case 2:
-                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).updateMany(filter, update, options).then(function (res) {
+                    }
+                    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;
+                        }
+                        ResolveIOServer.getMainDB().collection(this.collectionName).updateOne(filter, update, options).then(res => {
                             if (res.result.ok) {
                                 resolve(res.result.nModified);
                             }
                             else {
                                 reject(res.result.ok);
                             }
-                        }, function (err) { return reject(err); });
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        return;
-    };
-    Collection.prototype.updateOne = function (filter, update, options) {
-        var _this = this;
-        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 (!update['$set']) {
-                            update['$set'] = { updatedAt: new Date() };
-                        }
-                        else {
-                            update['$set']['updatedAt'] = new Date();
-                        }
-                        if (!this.createLogs) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.findOne(filter)];
-                    case 1:
-                        doc = _a.sent();
-                        if (doc) {
-                            log_collection_1.Logs.create({
-                                _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: ''
-                            });
-                        }
-                        _a.label = 2;
-                    case 2:
-                        index_1.ResolveIOServer.getMainDB().collection(this.collectionName).updateOne(filter, update, options).then(function (res) {
+                        }, err => reject(err));
+                    }
+                    else {
+                        ResolveIOServer.getMainDB().collection(this.collectionName).updateOne(filter, update, options).then(res => {
                             if (res.result.ok) {
                                 resolve(res.result.nModified);
                             }
                             else {
                                 reject(res.result.ok);
                             }
-                        }, function (err) { return reject(err); });
-                        return [2 /*return*/];
+                        }, err => reject(err));
+                    }
                 }
-            });
-        }); });
-    };
-    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;
+                else {
+                    reject('No Document');
+                }
+            }
+        });
     }
-    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);
-                        });
-                        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);
+                }
+                else {
+                    cb(null, null, authUser.error);
                 }
+            }, err => {
+                cb(err, null, null);
             });
-        }); };
-    };
-    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();
+        };
+    }
+    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: 'Attempt Too Soon'
+                            error: 'Too Many Attempts'
                         });
-                        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*/];
+                    }
+                    else {
+                        resolve({
+                            data: null,
+                            error: 'Invalid Username And Password'
+                        });
+                    }
                 }
             });
-        }); });
-    };
-    UserCollection.prototype.serializeUser = function () {
-        return function (user, cb) {
+        });
+    }
+    serializeUser() {
+        return (user, cb) => {
             cb(null, user.username);
         };
-    };
-    UserCollection.prototype.deserializeUser = function () {
-        return function (username, cb) {
-            user_collection_1.Users.findOne({ username: username }).then(function (res) {
+    }
+    deserializeUser() {
+        return (username, cb) => {
+            Users.findOne({ username: username }).then(res => {
                 cb(null, res);
-            }, function (err) {
+            }, err => {
                 cb(err, null);
             });
         };
-    };
-    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*/];
-                }
-            });
-        }); });
-    };
+    }
+    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: {} } });
+            }
+        });
+    }
     ;
-    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*/];
+    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']);
                 }
-            });
-        }); });
-    };
-    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*/];
+                else {
+                    this.setPassword(user, newPassword);
                 }
-            });
-        }); });
-    };
-    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();
+            }
+        });
+    }
+    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');
+                }
+                else {
+                    dbUser = await Users.findOne({ email: user.email });
+                    if (dbUser) {
+                        reject('Email Exists');
+                    }
+                    else {
+                        user.setPassword(password);
+                        resolve(user);
+                    }
+                }
+            }
+        });
+    }
+    resetAttempts(user) {
+        return Users.updateOne({ _id: user._id }, { $set: { attempts: 0 } });
+    }
+}
+export function objectIdHexString() {
+    let objectId = new ObjectId();
     return objectId.toHexString();
 }
-exports.objectIdHexString = objectIdHexString;
 function pbkdf2(password, salt, options, callback) {
     crypto.pbkdf2(password, salt, options.iterations, options.keylen, options.digestAlgorithm, callback);
 }
 ;
 function pbkdf2Promisified(password, salt, options) {
-    return new Promise(function (resolve, reject) { return pbkdf2(password, salt, options, function (err, hashRaw) { return (err ? reject(err) : resolve(hashRaw)); }); });
+    return new Promise((resolve, reject) => pbkdf2(password, salt, options, (err, hashRaw) => (err ? reject(err) : resolve(hashRaw))));
 }
 function randomBytes(saltlen) {
-    return new Promise(function (resolve, reject) { return crypto.randomBytes(saltlen, function (err, saltBuffer) { return (err ? reject(err) : resolve(saltBuffer)); }); });
+    return new Promise((resolve, reject) => crypto.randomBytes(saltlen, (err, saltBuffer) => (err ? reject(err) : resolve(saltBuffer))));
 }
 
 //# sourceMappingURL=mongo.manager.js.map