@resolveio/server-lib 9.0.32 → 9.0.34

package/methods/collections.js

@@ -1,33 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadCollectionMethods = void 0;
-var common_1 = require("../util/common");
-var simpl_schema_1 = require("simpl-schema");
-var pagination_model_1 = require("../models/pagination.model");
-var index_1 = require("../index");
-var mongo_manager_1 = require("../managers/mongo.manager");
-function loadCollectionMethods(methodManager) {
+import { deepCopy, getMongoMergeUpdatedDoc } from '../util/common';
+import SimpleSchema from 'simpl-schema';
+import { PaginationOptionsSchema } from '../models/pagination.model';
+import { ResolveIOServer } from '../index';
+import { objectIdHexString } from '../managers/mongo.manager';
+export function loadCollectionMethods(methodManager) {
     methodManager.methods({
         collectionListAll: {
             skipQueue: true,
             function: function () {
-                return new Promise(function (resolve, reject) {
-                    resolve(index_1.ResolveIOServer.getMongoManager().collections().map(function (a) { return a.collectionName; }).sort(function (a, b) { return a.localeCompare(b); }));
+                return new Promise((resolve, reject) => {
+                    resolve(ResolveIOServer.getMongoManager().collections().map(a => a.collectionName).sort((a, b) => a.localeCompare(b)));
                 });
             }
         },
         collectionListRB: {
             skipQueue: true,
             function: function () {
-                return new Promise(function (resolve, reject) {
-                    resolve(index_1.ResolveIOServer.getMongoManager().collections().filter(function (a) { return a.useRB; }).map(function (a) { return a.collectionName; }).sort(function (a, b) { return a.localeCompare(b); }));
+                return new Promise((resolve, reject) => {
+                    resolve(ResolveIOServer.getMongoManager().collections().filter(a => a.useRB).map(a => a.collectionName).sort((a, b) => a.localeCompare(b)));
                 });
             }
         },
         // Query database for any collection and query
         findOne: {
             skipQueue: true,
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -36,21 +33,20 @@ function loadCollectionMethods(methodManager) {
                     blackbox: true
                 }
             }),
-            function: function (collection, query) {
-                if (query === void 0) { query = {}; }
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+            function: function (collection, query = {}) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).findOne(query).then(function (res) { return resolve(res); }, function (err) { return reject(err); });
+                        ResolveIOServer.getMongoManager().collection(collection).findOne(query).then(res => resolve(res), err => reject(err));
                     }
                 });
             }
         },
         find: {
             skipQueue: true,
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -64,22 +60,20 @@ function loadCollectionMethods(methodManager) {
                     optional: true
                 }
             }),
-            function: function (collection, query, sortQuery) {
-                if (query === void 0) { query = {}; }
-                if (sortQuery === void 0) { sortQuery = {}; }
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+            function: function (collection, query = {}, sortQuery = {}) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).find(query, { sort: sortQuery }).then(function (res) { return resolve(res); }, function (err) { return reject(err); });
+                        ResolveIOServer.getMongoManager().collection(collection).find(query, { sort: sortQuery }).then(res => resolve(res), err => reject(err));
                     }
                 });
             }
         },
         findWithOptions: {
             skipQueue: true,
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -88,16 +82,16 @@ function loadCollectionMethods(methodManager) {
                     blackbox: true
                 },
                 options: {
-                    type: pagination_model_1.PaginationOptionsSchema
+                    type: PaginationOptionsSchema
                 }
             }),
             function: function (collection, query, options) {
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        var optionsQuery = {};
+                        let optionsQuery = {};
                         if (options.fields && Object.keys(options.fields).length) {
                             optionsQuery['projection'] = options.fields;
                         }
@@ -110,7 +104,7 @@ function loadCollectionMethods(methodManager) {
                         if (options.skip) {
                             optionsQuery['skip'] = options.skip;
                         }
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).find(query, optionsQuery).then(function (res) { return resolve(res); }, function (err) { return reject(err); });
+                        ResolveIOServer.getMongoManager().collection(collection).find(query, optionsQuery).then(res => resolve(res), err => reject(err));
                     }
                 });
             }
