@resolveio/server-lib 9.0.34 → 9.0.36

package/managers/subscription.manager.js

@@ -1,26 +1,73 @@
-import { loadLogPublications } from '../publications/logs';
-import { loadAppStatusPublications } from '../publications/app-status';
-import { loadAppVersionPublications } from '../publications/app-version';
-import { loadFilePublications } from '../publications/files';
-import { loadSuperAdminPublications } from '../publications/super-admin';
-import { LoggedInUsers } from '../collections/logged-in-users.collection';
-import { loadCronJobPublications } from '../publications/cron-jobs';
-import { loadFlagsPublications } from '../publications/flags';
-import { loadMethodCallsPublications } from '../publications/method-calls';
-import { loadMethodResponsePublications } from '../publications/method-responses';
-import { ResolveIOServer } from '../index';
-import { loadNotificationPublications } from '../publications/notifications';
-import { deepCopy } from '../util/common';
-import * as moment from 'moment';
-import { loadReportBuilderReportPublications } from '../publications/report-builder-reports';
-import * as NodeCache from 'node-cache';
-import { loadReportBuilderLibraryPublications } from '../publications/report-builder-libraries';
-import { loadUserGroupPublications } from '../publications/user-groups';
-import { loadUserGuidePublications } from '../publications/user-guides';
-import { loadReportBuilderDashboardBuilderPublications } from '../publications/report-builder-dashboard-builders';
-import { objectIdHexString } from './mongo.manager';
-export class SubscriptionManager {
-    constructor(mainServer, wss, serverConfig) {
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionManager = void 0;
+var logs_1 = require("../publications/logs");
+var app_status_1 = require("../publications/app-status");
+var app_version_1 = require("../publications/app-version");
+var files_1 = require("../publications/files");
+var super_admin_1 = require("../publications/super-admin");
+var logged_in_users_collection_1 = require("../collections/logged-in-users.collection");
+var cron_jobs_1 = require("../publications/cron-jobs");
+var flags_1 = require("../publications/flags");
+var method_calls_1 = require("../publications/method-calls");
+var method_responses_1 = require("../publications/method-responses");
+var index_1 = require("../index");
+var notifications_1 = require("../publications/notifications");
+var common_1 = require("../util/common");
+var moment = require("moment");
+var report_builder_reports_1 = require("../publications/report-builder-reports");
+var NodeCache = require("node-cache");
+var report_builder_libraries_1 = require("../publications/report-builder-libraries");
+var user_groups_1 = require("../publications/user-groups");
+var user_guides_1 = require("../publications/user-guides");
+var report_builder_dashboard_builders_1 = require("../publications/report-builder-dashboard-builders");
+var mongo_manager_1 = require("./mongo.manager");
+var SubscriptionManager = /** @class */ (function () {
+    function SubscriptionManager(mainServer, wss, serverConfig) {
+        var _this = this;
         this._publications = {};
         this._subscriptions = [];
         this._loggedInUsers = [];
@@ -34,269 +81,348 @@ export class SubscriptionManager {
         this.serverConfig = serverConfig;
         this._wss = wss;
         // Publications
-        loadSuperAdminPublications(this);
-        loadAppVersionPublications(this);
-        loadAppStatusPublications(this);
-        loadLogPublications(this);
-        loadFilePublications(this);
-        loadCronJobPublications(this);
-        loadFlagsPublications(this);
-        loadMethodCallsPublications(this);
-        loadMethodResponsePublications(this);
-        loadNotificationPublications(this);
-        loadReportBuilderReportPublications(this);
-        loadReportBuilderLibraryPublications(this);
-        loadUserGroupPublications(this);
-        loadUserGuidePublications(this);
-        loadReportBuilderDashboardBuilderPublications(this);
+        super_admin_1.loadSuperAdminPublications(this);
+        app_version_1.loadAppVersionPublications(this);
+        app_status_1.loadAppStatusPublications(this);
+        logs_1.loadLogPublications(this);
+        files_1.loadFilePublications(this);
+        cron_jobs_1.loadCronJobPublications(this);
+        flags_1.loadFlagsPublications(this);
+        method_calls_1.loadMethodCallsPublications(this);
+        method_responses_1.loadMethodResponsePublications(this);
+        notifications_1.loadNotificationPublications(this);
+        report_builder_reports_1.loadReportBuilderReportPublications(this);
+        report_builder_libraries_1.loadReportBuilderLibraryPublications(this);
+        user_groups_1.loadUserGroupPublications(this);
+        user_guides_1.loadUserGuidePublications(this);
+        report_builder_dashboard_builders_1.loadReportBuilderDashboardBuilderPublications(this);
         this.tailOpLog();
         this.runOpLogQueue();
-        setInterval(() => {
+        setInterval(function () {
             console.log(new Date());
-            console.log('Sub Cache Length: ' + this._subCache.length);
-            console.log('Sub Length: ' + this._subscriptions.length);
-            console.log(this._nodeCache.getStats().vsize);
+            console.log('Sub Cache Length: ' + _this._subCache.length);
+            console.log('Sub Length: ' + _this._subscriptions.length);
+            console.log(_this._nodeCache.getStats().vsize);
         }, 43200000);
-        setInterval(() => {
-            if (!this._runningQueue) {
-                if (this._sendQueue.length) {
-                    this._runningQueue = true;
-                    for (let i = this._sendQueue.length - 1; i >= 0; i--) {
-                        let ws = this._mainServer.getWS(this._sendQueue[i].id_ws);
+        setInterval(function () {
+            if (!_this._runningQueue) {
+                if (_this._sendQueue.length) {
+                    _this._runningQueue = true;
+                    var _loop_1 = function (i) {
+                        var ws = _this._mainServer.getWS(_this._sendQueue[i].id_ws);
                         if (ws && ws.readyState === ws.OPEN) {
                             if (ws.bufferedAmount < 20480) {
-                                let sendItem = this._sendQueue.pop();
-                                ws.send(JSON.stringify(sendItem.data), (error) => {
+                                var sendItem = _this._sendQueue.pop();
+                                ws.send(JSON.stringify(sendItem.data), function (error) {
                                     if (error) {
                                         console.log('Error on WS: ', error);
-                                        this.unsubscribeAll(ws);
+                                        _this.unsubscribeAll(ws);
                                     }
                                 });
                             }
                         }
                         else {
-                            this._sendQueue.splice(i, 1);
+                            _this._sendQueue.splice(i, 1);
                         }
+                    };
+                    for (var i = _this._sendQueue.length - 1; i >= 0; i--) {
+                        _loop_1(i);
                     }
-                    this._runningQueue = false;
+                    _this._runningQueue = false;
                 }
             }
         }, 10);
-        setInterval(async () => {
-            this._loggedInUsers = await LoggedInUsers.find();
-            let userCopy = deepCopy(this._loggedInUsers);
-            for (let i = this._loggedInUsers.length - 1; i >= 0; i--) {
-                let loggedInUser = userCopy[i];
-                if (!loggedInUser.date || moment().diff(moment(loggedInUser.date), 'seconds') >= 60) {
-                    if (this._mainServer.getWS(loggedInUser.id_ws)) {
-                        this.unsubscribeAll(this._mainServer.getWS(loggedInUser.id_ws));
-                    }
-                    else {
-                        this._subscriptions.forEach(sub => {
-                            for (let j = sub.clients.length - 1; j >= 0; j--) {
-                                let client = sub.clients[j];
-                                if (client.id_socket === loggedInUser.id_ws) {
+        setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _a, userCopy, _loop_2, this_1, i, i, sub, _loop_3, this_2, j;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.find()];
+                    case 1:
+                        _a._loggedInUsers = _b.sent();
+                        userCopy = common_1.deepCopy(this._loggedInUsers);
+                        _loop_2 = function (i) {
+                            var loggedInUser;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        loggedInUser = userCopy[i];
+                                        if (!(!loggedInUser.date || moment().diff(moment(loggedInUser.date), 'seconds') >= 60)) return [3 /*break*/, 3];
+                                        if (!this_1._mainServer.getWS(loggedInUser.id_ws)) return [3 /*break*/, 1];
+                                        this_1.unsubscribeAll(this_1._mainServer.getWS(loggedInUser.id_ws));
+                                        return [3 /*break*/, 3];
+                                    case 1:
+                                        this_1._subscriptions.forEach(function (sub) {
+                                            for (var j = sub.clients.length - 1; j >= 0; j--) {
+                                                var client = sub.clients[j];
+                                                if (client.id_socket === loggedInUser.id_ws) {
+                                                    sub.clients.splice(j, 1);
+                                                }
+                                            }
+                                        });
+                                        return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.findById(loggedInUser._id)];
+                                    case 2:
+                                        if (_a.sent()) {
+                                            logged_in_users_collection_1.LoggedInUsers.deleteOne({ _id: loggedInUser._id });
+                                        }
+                                        this_1._loggedInUsers.splice(i, 1);
+                                        _a.label = 3;
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        i = this._loggedInUsers.length - 1;
+                        _b.label = 2;
+                    case 2:
+                        if (!(i >= 0)) return [3 /*break*/, 5];
+                        return [5 /*yield**/, _loop_2(i)];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        i--;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        for (i = 0; i < this._subscriptions.length; i++) {
+                            sub = this._subscriptions[i];
+                            _loop_3 = function (j) {
+                                var client = sub.clients[j];
+                                if (!this_2._loggedInUsers.some(function (a) { return a.id_ws === client.id_socket; })) {
                                     sub.clients.splice(j, 1);
                                 }
+                            };
+                            this_2 = this;
+                            for (j = sub.clients.length - 1; j >= 0; j--) {
+                                _loop_3(j);
                             }
-                        });
-                        if (await LoggedInUsers.findById(loggedInUser._id)) {
-                            LoggedInUsers.deleteOne({ _id: loggedInUser._id });
                         }
-                        this._loggedInUsers.splice(i, 1);
-                    }
+                        return [2 /*return*/];
                 }
-            }
-            for (let i = 0; i < this._subscriptions.length; i++) {
-                let sub = this._subscriptions[i];
-                for (let j = sub.clients.length - 1; j >= 0; j--) {
-                    let client = sub.clients[j];
-                    if (!this._loggedInUsers.some(a => a.id_ws === client.id_socket)) {
-                        sub.clients.splice(j, 1);
-                    }
-                }
-            }
-        }, 60000);
+            });
+        }); }, 60000);
     }
     // Add all files to publications private object
-    publications(method) {
+    SubscriptionManager.prototype.publications = function (method) {
         this._publications = Object.assign(this._publications, method);
-    }
-    async loggedInLatency(ws) {
-        let date = new Date();
-        let loggedInUser = this._loggedInUsers.filter(a => a.id_ws === ws['id_socket'])[0];
-        if (loggedInUser) {
-            loggedInUser.date = date;
-        }
-        LoggedInUsers.findOneAndUpdate({ id_ws: ws['id_socket'] }, { $set: { latency: ws['latency'], date: date } }).then(res => {
-            if (!res) {
-                this.unsubscribeAll(ws);
-            }
-        }, () => {
-            this.unsubscribeAll(ws);
+    };
+    SubscriptionManager.prototype.loggedInLatency = function (ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var date, loggedInUser;
+            var _this = this;
+            return __generator(this, function (_a) {
+                date = new Date();
+                loggedInUser = this._loggedInUsers.filter(function (a) { return a.id_ws === ws['id_socket']; })[0];
+                if (loggedInUser) {
+                    loggedInUser.date = date;
+                }
+                logged_in_users_collection_1.LoggedInUsers.findOneAndUpdate({ id_ws: ws['id_socket'] }, { $set: { latency: ws['latency'], date: date } }).then(function (res) {
+                    if (!res) {
+                        _this.unsubscribeAll(ws);
+                    }
+                }, function () {
+                    _this.unsubscribeAll(ws);
+                });
+                return [2 /*return*/];
+            });
         });
-    }
+    };
     // Subscribe to publication
-    async subscribe(messageDate, ws, messageId, publication, ...subscriptionData) {
-        let that = this;
-        let pub = that._publications[publication];
-        if (!pub) {
-            console.error('No Publication: ' + publication);
-            return;
+    SubscriptionManager.prototype.subscribe = function (messageDate, ws, messageId, publication) {
+        var subscriptionData = [];
+        for (var _i = 4; _i < arguments.length; _i++) {
+            subscriptionData[_i - 4] = arguments[_i];
         }
-        else {
-            if (subscriptionData.length > 1 || subscriptionData[0]) {
-                if (!pub.check) {
-                    console.error('No Check Function For Pub ' + publication);
-                    return;
-                }
-                else if (!pub.check._schema) {
-                    console.error('No Check Schema For Pub ' + publication);
-                    return;
-                }
-                else {
-                    let valObj = {};
-                    let valKeys = Object.keys(pub.check._schema);
-                    let rootKeys = valKeys.filter(a => !a.includes('.'));
-                    for (let i = 0; i < subscriptionData.length; i++) {
-                        valObj[rootKeys[i]] = subscriptionData[i];
-                    }
-                    try {
-                        pub.check.validate(valObj);
-                    }
-                    catch (errors) {
-                        if (errors) {
-                            console.error('Error in Pub Check (' + publication + ')', errors);
-                            return;
+        return __awaiter(this, void 0, void 0, function () {
+            var that, pub, valObj, valKeys, rootKeys, i, sub, _a, newLoggedInUser;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        that = this;
+                        pub = that._publications[publication];
+                        if (!!pub) return [3 /*break*/, 1];
+                        console.error('No Publication: ' + publication);
+                        return [2 /*return*/];
+                    case 1:
+                        if (subscriptionData.length > 1 || subscriptionData[0]) {
+                            if (!pub.check) {
+                                console.error('No Check Function For Pub ' + publication);
+                                return [2 /*return*/];
+                            }
+                            else if (!pub.check._schema) {
+                                console.error('No Check Schema For Pub ' + publication);
+                                return [2 /*return*/];
+                            }
+                            else {
+                                valObj = {};
+                                valKeys = Object.keys(pub.check._schema);
+                                rootKeys = valKeys.filter(function (a) { return !a.includes('.'); });
+                                for (i = 0; i < subscriptionData.length; i++) {
+                                    valObj[rootKeys[i]] = subscriptionData[i];
+                                }
+                                try {
+                                    pub.check.validate(valObj);
+                                }
+                                catch (errors) {
+                                    if (errors) {
+                                        console.error('Error in Pub Check (' + publication + ')', errors);
+                                        return [2 /*return*/];
+                                    }
+                                }
+                            }
                         }
-                    }
+                        sub = that._subscriptions.filter(function (a) { return a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData); })[0];
+                        // If sub found (another user watching same data), add client to same sub
+                        if (sub) {
+                            sub.clients.push({
+                                id_user: ws['id_user'],
+                                messageId: messageId,
+                                id_socket: ws['id_socket']
+                            });
+                        }
+                        // If sub not found, create new sub
+                        else {
+                            that._subscriptions.push({
+                                publication: publication,
+                                subscriptionData: subscriptionData,
+                                collections: that.getPublicationCollections(publication),
+                                clients: [{
+                                        id_user: ws['id_user'],
+                                        messageId: messageId,
+                                        id_socket: ws['id_socket']
+                                    }]
+                            });
+                        }
+                        if (!sub) {
+                            sub = that._subscriptions.filter(function (a) { return a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData); })[0];
+                        }
+                        // console.log('Subscribe', new Date(), 'Success', sub);
+                        // Send pub data to client who just subscribed only, don't want to send to existing clients since nothing has changed
+                        that.sendPubDataOnce(ws, messageId, sub, 'newSub', that.getPublicationCollections(publication)[0]);
+                        if (!(that._publications[sub.publication].preFunction && !sub.preSubscriptionData)) return [3 /*break*/, 3];
+                        _a = sub;
+                        return [4 /*yield*/, (_b = that._publications[sub.publication]).preFunction.apply(_b, sub.subscriptionData)];
+                    case 2:
+                        _a.preSubscriptionData = _c.sent();
+                        _c.label = 3;
+                    case 3:
+                        if (publication === 'appversion') {
+                            newLoggedInUser = {
+                                _id: mongo_manager_1.objectIdHexString(),
+                                __v: 0,
+                                date: new Date(),
+                                id_user: ws['id_user'],
+                                user: ws['user'],
+                                id_ws: ws['id_socket']
+                            };
+                            this._loggedInUsers.push(newLoggedInUser);
+                            logged_in_users_collection_1.LoggedInUsers.create(newLoggedInUser);
+                            if (ws['user'] !== 'Admin' && this.serverConfig['CLIENT_NAME'] !== 'ResolveIO') {
+                                this._mainServer.getMethodManager().callMethodInternal('supportCreateBillingUser', {
+                                    id_user: ws['id_user'],
+                                    user: ws['user'],
+                                    date: new Date(),
+                                    client: index_1.ResolveIOServer.getClientName()
+                                });
+                            }
+                        }
+                        return [2 /*return*/];
                 }
-            }
-            let sub = that._subscriptions.filter(a => a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData))[0];
-            // If sub found (another user watching same data), add client to same sub
-            if (sub) {
-                sub.clients.push({
-                    id_user: ws['id_user'],
-                    messageId: messageId,
-                    id_socket: ws['id_socket']
-                });
-            }
-            // If sub not found, create new sub
-            else {
-                that._subscriptions.push({
-                    publication: publication,
-                    subscriptionData: subscriptionData,
-                    collections: that.getPublicationCollections(publication),
-                    clients: [{
-                            id_user: ws['id_user'],
-                            messageId: messageId,
-                            id_socket: ws['id_socket']
-                        }]
-                });
-            }
-            if (!sub) {
-                sub = that._subscriptions.filter(a => a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData))[0];
-            }
-            // console.log('Subscribe', new Date(), 'Success', sub);
-            // Send pub data to client who just subscribed only, don't want to send to existing clients since nothing has changed
-            that.sendPubDataOnce(ws, messageId, sub, 'newSub', that.getPublicationCollections(publication)[0]);
-            if (that._publications[sub.publication].preFunction && !sub.preSubscriptionData) {
-                sub.preSubscriptionData = await that._publications[sub.publication].preFunction(...sub.subscriptionData);
-            }
-        }
-        if (publication === 'appversion') {
-            let newLoggedInUser = {
-                _id: objectIdHexString(),
-                __v: 0,
-                date: new Date(),
-                id_user: ws['id_user'],
-                user: ws['user'],
-                id_ws: ws['id_socket']
-            };
-            this._loggedInUsers.push(newLoggedInUser);
-            LoggedInUsers.create(newLoggedInUser);
-            if (ws['user'] !== 'Admin' && this.serverConfig['CLIENT_NAME'] !== 'ResolveIO') {
-                this._mainServer.getMethodManager().callMethodInternal('supportCreateBillingUser', {
-                    id_user: ws['id_user'],
-                    user: ws['user'],
-                    date: new Date(),
-                    client: ResolveIOServer.getClientName()
-                });
-            }
-        }
-    }
+            });
+        });
+    };
     // Unsubscribe from publication 
-    async unsubscribe(messageDate, ws, messageId, publication, ...subscriptionData) {
-        let that = this;
-        // console.log('Before');
-        // console.dir(this._subscriptions.map(a => a.publication));
-        if (!that._publications[publication]) {
-            console.log('No Publication: ' + publication);
-            return;
+    SubscriptionManager.prototype.unsubscribe = function (messageDate, ws, messageId, publication) {
+        var subscriptionData = [];
+        for (var _i = 4; _i < arguments.length; _i++) {
+            subscriptionData[_i - 4] = arguments[_i];
         }
-        else {
-            let sub = that._subscriptions.filter(a => a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData))[0];
-            if (sub) {
-                for (let i = sub.clients.length - 1; i >= 0; i--) {
-                    if (sub.clients[i].id_user === ws['id_user'] && sub.clients[i].messageId === messageId && sub.clients[i].id_socket === ws['id_socket']) {
-                        sub.clients.splice(i, 1);
+        return __awaiter(this, void 0, void 0, function () {
+            var that, sub, i;
+            return __generator(this, function (_a) {
+                that = this;
+                // console.log('Before');
+                // console.dir(this._subscriptions.map(a => a.publication));
+                if (!that._publications[publication]) {
+                    console.log('No Publication: ' + publication);
+                    return [2 /*return*/];
+                }
+                else {
+                    sub = that._subscriptions.filter(function (a) { return a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData); })[0];
+                    if (sub) {
+                        for (i = sub.clients.length - 1; i >= 0; i--) {
+                            if (sub.clients[i].id_user === ws['id_user'] && sub.clients[i].messageId === messageId && sub.clients[i].id_socket === ws['id_socket']) {
+                                sub.clients.splice(i, 1);
+                            }
+                        }
                     }
                 }
-            }
-        }
-    }
+                return [2 /*return*/];
+            });
+        });
+    };
     // Unsubscribe from publication
-    async unsubscribeAll(ws) {
-        let that = this;
-        // console.log('Before');
-        // console.dir(this._subscriptions.map(a => a.publication));
-        let loggedInUser = await LoggedInUsers.findOne({ id_ws: ws['id_socket'] });
-        if (loggedInUser) {
-            if (this._loggedInUsers.map(a => a._id).indexOf(loggedInUser._id) >= 0) {
-                this._loggedInUsers.splice(this._loggedInUsers.map(a => a._id).indexOf(loggedInUser._id), 1);
-            }
-            LoggedInUsers.deleteOne({ _id: loggedInUser._id });
-        }
-        let userSubs = that._subscriptions.filter(a => a.clients.some(b => b.id_user === ws['id_user'] && b.id_socket === ws['id_socket']));
-        for (let i = userSubs.length - 1; i >= 0; i--) {
-            let sub = userSubs[i];
-            for (let j = sub.clients.length - 1; j >= 0; j--) {
-                if (sub.clients[j].id_socket === ws['id_socket']) {
-                    sub.clients.splice(j, 1);
+    SubscriptionManager.prototype.unsubscribeAll = function (ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var that, loggedInUser, userSubs, i, sub, j;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        that = this;
+                        return [4 /*yield*/, logged_in_users_collection_1.LoggedInUsers.findOne({ id_ws: ws['id_socket'] })];
+                    case 1:
+                        loggedInUser = _a.sent();
+                        if (loggedInUser) {
+                            if (this._loggedInUsers.map(function (a) { return a._id; }).indexOf(loggedInUser._id) >= 0) {
+                                this._loggedInUsers.splice(this._loggedInUsers.map(function (a) { return a._id; }).indexOf(loggedInUser._id), 1);
+                            }
+                            logged_in_users_collection_1.LoggedInUsers.deleteOne({ _id: loggedInUser._id });
+                        }
+                        userSubs = that._subscriptions.filter(function (a) { return a.clients.some(function (b) { return b.id_user === ws['id_user'] && b.id_socket === ws['id_socket']; }); });
+                        for (i = userSubs.length - 1; i >= 0; i--) {
+                            sub = userSubs[i];
+                            for (j = sub.clients.length - 1; j >= 0; j--) {
+                                if (sub.clients[j].id_socket === ws['id_socket']) {
+                                    sub.clients.splice(j, 1);
+                                }
+                            }
+                        }
+                        ws.terminate();
+                        return [2 /*return*/];
                 }
-            }
-        }
-        ws.terminate();
-        // console.log('After');
-        // console.dir(this._subscriptions.map(a => a.publication));
-    }
+            });
+        });
+    };
     // Get publication collection
-    getPublicationCollections(publication) {
+    SubscriptionManager.prototype.getPublicationCollections = function (publication) {
         return this._publications[publication].collections;
-    }
+    };
     // Watch (tail) Mongo's operation log on the entire database (all insert/modify/delete will trigger this function)
-    tailOpLog() {
-        this._oplog = ResolveIOServer.getMainDB().watch([], { fullDocument: 'updateLookup' });
-        this._oplog.on('change', (doc) => {
-            let collection = doc.ns.coll;
+    SubscriptionManager.prototype.tailOpLog = function () {
+        var _this = this;
+        this._oplog = index_1.ResolveIOServer.getMainDB().watch([], { fullDocument: 'updateLookup' });
+        this._oplog.on('change', function (doc) {
+            var collection = doc.ns.coll;
             if (collection && !collection.endsWith('.versions') && !collection.startsWith('monitor-')) {
                 if (doc.operationType === 'insert') {
                     if (collection === 'queue-methods') {
-                        this._mainServer.getQueueManager().runMethodQueue();
+                        _this._mainServer.getQueueManager().runMethodQueue();
                     }
                     else if (collection === 'queue-responses') {
-                        this._mainServer.getQueueManager().runMethodResponse();
+                        _this._mainServer.getQueueManager().runMethodResponse();
                     }
                     else {
                         if (collection === 'cron-jobs') {
-                            this._mainServer.getCronManager().checkCronJobsForUpdates();
+                            _this._mainServer.getCronManager().checkCronJobsForUpdates();
                         }
                         else if (collection === 'support-tickets') {
-                            if (this.serverConfig['ROOT_URL'] === 'https://resolveio.com') {
-                                this._mainServer.getMethodManager().callMethodInternal('sendSupportTicketEmail', doc.fullDocument._id);
+                            if (_this.serverConfig['ROOT_URL'] === 'https://resolveio.com') {
+                                _this._mainServer.getMethodManager().callMethodInternal('sendSupportTicketEmail', doc.fullDocument._id);
                             }
                         }
-                        this._oplogQueue.push({
+                        _this._oplogQueue.push({
                             type: 'insert',
                             collection: collection,
                             doc: doc.fullDocument
@@ -305,370 +431,443 @@ export class SubscriptionManager {
                 }
                 else if (doc.operationType === 'update' || doc.operationType === 'replace') {
                     if (collection === 'cron-jobs') {
-                        this._mainServer.getCronManager().checkCronJobsForUpdates();
+                        _this._mainServer.getCronManager().checkCronJobsForUpdates();
                     }
-                    this._oplogQueue.push({
+                    _this._oplogQueue.push({
                         type: 'update',
                         collection: collection,
                         doc: doc.fullDocument
                     });
                 }
                 else if (doc.operationType === 'delete') {
-                    this.resendPubsForDelete(collection);
+                    _this.resendPubsForDelete(collection);
                     if (collection === 'cron-jobs') {
-                        this._mainServer.getCronManager().checkCronJobsForUpdates();
+                        _this._mainServer.getCronManager().checkCronJobsForUpdates();
                     }
                 }
             }
         });
-        this._oplog.on('error', error => {
+        this._oplog.on('error', function (error) {
             console.log('oplog error', error);
             process.exit();
         });
-        this._oplog.on('end', () => {
+        this._oplog.on('end', function () {
             console.log('oplog ended');
             process.exit();
         });
-    }
-    runOpLogQueue() {
-        let that = this;
-        setInterval(async () => {
-            if (this._oplogQueue.length) {
-                let uniqueOplog = deepCopy(this._oplogQueue);
-                this._oplogQueue = [];
-                let uniquePubs = [];
-                for (let i = uniqueOplog.length - 1; i >= 0; i--) {
-                    if (!that._subscriptions.some(a => a.collections.includes(uniqueOplog[i].collection))) {
-                        for (let j = this._subCache.length - 1; j >= 0; j--) {
-                            if (this._subCache[j].collection === uniqueOplog[i].collection) {
-                                this._nodeCache.del(this._subCache[j].id);
-                                this._subCache.splice(j, 1);
-                            }
-                        }
-                        uniqueOplog.splice(i, 1);
-                    }
-                }
-                for (let i = uniqueOplog.length - 1; i >= 0; i--) {
-                    let oplog = uniqueOplog[i];
-                    for (let j = that._subscriptions.length - 1; j >= 0; j--) {
-                        let sub = that._subscriptions[j];
-                        if (sub) {
-                            if (sub.collections.includes(oplog.collection) && !uniquePubs.filter(a => a.publication === sub.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(sub.subscriptionData)).length) {
-                                if (sub.preSubscriptionData) {
-                                    if (that._publications[sub.publication].fetchFunction(oplog.doc, sub.preSubscriptionData)) {
-                                        sub['oplog'] = oplog;
-                                        uniquePubs.push(deepCopy(sub));
-                                        continue;
+    };
+    SubscriptionManager.prototype.runOpLogQueue = function () {
+        var _this = this;
+        var that = this;
+        setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var uniqueOplog_1, uniquePubs, _loop_4, this_3, i, i, oplog, _loop_5, this_4, j, i, pub;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._oplogQueue.length) return [3 /*break*/, 7];
+                        uniqueOplog_1 = common_1.deepCopy(this._oplogQueue);
+                        this._oplogQueue = [];
+                        uniquePubs = [];
+                        _loop_4 = function (i) {
+                            if (!that._subscriptions.some(function (a) { return a.collections.includes(uniqueOplog_1[i].collection); })) {
+                                for (var j = this_3._subCache.length - 1; j >= 0; j--) {
+                                    if (this_3._subCache[j].collection === uniqueOplog_1[i].collection) {
+                                        this_3._nodeCache.del(this_3._subCache[j].id);
+                                        this_3._subCache.splice(j, 1);
                                     }
                                 }
-                                if (that._publications[sub.publication].preFunction) {
-                                    if (sub.clients.length) {
-                                        sub.preSubscriptionData = await that._publications[sub.publication].preFunction(...sub.subscriptionData);
+                                uniqueOplog_1.splice(i, 1);
+                            }
+                        };
+                        this_3 = this;
+                        for (i = uniqueOplog_1.length - 1; i >= 0; i--) {
+                            _loop_4(i);
+                        }
+                        i = uniqueOplog_1.length - 1;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i >= 0)) return [3 /*break*/, 6];
+                        oplog = uniqueOplog_1[i];
+                        _loop_5 = function (j) {
+                            var sub, _a, i_1;
+                            var _b, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        sub = that._subscriptions[j];
+                                        if (!sub) return [3 /*break*/, 5];
+                                        if (!(sub.collections.includes(oplog.collection) && !uniquePubs.filter(function (a) { return a.publication === sub.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(sub.subscriptionData); }).length)) return [3 /*break*/, 5];
+                                        if (sub.preSubscriptionData) {
+                                            if (that._publications[sub.publication].fetchFunction(oplog.doc, sub.preSubscriptionData)) {
+                                                sub['oplog'] = oplog;
+                                                uniquePubs.push(common_1.deepCopy(sub));
+                                                return [2 /*return*/, "continue"];
+                                            }
+                                        }
+                                        if (!that._publications[sub.publication].preFunction) return [3 /*break*/, 4];
+                                        if (!sub.clients.length) return [3 /*break*/, 2];
+                                        _a = sub;
+                                        return [4 /*yield*/, (_b = that._publications[sub.publication]).preFunction.apply(_b, sub.subscriptionData)];
+                                    case 1:
+                                        _a.preSubscriptionData = _d.sent();
                                         if (that._publications[sub.publication].fetchFunction(oplog.doc, sub.preSubscriptionData)) {
                                             sub['oplog'] = oplog;
-                                            uniquePubs.push(deepCopy(sub));
+                                            uniquePubs.push(common_1.deepCopy(sub));
                                         }
-                                    }
-                                    else {
-                                        for (let i = this._subCache.length - 1; i >= 0; i--) {
-                                            if (this._subCache[i].publication === sub.publication && JSON.stringify(this._subCache[i].subscriptionData) === JSON.stringify(sub.subscriptionData)) {
-                                                this._nodeCache.del(this._subCache[i].id);
-                                                this._subCache.splice(i, 1);
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        for (i_1 = this_4._subCache.length - 1; i_1 >= 0; i_1--) {
+                                            if (this_4._subCache[i_1].publication === sub.publication && JSON.stringify(this_4._subCache[i_1].subscriptionData) === JSON.stringify(sub.subscriptionData)) {
+                                                this_4._nodeCache.del(this_4._subCache[i_1].id);
+                                                this_4._subCache.splice(i_1, 1);
                                             }
                                         }
-                                        if (that._subscriptions.findIndex(a => a.publication === sub.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(sub.subscriptionData)) >= 0) {
-                                            that._subscriptions.splice(that._subscriptions.findIndex(a => a.publication === sub.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(sub.subscriptionData)), 1);
+                                        if (that._subscriptions.findIndex(function (a) { return a.publication === sub.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(sub.subscriptionData); }) >= 0) {
+                                            that._subscriptions.splice(that._subscriptions.findIndex(function (a) { return a.publication === sub.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(sub.subscriptionData); }), 1);
                                         }
-                                    }
-                                }
-                                else {
-                                    if (that._publications[sub.publication].fetchFunction) {
-                                        if (that._publications[sub.publication].fetchFunction(oplog.doc, ...sub.subscriptionData)) {
+                                        _d.label = 3;
+                                    case 3: return [3 /*break*/, 5];
+                                    case 4:
+                                        if (that._publications[sub.publication].fetchFunction) {
+                                            if ((_c = that._publications[sub.publication]).fetchFunction.apply(_c, __spreadArrays([oplog.doc], sub.subscriptionData))) {
+                                                sub['oplog'] = oplog;
+                                                uniquePubs.push(common_1.deepCopy(sub));
+                                            }
+                                        }
+                                        else {
                                             sub['oplog'] = oplog;
-                                            uniquePubs.push(deepCopy(sub));
+                                            uniquePubs.push(common_1.deepCopy(sub));
                                         }
-                                    }
-                                    else {
-                                        sub['oplog'] = oplog;
-                                        uniquePubs.push(deepCopy(sub));
-                                    }
+                                        _d.label = 5;
+                                    case 5: return [2 /*return*/];
                                 }
-                            }
+                            });
+                        };
+                        this_4 = this;
+                        j = that._subscriptions.length - 1;
+                        _a.label = 2;
+                    case 2:
+                        if (!(j >= 0)) return [3 /*break*/, 5];
+                        return [5 /*yield**/, _loop_5(j)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        j--;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        i--;
+                        return [3 /*break*/, 1];
+                    case 6:
+                        for (i = 0; i < uniquePubs.length; i++) {
+                            pub = uniquePubs[i];
+                            this.checkPubsForChanges(pub['oplog'].collection, pub['oplog'].doc, pub['oplog'].type, pub);
                         }
-                    }
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
                 }
-                for (let i = 0; i < uniquePubs.length; i++) {
-                    let pub = uniquePubs[i];
-                    this.checkPubsForChanges(pub['oplog'].collection, pub['oplog'].doc, pub['oplog'].type, pub);
+            });
+        }); }, 100);
+    };
+    SubscriptionManager.prototype.resendPubsForDelete = function (collection) {
+        return __awaiter(this, void 0, void 0, function () {
+            var that, subCopy, _loop_6, this_5, i, zz, sub, aa, client, bb, ws;
+            var _this = this;
+            return __generator(this, function (_a) {
+                that = this;
+                subCopy = common_1.deepCopy(that._subscriptions.filter(function (a) { return a.collections.includes(collection); }));
+                _loop_6 = function (i) {
+                    if (this_5._subCache[i].collection === collection || subCopy.some(function (a) { return a.publication === _this._subCache[i].publication; })) {
+                        this_5._nodeCache.del(this_5._subCache[i].id);
+                        this_5._subCache.splice(i, 1);
+                    }
+                };
+                this_5 = this;
+                for (i = this._subCache.length - 1; i >= 0; i--) {
+                    _loop_6(i);
                 }
-            }
-        }, 100);
-    }
-    async resendPubsForDelete(collection) {
-        let that = this;
-        let subCopy = deepCopy(that._subscriptions.filter(a => a.collections.includes(collection)));
-        for (let i = this._subCache.length - 1; i >= 0; i--) {
-            if (this._subCache[i].collection === collection || subCopy.some(a => a.publication === this._subCache[i].publication)) {
-                this._nodeCache.del(this._subCache[i].id);
-                this._subCache.splice(i, 1);
-            }
-        }
-        for (let zz = subCopy.length - 1; zz >= 0; zz--) {
-            let sub = subCopy[zz];
-            if (that._publications[sub.publication].ws_specific) {
-                for (let aa = 0; aa < sub.clients.length; aa++) {
-                    let client = sub.clients[aa];
-                    for (let bb = 0; bb < that._wss.clients.size; bb++) {
-                        let ws = Array.from(that._wss.clients)[bb];
-                        if (ws['id_socket'] === client.id_socket) {
-                            that.sendPubDataOnce(ws, client.messageId, sub, 'delete', collection);
+                for (zz = subCopy.length - 1; zz >= 0; zz--) {
+                    sub = subCopy[zz];
+                    if (that._publications[sub.publication].ws_specific) {
+                        for (aa = 0; aa < sub.clients.length; aa++) {
+                            client = sub.clients[aa];
+                            for (bb = 0; bb < that._wss.clients.size; bb++) {
+                                ws = Array.from(that._wss.clients)[bb];
+                                if (ws['id_socket'] === client.id_socket) {
+                                    that.sendPubDataOnce(ws, client.messageId, sub, 'delete', collection);
+                                }
+                            }
                         }
                     }
+                    else {
+                        that.sendPubData(sub, 'delete', collection);
+                    }
                 }
-            }
-            else {
-                that.sendPubData(sub, 'delete', collection);
-            }
-        }
-    }
+                return [2 /*return*/];
+            });
+        });
+    };
     // Document: Inserted/Modified Document
     // Collection: Collection Document Lives In
     // Check to see if any pubs need to refetch due to Mongo operation
-    async checkPubsForChanges(collection, document, type, sub) {
-        let that = this;
-        if (sub.preSubscriptionData) {
-            if (that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) {
-                that.sendPubData(sub, type, collection);
-                return;
-            }
-        }
-        if (!that._publications[sub.publication].preFunction) {
-            if (that._publications[sub.publication].ws_specific) {
-                for (let k = 0; k < sub.clients.length; k++) {
-                    let client = sub.clients[k];
-                    if (that._publications[sub.publication].fetchFunction) {
-                        if (that._publications[sub.publication].fetchFunction(document, client.id_user, ...sub.subscriptionData)) {
-                            for (let j = 0; j < that._wss.clients.size; j++) {
-                                let ws = Array.from(that._wss.clients)[j];
-                                if (ws['id_socket'] === client.id_socket) {
-                                    that.sendPubDataOnce(ws, client.messageId, sub, type, collection);
+    SubscriptionManager.prototype.checkPubsForChanges = function (collection, document, type, sub) {
+        return __awaiter(this, void 0, void 0, function () {
+            var that, k, client, j, ws, j, ws;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                that = this;
+                if (sub.preSubscriptionData) {
+                    if (that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) {
+                        that.sendPubData(sub, type, collection);
+                        return [2 /*return*/];
+                    }
+                }
+                if (!that._publications[sub.publication].preFunction) {
+                    if (that._publications[sub.publication].ws_specific) {
+                        for (k = 0; k < sub.clients.length; k++) {
+                            client = sub.clients[k];
+                            if (that._publications[sub.publication].fetchFunction) {
+                                if ((_a = that._publications[sub.publication]).fetchFunction.apply(_a, __spreadArrays([document, client.id_user], sub.subscriptionData))) {
+                                    for (j = 0; j < that._wss.clients.size; j++) {
+                                        ws = Array.from(that._wss.clients)[j];
+                                        if (ws['id_socket'] === client.id_socket) {
+                                            that.sendPubDataOnce(ws, client.messageId, sub, type, collection);
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                for (j = 0; j < that._wss.clients.size; j++) {
+                                    ws = Array.from(that._wss.clients)[j];
+                                    if (ws['id_socket'] === client.id_socket) {
+                                        that.sendPubDataOnce(ws, client.messageId, sub, type, collection);
+                                    }
                                 }
                             }
                         }
                     }
                     else {
-                        for (let j = 0; j < that._wss.clients.size; j++) {
-                            let ws = Array.from(that._wss.clients)[j];
-                            if (ws['id_socket'] === client.id_socket) {
-                                that.sendPubDataOnce(ws, client.messageId, sub, type, collection);
+                        if (that._publications[sub.publication].fetchFunction) {
+                            if ((_b = that._publications[sub.publication]).fetchFunction.apply(_b, __spreadArrays([document], sub.subscriptionData))) {
+                                that.sendPubData(sub, type, collection);
                             }
+                            // else
+                        }
+                        else {
+                            that.sendPubData(sub, type, collection);
                         }
                     }
                 }
-            }
-            else {
-                if (that._publications[sub.publication].fetchFunction) {
-                    if (that._publications[sub.publication].fetchFunction(document, ...sub.subscriptionData)) {
-                        that.sendPubData(sub, type, collection);
-                    }
-                    // else
-                }
-                else {
-                    that.sendPubData(sub, type, collection);
-                }
-            }
-        }
-    }
+                return [2 /*return*/];
+            });
+        });
+    };
     // Fetch pub once, send to all clients linked to this pub
-    sendPubDataOnce(ws, messageId, subscription, type, collection) {
-        return new Promise(async (resolve, reject) => {
-            let that = this;
-            if (!that._publications[subscription.publication].ws_specific) { // Same pub for all users
-                if (this._subCache.some(a => a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData))) {
-                    let serverRes = {
-                        messageId: messageId,
-                        hasError: false,
-                        data: this._nodeCache.get(this._subCache.filter(a => a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData))[0].id)
-                    };
-                    this.sendWS(ws, serverRes);
-                    resolve(true);
-                }
-                else {
-                    if (subscription.publication !== 'superadminAPM' && subscription.publication !== 'loggedInUsers') {
-                        that._mainServer.getMethodManager().callMethodInternal('insertSubscriptionLog', type, subscription.publication, collection, JSON.stringify(subscription.subscriptionData));
-                    }
-                    for (let i = this._subCache.length - 1; i >= 0; i--) {
-                        if (this._subCache[i].publication === subscription.publication && JSON.stringify(this._subCache[i].subscriptionData) === JSON.stringify(subscription.subscriptionData)) {
-                            this._nodeCache.del(this._subCache[i].id);
-                            this._subCache.splice(i, 1);
-                        }
+    SubscriptionManager.prototype.sendPubDataOnce = function (ws, messageId, subscription, type, collection) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var that, serverRes, i;
+            var _a, _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                that = this;
+                if (!that._publications[subscription.publication].ws_specific) { // Same pub for all users
+                    if (this._subCache.some(function (a) { return a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData); })) {
+                        serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: this._nodeCache.get(this._subCache.filter(function (a) { return a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData); })[0].id)
+                        };
+                        this.sendWS(ws, serverRes);
+                        resolve(true);
                     }
-                    that._publications[subscription.publication].function.call(Object.assign({}, that, SubscriptionManager.prototype), ...subscription.subscriptionData).catch(methodErrs => {
-                        that._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Subscription ' + subscription.publication + ' - (sendPubDataOnce - No WS)\n\nData \n' + JSON.stringify(subscription.subscriptionData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
-                    }).then(res => {
-                        let nodeCacheSize = this._nodeCache.getStats().vsize;
-                        if (nodeCacheSize > 500000000) {
-                            let neededSizeIndex = 0;
-                            for (let zz = 0; zz < this._subCache.length; zz++) {
-                                this._nodeCache.del(this._subCache[zz].id);
-                                if (this._nodeCache.getStats().vsize < 500000000) {
-                                    neededSizeIndex = zz;
-                                    break;
-                                }
-                            }
-                            // console.log('Cache1: ' + 'Too Big - ' + subscription.publication + ' - ' + getBinarySize(JSON.stringify(this._subCache)));
-                            this._subCache.splice(0, neededSizeIndex);
+                    else {
+                        if (subscription.publication !== 'superadminAPM' && subscription.publication !== 'loggedInUsers') {
+                            that._mainServer.getMethodManager().callMethodInternal('insertSubscriptionLog', type, subscription.publication, collection, JSON.stringify(subscription.subscriptionData));
                         }
-                        for (let i = this._subCache.length - 1; i >= 0; i--) {
+                        for (i = this._subCache.length - 1; i >= 0; i--) {
                             if (this._subCache[i].publication === subscription.publication && JSON.stringify(this._subCache[i].subscriptionData) === JSON.stringify(subscription.subscriptionData)) {
                                 this._nodeCache.del(this._subCache[i].id);
                                 this._subCache.splice(i, 1);
                             }
                         }
-                        if (this._subscriptions.some(a => a.collections.includes(collection) && a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData))) {
-                            let cacheId = this._cacheId++;
-                            this._nodeCache.set(cacheId, res);
-                            this._subCache.push({ collection: collection, publication: subscription.publication, subscriptionData: subscription.subscriptionData, id: cacheId });
-                            let serverRes = {
+                        (_a = that._publications[subscription.publication].function).call.apply(_a, __spreadArrays([Object.assign({}, that, SubscriptionManager.prototype)], subscription.subscriptionData)).catch(function (methodErrs) {
+                            that._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Subscription ' + subscription.publication + ' - (sendPubDataOnce - No WS)\n\nData \n' + JSON.stringify(subscription.subscriptionData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
+                        }).then(function (res) {
+                            var nodeCacheSize = _this._nodeCache.getStats().vsize;
+                            if (nodeCacheSize > 500000000) {
+                                var neededSizeIndex = 0;
+                                for (var zz = 0; zz < _this._subCache.length; zz++) {
+                                    _this._nodeCache.del(_this._subCache[zz].id);
+                                    if (_this._nodeCache.getStats().vsize < 500000000) {
+                                        neededSizeIndex = zz;
+                                        break;
+                                    }
+                                }
+                                // console.log('Cache1: ' + 'Too Big - ' + subscription.publication + ' - ' + getBinarySize(JSON.stringify(this._subCache)));
+                                _this._subCache.splice(0, neededSizeIndex);
+                            }
+                            for (var i = _this._subCache.length - 1; i >= 0; i--) {
+                                if (_this._subCache[i].publication === subscription.publication && JSON.stringify(_this._subCache[i].subscriptionData) === JSON.stringify(subscription.subscriptionData)) {
+                                    _this._nodeCache.del(_this._subCache[i].id);
+                                    _this._subCache.splice(i, 1);
+                                }
+                            }
+                            if (_this._subscriptions.some(function (a) { return a.collections.includes(collection) && a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData); })) {
+                                var cacheId = _this._cacheId++;
+                                _this._nodeCache.set(cacheId, res);
+                                _this._subCache.push({ collection: collection, publication: subscription.publication, subscriptionData: subscription.subscriptionData, id: cacheId });
+                                var serverRes = {
+                                    messageId: messageId,
+                                    hasError: false,
+                                    data: res
+                                };
+                                _this.sendWS(ws, serverRes);
+                            }
+                            resolve(true);
+                        }, function (err) {
+                            var serverRes = {
                                 messageId: messageId,
-                                hasError: false,
-                                data: res
+                                hasError: true,
+                                data: err
                             };
-                            this.sendWS(ws, serverRes);
-                        }
+                            _this.sendWS(ws, serverRes);
+                            reject(err);
+                        });
+                    }
+                }
+                else { // Pub is different for each user (Look at users publication) [MUCH SLOWER, RE-RUNS FOR EACH USER]
+                    (_b = that._publications[subscription.publication].function).call.apply(_b, __spreadArrays([Object.assign({}, that, SubscriptionManager.prototype), ws['id_user']], subscription.subscriptionData)).catch(function (methodErrs) {
+                        that._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Subscription ' + subscription.publication + ' - (sendPubDataOnce - WS)\n\nData \n' + JSON.stringify(subscription.subscriptionData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
+                    }).then(function (res) {
+                        var serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: res
+                        };
+                        // console.log('Send Pub Data Once 2', new Date(), 'Success', subscription);
+                        _this.sendWS(ws, serverRes);
                         resolve(true);
-                    }, err => {
-                        let serverRes = {
+                    }, function (err) {
+                        var serverRes = {
                             messageId: messageId,
                             hasError: true,
                             data: err
                         };
-                        this.sendWS(ws, serverRes);
+                        // console.log('Send Pub Data Once 2', new Date(), 'Error', subscription);
+                        _this.sendWS(ws, serverRes);
                         reject(err);
                     });
                 }
-            }
-            else { // Pub is different for each user (Look at users publication) [MUCH SLOWER, RE-RUNS FOR EACH USER]
-                that._publications[subscription.publication].function.call(Object.assign({}, that, SubscriptionManager.prototype), ws['id_user'], ...subscription.subscriptionData).catch(methodErrs => {
-                    that._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Subscription ' + subscription.publication + ' - (sendPubDataOnce - WS)\n\nData \n' + JSON.stringify(subscription.subscriptionData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
-                }).then(res => {
-                    let serverRes = {
-                        messageId: messageId,
-                        hasError: false,
-                        data: res
-                    };
-                    // console.log('Send Pub Data Once 2', new Date(), 'Success', subscription);
-                    this.sendWS(ws, serverRes);
-                    resolve(true);
-                }, err => {
-                    let serverRes = {
-                        messageId: messageId,
-                        hasError: true,
-                        data: err
-                    };
-                    // console.log('Send Pub Data Once 2', new Date(), 'Error', subscription);
-                    this.sendWS(ws, serverRes);
-                    reject(err);
-                });
-            }
-        });
-    }
+                return [2 /*return*/];
+            });
+        }); });
+    };
     // Fetch pub once, send to all clients linked to this pub
-    sendPubData(subscription, type, collection) {
-        return new Promise(async (resolve, reject) => {
-            let that = this;
-            if (!subscription.clients.length) {
-                for (let i = this._subCache.length - 1; i >= 0; i--) {
-                    if (this._subCache[i].publication === subscription.publication && JSON.stringify(this._subCache[i].subscriptionData) === JSON.stringify(subscription.subscriptionData)) {
-                        this._nodeCache.del(this._subCache[i].id);
-                        this._subCache.splice(i, 1);
+    SubscriptionManager.prototype.sendPubData = function (subscription, type, collection) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var that, i, i;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                that = this;
+                if (!subscription.clients.length) {
+                    for (i = this._subCache.length - 1; i >= 0; i--) {
+                        if (this._subCache[i].publication === subscription.publication && JSON.stringify(this._subCache[i].subscriptionData) === JSON.stringify(subscription.subscriptionData)) {
+                            this._nodeCache.del(this._subCache[i].id);
+                            this._subCache.splice(i, 1);
+                        }
                     }
-                }
-                if (that._subscriptions.findIndex(a => a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData)) >= 0) {
-                    that._subscriptions.splice(that._subscriptions.findIndex(a => a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData)), 1);
-                }
-            }
-            else {
-                if (subscription.publication !== 'superadminAPM' && subscription.publication !== 'loggedInUsers') {
-                    that._mainServer.getMethodManager().callMethodInternal('insertSubscriptionLog', type, subscription.publication, collection, JSON.stringify(subscription.subscriptionData));
-                }
-                for (let i = this._subCache.length - 1; i >= 0; i--) {
-                    if (this._subCache[i].publication === subscription.publication && JSON.stringify(this._subCache[i].subscriptionData) === JSON.stringify(subscription.subscriptionData)) {
-                        this._nodeCache.del(this._subCache[i].id);
-                        this._subCache.splice(i, 1);
+                    if (that._subscriptions.findIndex(function (a) { return a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData); }) >= 0) {
+                        that._subscriptions.splice(that._subscriptions.findIndex(function (a) { return a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData); }), 1);
                     }
                 }
-                that._publications[subscription.publication].function.call(Object.assign({}, that, SubscriptionManager.prototype), ...subscription.subscriptionData).catch(methodErrs => {
-                    that._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Subscription ' + subscription.publication + ' - (sendPubData)\n\nData \n' + JSON.stringify(subscription.subscriptionData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
-                }).then(res => {
-                    let nodeCacheSize = this._nodeCache.getStats().vsize;
-                    if (nodeCacheSize > 500000000) {
-                        let neededSizeIndex = 0;
-                        for (let zz = 0; zz < this._subCache.length; zz++) {
-                            this._nodeCache.del(this._subCache[zz].id);
-                            if (this._nodeCache.getStats().vsize < 500000000) {
-                                neededSizeIndex = zz;
-                                break;
-                            }
-                        }
-                        // console.log('Cache: ' + 'Too Big - ' + subscription.publication + ' - ' + getBinarySize(JSON.stringify(this._subCache)));
-                        this._subCache.splice(0, neededSizeIndex);
+                else {
+                    if (subscription.publication !== 'superadminAPM' && subscription.publication !== 'loggedInUsers') {
+                        that._mainServer.getMethodManager().callMethodInternal('insertSubscriptionLog', type, subscription.publication, collection, JSON.stringify(subscription.subscriptionData));
                     }
-                    for (let i = this._subCache.length - 1; i >= 0; i--) {
+                    for (i = this._subCache.length - 1; i >= 0; i--) {
                         if (this._subCache[i].publication === subscription.publication && JSON.stringify(this._subCache[i].subscriptionData) === JSON.stringify(subscription.subscriptionData)) {
                             this._nodeCache.del(this._subCache[i].id);
                             this._subCache.splice(i, 1);
                         }
                     }
-                    if (!subscription.clients.length) {
-                        if (that._subscriptions.findIndex(a => a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData)) >= 0) {
-                            that._subscriptions.splice(that._subscriptions.findIndex(a => a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData)), 1);
+                    (_a = that._publications[subscription.publication].function).call.apply(_a, __spreadArrays([Object.assign({}, that, SubscriptionManager.prototype)], subscription.subscriptionData)).catch(function (methodErrs) {
+                        that._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Subscription ' + subscription.publication + ' - (sendPubData)\n\nData \n' + JSON.stringify(subscription.subscriptionData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
+                    }).then(function (res) {
+                        var nodeCacheSize = _this._nodeCache.getStats().vsize;
+                        if (nodeCacheSize > 500000000) {
+                            var neededSizeIndex = 0;
+                            for (var zz = 0; zz < _this._subCache.length; zz++) {
+                                _this._nodeCache.del(_this._subCache[zz].id);
+                                if (_this._nodeCache.getStats().vsize < 500000000) {
+                                    neededSizeIndex = zz;
+                                    break;
+                                }
+                            }
+                            // console.log('Cache: ' + 'Too Big - ' + subscription.publication + ' - ' + getBinarySize(JSON.stringify(this._subCache)));
+                            _this._subCache.splice(0, neededSizeIndex);
                         }
-                    }
-                    else {
-                        if (this._subscriptions.some(a => a.collections.includes(collection) && a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData))) {
-                            let cacheId = this._cacheId++;
-                            this._nodeCache.set(cacheId, res);
-                            this._subCache.push({ collection: collection, publication: subscription.publication, subscriptionData: subscription.subscriptionData, id: cacheId });
-                            subscription.clients.forEach(client => {
-                                that._wss.clients.forEach(ws => {
-                                    if (ws['id_socket'] === client.id_socket) {
-                                        let serverRes = {
-                                            messageId: client.messageId,
-                                            hasError: false,
-                                            data: res
-                                        };
-                                        this.sendWS(ws, serverRes);
-                                    }
-                                });
-                            });
+                        for (var i = _this._subCache.length - 1; i >= 0; i--) {
+                            if (_this._subCache[i].publication === subscription.publication && JSON.stringify(_this._subCache[i].subscriptionData) === JSON.stringify(subscription.subscriptionData)) {
+                                _this._nodeCache.del(_this._subCache[i].id);
+                                _this._subCache.splice(i, 1);
+                            }
                         }
-                    }
-                    resolve(true);
-                }, err => {
-                    subscription.clients.forEach(client => {
-                        that._wss.clients.forEach(ws => {
-                            if (ws['id_socket'] === client.id_socket) {
-                                let serverRes = {
-                                    messageId: client.messageId,
-                                    hasError: true,
-                                    data: err
-                                };
-                                this.sendWS(ws, serverRes);
+                        if (!subscription.clients.length) {
+                            if (that._subscriptions.findIndex(function (a) { return a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData); }) >= 0) {
+                                that._subscriptions.splice(that._subscriptions.findIndex(function (a) { return a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData); }), 1);
+                            }
+                        }
+                        else {
+                            if (_this._subscriptions.some(function (a) { return a.collections.includes(collection) && a.publication === subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscription.subscriptionData); })) {
+                                var cacheId = _this._cacheId++;
+                                _this._nodeCache.set(cacheId, res);
+                                _this._subCache.push({ collection: collection, publication: subscription.publication, subscriptionData: subscription.subscriptionData, id: cacheId });
+                                subscription.clients.forEach(function (client) {
+                                    that._wss.clients.forEach(function (ws) {
+                                        if (ws['id_socket'] === client.id_socket) {
+                                            var serverRes = {
+                                                messageId: client.messageId,
+                                                hasError: false,
+                                                data: res
+                                            };
+                                            _this.sendWS(ws, serverRes);
+                                        }
+                                    });
+                                });
                             }
+                        }
+                        resolve(true);
+                    }, function (err) {
+                        subscription.clients.forEach(function (client) {
+                            that._wss.clients.forEach(function (ws) {
+                                if (ws['id_socket'] === client.id_socket) {
+                                    var serverRes = {
+                                        messageId: client.messageId,
+                                        hasError: true,
+                                        data: err
+                                    };
+                                    _this.sendWS(ws, serverRes);
+                                }
+                            });
                         });
+                        reject(err);
                     });
-                    reject(err);
-                });
-            }
-        });
-    }
-    sendWS(ws, data) {
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    SubscriptionManager.prototype.sendWS = function (ws, data) {
         this._sendQueue.splice(0, 0, {
             id_ws: ws['id_socket'],
             data: data
         });
-    }
-}
+    };
+    return SubscriptionManager;
+}());
+exports.SubscriptionManager = SubscriptionManager;
 
 //# sourceMappingURL=subscription.manager.js.map