@@ -119,7 +113,7 @@ function loadCollectionMethods(methodManager) {
         // @Inputs: collection, document
         // @Outputs: res = _id of new document, err = not inserted
         insertDocument: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -129,30 +123,15 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, document) {
-                var _this = this;
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        var schemaErrors = null;
-                        try {
-                            index_1.ResolveIOServer.getMongoManager().collection(collection)['simplschema'].validate(document);
-                        }
-                        catch (errors) {
-                            schemaErrors = errors;
-                            _this.callMethodInternal('insertErrorLog', 'Schema Failed on insert - ' + collection, [schemaErrors, document]);
-                        }
-                        if (schemaErrors) {
-                            console.log(schemaErrors);
-                            reject('Schema Errors');
-                        }
-                        else {
-                            var id_1 = mongo_manager_1.objectIdHexString();
-                            document['_id'] = id_1;
-                            document['__v'] = 0;
-                            index_1.ResolveIOServer.getMongoManager().collection(collection).insertOne(document).then(function () { return resolve(id_1); }, function (err) { return reject(err); });
-                        }
+                        let id = objectIdHexString();
+                        document['_id'] = id;
+                        document['__v'] = 0;
+                        ResolveIOServer.getMongoManager().collection(collection).insertOne(document).then(() => resolve(id), err => reject(err));
                     }
                 });
             }
@@ -161,7 +140,7 @@ function loadCollectionMethods(methodManager) {
         // @Inputs: collection, document
         // @Outputs: res = _id of new document, err = not inserted
         insertManyDocuments: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -174,50 +153,26 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, documents) {
-                var _this = this;
-                return new Promise(function (res, rej) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
-                        rej('Invalid collection');
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
+                        reject('Invalid collection');
                     }
                     else {
-                        var promises = [];
-                        var _loop_1 = function (i) {
-                            var document_1 = documents[i];
-                            promises.push(new Promise(function (resolve, reject) {
-                                var schemaErrors = null;
-                                try {
-                                    index_1.ResolveIOServer.getMongoManager().collection(collection)['simplschema'].validate(document_1);
-                                }
-                                catch (errors) {
-                                    schemaErrors = errors;
-                                    _this.callMethodInternal('insertErrorLog', 'Schema Failed on insert - ' + collection, [schemaErrors, document_1]);
-                                }
-                                if (schemaErrors) {
-                                    console.log(schemaErrors);
-                                    reject('Schema Errors');
-                                }
-                                else {
-                                    var id_2 = mongo_manager_1.objectIdHexString();
-                                    document_1['_id'] = id_2;
-                                    document_1['__v'] = 0;
-                                    index_1.ResolveIOServer.getMongoManager().collection(collection).insertOne(document_1).then(function () { return resolve(id_2); }, function (err) { return reject(err); });
-                                }
-                            }));
-                        };
-                        for (var i = 0; i < documents.length; i++) {
-                            _loop_1(i);
-                        }
-                        Promise.all(promises).then(function (vals) { return res(vals); }, function (err) { return rej(err); });
+                        documents.forEach(document => {
+                            document['_id'] = objectIdHexString();
+                            document['__v'] = 0;
+                        });
+                        ResolveIOServer.getMongoManager().collection(collection).insertMany(documents).then(() => resolve(documents.map(a => a['_id'])), err => reject(err));
                     }
                 });
             }
         },
         // Replaces 1 document with new document (from _id)
         // @Inputs: collection, document id
-        // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
+        // @Outputs: res = 1 (updated 1), err = not updated/wrong version
         // Search for doc, check version, if found then try and update
         updateDocument: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -227,130 +182,12 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, f_document) {
-                var _this = this;
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).findOne({ _id: f_document['_id'] }).then(function (currDoc) {
-                            if (currDoc) {
-                                if (currDoc.__v === f_document['__v']) {
-                                    var versionDoc = common_1.deepCopy(currDoc);
-                                    versionDoc._id = {
-                                        _id: currDoc._id,
-                                        __v: currDoc.__v
-                                    };
-                                    var schemaErrors = null;
-                                    try {
-                                        index_1.ResolveIOServer.getMongoManager().collection(collection)['simplschema'].validate(f_document);
-                                    }
-                                    catch (errors) {
-                                        schemaErrors = errors;
-                                        _this.callMethodInternal('insertErrorLog', 'Schema Failed on updateDocument - ' + collection, [schemaErrors, f_document]);
-                                    }
-                                    if (schemaErrors) {
-                                        console.log(schemaErrors);
-                                        reject('Schema Errors');
-                                    }
-                                    else {
-                                        var updates_1 = common_1.getMongoUpdates(currDoc, f_document, true);
-                                        if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                            index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').create(versionDoc).then(function (doc) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                    $and: [
-                                                        { '_id._id': currDoc._id },
-                                                        { '_id.__v': { $lte: currDoc.__v - 4 } }
-                                                    ]
-                                                }).then(function () {
-                                                    if (updates_1) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: f_document['_id'] }, updates_1).then(function (res) {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(1);
-                                                    }
-                                                }, function (err) { return reject(err); });
-                                            }, function (err) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                    $and: [
-                                                        { '_id._id': currDoc._id },
-                                                        { '_id.__v': { $lte: currDoc.__v - 4 } }
-                                                    ]
-                                                }).then(function () {
-                                                    if (updates_1) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: f_document['_id'] }, updates_1).then(function (res) {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(1);
-                                                    }
-                                                }, function (err) { return reject(err); });
-                                            });
-                                        }
-                                        else {
-                                            if (updates_1) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: f_document['_id'] }, updates_1).then(function (res) {
-                                                    resolve(res);
-                                                }, function (err) { return reject(err); });
-                                            }
-                                            else {
-                                                resolve(1);
-                                            }
-                                        }
-                                    }
-                                }
-                                else {
-                                    console.log('invalid version - ' + collection, currDoc.__v, f_document['__v']);
-                                    if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                        index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
-                                            $and: [
-                                                { '_id._id': currDoc._id },
-                                                { '_id.__v': f_document['__v'] }
-                                            ]
-                                        }).then(function (oldDoc) {
-                                            var newCurrDocId = currDoc._id;
-                                            if (oldDoc) {
-                                                var versionDoc_1 = common_1.deepCopy(currDoc);
-                                                versionDoc_1._id = {
-                                                    _id: currDoc._id,
-                                                    __v: currDoc.__v
-                                                };
-                                                var updatedDoc = common_1.getMongoMergeUpdatedDoc(f_document, currDoc, oldDoc);
-                                                updatedDoc._id = newCurrDocId;
-                                                updatedDoc.__v++;
-                                                updatedDoc.updatedAt = new Date();
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).then(function (res) {
-                                                    index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').create(versionDoc_1).then(function (doc) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                            $and: [
-                                                                { '_id._id': versionDoc_1._id._id },
-                                                                { '_id.__v': { $lte: versionDoc_1._id.__v - 4 } }
-                                                            ]
-                                                        }).then(function () {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }, function (err) { return reject(err); });
-                                                }, function (err) { return reject(err); });
-                                            }
-                                            else {
-                                                reject('Invalid Version And Could Not Find History - DB: ' + currDoc.__v + ', Trying to update with :' + f_document['__v']);
-                                            }
-                                        }, function (err) { return reject(err); });
-                                    }
-                                    else {
-                                        reject('Invalid Version And We Are NOT Using Versions On This Collection!');
-                                    }
-                                }
-                            }
-                            else {
-                                reject('No Document');
-                            }
-                        }, function (errDoc) {
-                            reject('No Document');
-                        });
+                        ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: f_document['_id'] }, f_document).then(res => resolve(res), err => reject(err));
                     }
                 });
             }
@@ -360,7 +197,7 @@ function loadCollectionMethods(methodManager) {
         // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
         // Search for doc, check version, if found then try and update props
         updateDocumentProps: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -379,127 +216,43 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, doc_id, updateParams, doc__v) {
-                var _this = this;
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).findOne({ _id: doc_id }).then(function (currDoc) {
+                        ResolveIOServer.getMongoManager().collection(collection).findOne({ _id: doc_id }).then(currDoc => {
                             if (currDoc) {
-                                var modifiedDoc_1 = common_1.deepCopy(currDoc);
-                                updateParams.forEach(function (data) {
-                                    modifiedDoc_1[data.prop] = data.data;
+                                let modifiedDoc = deepCopy(currDoc);
+                                updateParams.forEach(data => {
+                                    modifiedDoc[data.prop] = data.data;
                                 });
-                                if (modifiedDoc_1.__v === doc__v) {
-                                    var versionDoc = common_1.deepCopy(currDoc);
-                                    versionDoc._id = {
-                                        _id: currDoc._id,
-                                        __v: currDoc.__v
-                                    };
-                                    var schemaErrors = null;
-                                    try {
-                                        index_1.ResolveIOServer.getMongoManager().collection(collection)['simplschema'].validate(modifiedDoc_1);
-                                    }
-                                    catch (errors) {
-                                        schemaErrors = errors;
-                                        _this.callMethodInternal('insertErrorLog', 'Schema Failed on updateDocumentProps - ' + collection, [schemaErrors, modifiedDoc_1]);
-                                    }
-                                    if (schemaErrors) {
-                                        console.log(schemaErrors);
-                                        reject('Schema Errors');
-                                    }
-                                    else {
-                                        var updates_2 = common_1.getMongoUpdates(currDoc, modifiedDoc_1, true);
-                                        if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                            index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').create(versionDoc).then(function (doc) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                    $and: [
-                                                        { '_id._id': currDoc._id },
-                                                        { '_id.__v': { $lte: currDoc.__v - 4 } }
-                                                    ]
-                                                }).then(function () {
-                                                    if (updates_2) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: modifiedDoc_1._id }, updates_2).then(function (res) {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(1);
-                                                    }
-                                                }, function (err) { return reject(err); });
-                                            }, function (err) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                    $and: [
-                                                        { '_id._id': currDoc._id },
-                                                        { '_id.__v': { $lte: currDoc.__v - 4 } }
-                                                    ]
-                                                }).then(function () {
-                                                    if (updates_2) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: modifiedDoc_1._id }, updates_2).then(function (res) {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(1);
-                                                    }
-                                                }, function (err) { return reject(err); });
-                                            });
-                                        }
-                                        else {
-                                            if (updates_2) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: modifiedDoc_1._id }, updates_2).then(function (res) {
-                                                    resolve(res);
-                                                }, function (err) { return reject(err); });
-                                            }
-                                            else {
-                                                resolve(1);
-                                            }
-                                        }
-                                    }
+                                if (modifiedDoc.__v === doc__v) {
+                                    ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: modifiedDoc._id }, modifiedDoc, {}, false, true).then(res => {
+                                        resolve(res);
+                                    }, err => reject(err));
                                 }
                                 else {
                                     console.log(new Date(), 'invalid version - ' + collection, currDoc.__v, doc__v);
-                                    if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                        index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
+                                    if (ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
+                                        ResolveIOServer.getMongoManager().collection(collection + '.versions').findOne({
                                             $and: [
                                                 { '_id._id': currDoc._id },
                                                 { '_id.__v': doc__v }
                                             ]
-                                        }).then(function (oldDoc) {
-                                            var newCurrDocId = currDoc._id;
+                                        }).then(oldDoc => {
+                                            let newCurrDocId = currDoc._id;
                                             if (oldDoc) {
-                                                var versionDoc_2 = common_1.deepCopy(currDoc);
-                                                versionDoc_2._id = {
-                                                    _id: currDoc._id,
-                                                    __v: currDoc.__v
-                                                };
-                                                var updatedDoc = common_1.getMongoMergeUpdatedDoc(modifiedDoc_1, currDoc, oldDoc);
+                                                let updatedDoc = getMongoMergeUpdatedDoc(modifiedDoc, currDoc, oldDoc);
                                                 updatedDoc._id = newCurrDocId;
-                                                updatedDoc.__v++;
-                                                updatedDoc.updatedAt = new Date();
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).then(function (res) {
-                                                    if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').create(versionDoc_2).then(function (doc) {
-                                                            index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                                $and: [
-                                                                    { '_id._id': versionDoc_2._id._id },
-                                                                    { '_id.__v': { $lte: versionDoc_2._id.__v - 4 } }
-                                                                ]
-                                                            }).then(function () {
-                                                                resolve(res);
-                                                            }, function (err) { return reject(err); });
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(res);
-                                                    }
-                                                }, function (err) { return reject(err); });
+                                                ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: newCurrDocId }, updatedDoc, {}, false, true).then(res => {
+                                                    resolve(res);
+                                                }, err => reject(err));
                                             }
                                             else {
                                                 reject('Invalid Version And Could Not Find History Props - DB: ' + currDoc.__v + ', Trying to update with :' + doc__v);
                                             }
-                                        }, function () { });
+                                        }, () => { });
                                     }
                                     else {
                                         reject('Invalid Version And We Are NOT Using Versions On This Collection!');
@@ -509,13 +262,13 @@ function loadCollectionMethods(methodManager) {
                             else {
                                 reject('No Document');
                             }
-                        }, function () { });
+                        }, () => { });
                     }
                 });
             }
         },
         updateDocumentOffline: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -529,111 +282,27 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, f_document, f_oldDocument) {
-                var _this = this;
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).findOne({ _id: f_document['_id'] }).then(function (currDoc) {
+                        ResolveIOServer.getMongoManager().collection(collection).findOne({ _id: f_document['_id'] }).then(currDoc => {
                             if (currDoc) {
                                 if (currDoc.__v === f_document['__v']) {
-                                    var versionDoc = common_1.deepCopy(currDoc);
-                                    versionDoc._id = {
-                                        _id: currDoc._id,
-                                        __v: currDoc.__v
-                                    };
-                                    var schemaErrors = null;
-                                    try {
-                                        index_1.ResolveIOServer.getMongoManager().collection(collection)['simplschema'].validate(f_document);
-                                    }
-                                    catch (errors) {
-                                        schemaErrors = errors;
-                                        _this.callMethodInternal('insertErrorLog', 'Schema Failed on updateDocument - ' + collection, [schemaErrors, f_document]);
-                                    }
-                                    if (schemaErrors) {
-                                        console.log(schemaErrors);
-                                        reject('Schema Errors');
-                                    }
-                                    else {
-                                        var updates_3 = common_1.getMongoUpdates(currDoc, f_document, true);
-                                        if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                            index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').create(versionDoc).then(function (doc) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                    $and: [
-                                                        { '_id._id': currDoc._id },
-                                                        { '_id.__v': { $lte: currDoc.__v - 4 } }
-                                                    ]
-                                                }).then(function () {
-                                                    if (updates_3) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: f_document['_id'] }, updates_3).then(function (res) {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(1);
-                                                    }
-                                                }, function (err) { return reject(err); });
-                                            }, function (err) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                    $and: [
-                                                        { '_id._id': currDoc._id },
-                                                        { '_id.__v': { $lte: currDoc.__v - 4 } }
-                                                    ]
-                                                }).then(function () {
-                                                    if (updates_3) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: f_document['_id'] }, updates_3).then(function (res) {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(1);
-                                                    }
-                                                }, function (err) { return reject(err); });
-                                            });
-                                        }
-                                        else {
-                                            if (updates_3) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: f_document['_id'] }, updates_3).then(function (res) {
-                                                    resolve(res);
-                                                }, function (err) { return reject(err); });
-                                            }
-                                            else {
-                                                resolve(1);
-                                            }
-                                        }
-                                    }
+                                    ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: f_document['_id'] }, f_document, {}, false, true).then(res => {
+                                        resolve(res);
+                                    }, err => reject(err));
                                 }
                                 else {
                                     console.log('OFFLINE - invalid version - ' + collection, currDoc.__v, f_document['__v']);
-                                    var newCurrDocId = currDoc._id;
+                                    let newCurrDocId = currDoc._id;
                                     if (f_oldDocument) {
-                                        var versionDoc_3 = common_1.deepCopy(currDoc);
-                                        versionDoc_3._id = {
-                                            _id: currDoc._id,
-                                            __v: currDoc.__v
-                                        };
-                                        var updatedDoc = common_1.getMongoMergeUpdatedDoc(f_document, currDoc, f_oldDocument);
+                                        let updatedDoc = getMongoMergeUpdatedDoc(f_document, currDoc, f_oldDocument);
                                         updatedDoc._id = newCurrDocId;
-                                        updatedDoc.__v++;
-                                        updatedDoc.updatedAt = new Date();
-                                        index_1.ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).then(function (res) {
-                                            if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').create(versionDoc_3).then(function (doc) {
-                                                    index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                        $and: [
-                                                            { '_id._id': versionDoc_3._id._id },
-                                                            { '_id.__v': { $lte: versionDoc_3._id.__v - 4 } }
-                                                        ]
-                                                    }).then(function () {
-                                                        resolve(res);
-                                                    }, function (err) { return reject(err); });
-                                                }, function (err) { return reject(err); });
-                                            }
-                                            else {
-                                                resolve(res);
-                                            }
-                                        }, function (err) { return reject(err); });
+                                        ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: newCurrDocId }, updatedDoc, {}, false, true).then(res => {
+                                            resolve(res);
+                                        }, err => reject(err));
                                     }
                                     else {
                                         reject('OFFLINE - Invalid Version And Could Not Find History - DB: ' + currDoc.__v + ', Trying to update with :' + f_document['__v']);
@@ -643,7 +312,7 @@ function loadCollectionMethods(methodManager) {
                             else {
                                 reject('No Document');
                             }
-                        }, function () { });
+                        }, () => { });
                     }
                 });
             }
@@ -653,7 +322,7 @@ function loadCollectionMethods(methodManager) {
         // @Outputs: res = 1 (updated 1), res = 0 (not updated), err = not updated/wrong version
         // Search for doc, check version, if found then try and update props
         updateDocumentPropsOffline: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -676,125 +345,41 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, doc_id, updateParams, doc__v, f_oldDocument) {
-                var _this = this;
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).findOne({ _id: doc_id }).then(function (currDoc) {
+                        ResolveIOServer.getMongoManager().collection(collection).findOne({ _id: doc_id }).then(currDoc => {
                             if (currDoc) {
-                                var modifiedDoc_2 = common_1.deepCopy(currDoc);
-                                updateParams.forEach(function (data) {
-                                    modifiedDoc_2[data.prop] = data.data;
+                                let modifiedDoc = deepCopy(currDoc);
+                                updateParams.forEach(data => {
+                                    modifiedDoc[data.prop] = data.data;
                                 });
-                                if (modifiedDoc_2.__v === doc__v) {
-                                    var versionDoc = common_1.deepCopy(currDoc);
-                                    versionDoc._id = {
-                                        _id: currDoc._id,
-                                        __v: currDoc.__v
-                                    };
-                                    var schemaErrors = null;
-                                    try {
-                                        index_1.ResolveIOServer.getMongoManager().collection(collection)['simplschema'].validate(modifiedDoc_2);
-                                    }
-                                    catch (errors) {
-                                        schemaErrors = errors;
-                                        _this.callMethodInternal('insertErrorLog', 'Schema Failed on updateDocumentProps - ' + collection, [schemaErrors, modifiedDoc_2]);
-                                    }
-                                    if (schemaErrors) {
-                                        console.log(schemaErrors);
-                                        reject('Schema Errors');
-                                    }
-                                    else {
-                                        var updates_4 = common_1.getMongoUpdates(currDoc, modifiedDoc_2, true);
-                                        if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                            index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').create(versionDoc).then(function (doc) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                    $and: [
-                                                        { '_id._id': currDoc._id },
-                                                        { '_id.__v': { $lte: currDoc.__v - 4 } }
-                                                    ]
-                                                }).then(function () {
-                                                    if (updates_4) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: modifiedDoc_2._id }, updates_4).then(function (res) {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(1);
-                                                    }
-                                                }, function (err) { return reject(err); });
-                                            }, function (err) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                    $and: [
-                                                        { '_id._id': currDoc._id },
-                                                        { '_id.__v': { $lte: currDoc.__v - 4 } }
-                                                    ]
-                                                }).then(function () {
-                                                    if (updates_4) {
-                                                        index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: modifiedDoc_2._id }, updates_4).then(function (res) {
-                                                            resolve(res);
-                                                        }, function (err) { return reject(err); });
-                                                    }
-                                                    else {
-                                                        resolve(1);
-                                                    }
-                                                }, function (err) { return reject(err); });
-                                            });
-                                        }
-                                        else {
-                                            if (updates_4) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection).updateOne({ _id: modifiedDoc_2._id }, updates_4).then(function (res) {
-                                                    resolve(res);
-                                                }, function (err) { return reject(err); });
-                                            }
-                                            else {
-                                                resolve(1);
-                                            }
-                                        }
-                                    }
+                                if (modifiedDoc.__v === doc__v) {
+                                    ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: modifiedDoc._id }, modifiedDoc, {}, false, true).then(res => {
+                                        resolve(res);
+                                    }, err => reject(err));
                                 }
                                 else {
                                     console.log('OFFLINE - invalid version - ' + collection, currDoc.__v, doc__v);
-                                    var newCurrDocId = currDoc._id;
+                                    let newCurrDocId = currDoc._id;
                                     if (f_oldDocument) {
-                                        var versionDoc_4 = common_1.deepCopy(currDoc);
-                                        versionDoc_4._id = {
-                                            _id: currDoc._id,
-                                            __v: currDoc.__v
-                                        };
-                                        var updatedDoc = common_1.getMongoMergeUpdatedDoc(modifiedDoc_2, currDoc, f_oldDocument);
+                                        let updatedDoc = getMongoMergeUpdatedDoc(modifiedDoc, currDoc, f_oldDocument);
                                         updatedDoc._id = newCurrDocId;
-                                        updatedDoc.__v++;
-                                        updatedDoc.updatedAt = new Date();
-                                        index_1.ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).then(function (res) {
-                                            if (index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions')) {
-                                                index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').create(versionDoc_4).then(function (doc) {
-                                                    index_1.ResolveIOServer.getMongoManager().collection(collection + '.versions').deleteMany({
-                                                        $and: [
-                                                            { '_id._id': versionDoc_4._id._id },
-                                                            { '_id.__v': { $lte: versionDoc_4._id.__v - 4 } }
-                                                        ]
-                                                    }).then(function () {
-                                                        resolve(res);
-                                                    }, function (err) { return reject(err); });
-                                                }, function (err) { return reject(err); });
-                                            }
-                                            else {
-                                                resolve(res);
-                                            }
-                                        }, function (err) { return reject(err); });
+                                        ResolveIOServer.getMongoManager().collection(collection).replaceOne({ _id: newCurrDocId }, updatedDoc).then(res => {
+                                            resolve(res);
+                                        }, err => reject(err));
                                     }
                                     else {
-                                        reject('OFFLINE - Invalid Version And Could Not Find History Props - DB: ' + currDoc.__v + ', Trying to update with :' + modifiedDoc_2.__v);
+                                        reject('OFFLINE - Invalid Version And Could Not Find History Props - DB: ' + currDoc.__v + ', Trying to update with :' + modifiedDoc.__v);
                                     }
                                 }
                             }
                             else {
                                 reject('No Document');
                             }
-                        }, function () { });
+                        }, () => { });
                     }
                 });
             }
@@ -804,7 +389,7 @@ function loadCollectionMethods(methodManager) {
         // @Outputs: res = 1 (deleted), res = 0 (not deleted), err = not deleted
         // Search for doc, if found then try and remove
         removeDocument: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -813,14 +398,14 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, doc_id) {
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).deleteOne({ _id: doc_id }).then(function (res) {
+                        ResolveIOServer.getMongoManager().collection(collection).deleteOne({ _id: doc_id }).then(res => {
                             resolve(res);
-                        }, function (err) {
+                        }, err => {
                             reject(err);
                         });
                     }
@@ -828,7 +413,7 @@ function loadCollectionMethods(methodManager) {
             }
         },
         removeDocumentWithQuery: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -838,14 +423,14 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, query) {
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).deleteOne(query).then(function (res) {
+                        ResolveIOServer.getMongoManager().collection(collection).deleteOne(query).then(res => {
                             resolve(res);
-                        }, function (err) {
+                        }, err => {
                             reject(err);
                         });
                     }
@@ -853,7 +438,7 @@ function loadCollectionMethods(methodManager) {
             }
         },
         removeDocumentsWithQuery: {
-            check: new simpl_schema_1.default({
+            check: new SimpleSchema({
                 collection: {
                     type: String
                 },
@@ -863,14 +448,14 @@ function loadCollectionMethods(methodManager) {
                 }
             }),
             function: function (collection, query) {
-                return new Promise(function (resolve, reject) {
-                    if (!index_1.ResolveIOServer.getMongoManager().collection(collection)) {
+                return new Promise((resolve, reject) => {
+                    if (!ResolveIOServer.getMongoManager().collection(collection)) {
                         reject('Invalid collection');
                     }
                     else {
-                        index_1.ResolveIOServer.getMongoManager().collection(collection).deleteMany(query).then(function (res) {
+                        ResolveIOServer.getMongoManager().collection(collection).deleteMany(query).then(res => {
                             resolve(res);
-                        }, function (err) {
+                        }, err => {
                             reject(err);
                         });
                     }
@@ -879,6 +464,5 @@ function loadCollectionMethods(methodManager) {
         }
     });
 }
-exports.loadCollectionMethods = loadCollectionMethods;
 
 //# sourceMappingURL=collections.js.map