@resolveio/server-lib 9.0.32 → 9.0.34

package/managers/subscription.manager.js

@@ -1,73 +1,26 @@
-"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;
+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) {
         this._publications = {};
         this._subscriptions = [];
         this._loggedInUsers = [];
@@ -81,348 +34,269 @@ var SubscriptionManager = /** @class */ (function () {
         this.serverConfig = serverConfig;
         this._wss = wss;
         // Publications
-        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);
+        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);
         this.tailOpLog();
         this.runOpLogQueue();
-        setInterval(function () {
+        setInterval(() => {
             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(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);
+        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);
                         if (ws && ws.readyState === ws.OPEN) {
                             if (ws.bufferedAmount < 20480) {
-                                var sendItem = _this._sendQueue.pop();
-                                ws.send(JSON.stringify(sendItem.data), function (error) {
+                                let sendItem = this._sendQueue.pop();
+                                ws.send(JSON.stringify(sendItem.data), (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(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; })) {
+        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) {
                                     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 });
                         }
-                        return [2 /*return*/];
+                        this._loggedInUsers.splice(i, 1);
+                    }
                 }
-            });
-        }); }, 60000);
+            }
+            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);
     }
     // Add all files to publications private object
-    SubscriptionManager.prototype.publications = function (method) {
+    publications(method) {
         this._publications = Object.assign(this._publications, method);
-    };
-    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 (err) {
-                    _this.unsubscribeAll(ws);
-                });
-                return [2 /*return*/];
-            });
+    }
+    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);
         });
-    };
+    }
     // Subscribe to publication
-    SubscriptionManager.prototype.subscribe = function (messageDate, ws, messageId, publication) {
-        var subscriptionData = [];
-        for (var _i = 4; _i < arguments.length; _i++) {
-            subscriptionData[_i - 4] = arguments[_i];
+    async subscribe(messageDate, ws, messageId, publication, ...subscriptionData) {
+        let that = this;
+        let pub = that._publications[publication];
+        if (!pub) {
+            console.error('No Publication: ' + publication);
+            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*/];
+        else {
+            if (subscriptionData.length > 1 || subscriptionData[0]) {
+                if (!pub.check) {
+                    console.error('No Check Function For Pub ' + publication);
+                    return;
                 }
-            });
-        });
-    };
-    // Unsubscribe from publication 
-    SubscriptionManager.prototype.unsubscribe = function (messageDate, ws, messageId, publication) {
-        var subscriptionData = [];
-        for (var _i = 4; _i < arguments.length; _i++) {
-            subscriptionData[_i - 4] = arguments[_i];
-        }
-        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 if (!pub.check._schema) {
+                    console.error('No Check Schema For Pub ' + publication);
+                    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);
-                            }
+                    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 [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;
+        }
+        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);
+                    }
+                }
+            }
+        }
+    }
     // Unsubscribe from publication
-    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*/];
+    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);
                 }
-            });
-        });
-    };
+            }
+        }
+        ws.terminate();
+        // console.log('After');
+        // console.dir(this._subscriptions.map(a => a.publication));
+    }
     // Get publication collection
-    SubscriptionManager.prototype.getPublicationCollections = function (publication) {
+    getPublicationCollections(publication) {
         return this._publications[publication].collections;
-    };
+    }
     // Watch (tail) Mongo's operation log on the entire database (all insert/modify/delete will trigger this function)
-    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;
+    tailOpLog() {
+        this._oplog = ResolveIOServer.getMainDB().watch([], { fullDocument: 'updateLookup' });
+        this._oplog.on('change', (doc) => {
+            let 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
@@ -431,437 +305,370 @@ var SubscriptionManager = /** @class */ (function () {
                 }
                 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', function (error) {
+        this._oplog.on('error', error => {
             console.log('oplog error', error);
             process.exit();
         });
-        this._oplog.on('end', function () {
+        this._oplog.on('end', () => {
             console.log('oplog ended');
             process.exit();
         });
-    };
-    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);
-                                    }
-                                }
-                                uniqueOplog_1.splice(i, 1);
+    }
+    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);
                             }
-                        };
-                        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();
+                        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;
+                                    }
+                                }
+                                if (that._publications[sub.publication].preFunction) {
+                                    if (sub.clients.length) {
+                                        sub.preSubscriptionData = await that._publications[sub.publication].preFunction(...sub.subscriptionData);
                                         if (that._publications[sub.publication].fetchFunction(oplog.doc, sub.preSubscriptionData)) {
                                             sub['oplog'] = oplog;
-                                            uniquePubs.push(common_1.deepCopy(sub));
+                                            uniquePubs.push(deepCopy(sub));
                                         }
-                                        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);
+                                    }
+                                    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);
                                             }
                                         }
-                                        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);
-                                        }
-                                        _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));
-                                            }
+                                        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);
                                         }
-                                        else {
+                                    }
+                                }
+                                else {
+                                    if (that._publications[sub.publication].fetchFunction) {
+                                        if (that._publications[sub.publication].fetchFunction(oplog.doc, ...sub.subscriptionData)) {
                                             sub['oplog'] = oplog;
-                                            uniquePubs.push(common_1.deepCopy(sub));
+                                            uniquePubs.push(deepCopy(sub));
                                         }
-                                        _d.label = 5;
-                                    case 5: return [2 /*return*/];
+                                    }
+                                    else {
+                                        sub['oplog'] = oplog;
+                                        uniquePubs.push(deepCopy(sub));
+                                    }
                                 }
-                            });
-                        };
-                        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*/];
-                }
-            });
-        }); }, 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);
                 }
-                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);
-                                }
-                            }
+                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);
+    }
+    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);
                         }
                     }
-                    else {
-                        that.sendPubData(sub, 'delete', collection);
-                    }
                 }
-                return [2 /*return*/];
-            });
-        });
-    };
+            }
+            else {
+                that.sendPubData(sub, 'delete', collection);
+            }
+        }
+    }
     // Document: Inserted/Modified Document
     // Collection: Collection Document Lives In
     // Check to see if any pubs need to refetch due to Mongo operation
-    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);
-                                    }
+    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);
                                 }
                             }
                         }
                     }
                     else {
-                        if (that._publications[sub.publication].fetchFunction) {
-                            if ((_b = that._publications[sub.publication]).fetchFunction.apply(_b, __spreadArrays([document], sub.subscriptionData))) {
-                                that.sendPubData(sub, type, collection);
+                        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);
                             }
-                            // else
-                        }
-                        else {
-                            that.sendPubData(sub, type, collection);
                         }
                     }
                 }
-                return [2 /*return*/];
-            });
-        });
-    };
+            }
+            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);
+                }
+            }
+        }
+    }
     // Fetch pub once, send to all clients linked to this pub
-    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);
+    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));
                     }
-                    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);
                         }
-                        for (i = this._subCache.length - 1; i >= 0; i--) {
+                    }
+                    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);
+                        }
+                        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);
                             }
                         }
-                        (_a = that._publications[subscription.publication].function).call.apply(_a, __spreadArrays([Object.assign({}, that, SubscriptionManager.prototype)], subscription.subscriptionData)).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 = {
+                        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 = {
                                 messageId: messageId,
-                                hasError: true,
-                                data: err
+                                hasError: false,
+                                data: res
                             };
-                            _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)).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);
+                            this.sendWS(ws, serverRes);
+                        }
                         resolve(true);
-                    }, function (err) {
-                        var serverRes = {
+                    }, err => {
+                        let serverRes = {
                             messageId: messageId,
                             hasError: true,
                             data: err
                         };
-                        // console.log('Send Pub Data Once 2', new Date(), 'Error', subscription);
-                        _this.sendWS(ws, serverRes);
+                        this.sendWS(ws, serverRes);
                         reject(err);
                     });
                 }
-                return [2 /*return*/];
-            });
-        }); });
-    };
+            }
+            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);
+                });
+            }
+        });
+    }
     // Fetch pub once, send to all clients linked to this pub
-    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);
-                        }
+    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);
                     }
-                    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);
+                }
+                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);
                     }
                 }
-                else {
-                    if (subscription.publication !== 'superadminAPM' && subscription.publication !== 'loggedInUsers') {
-                        that._mainServer.getMethodManager().callMethodInternal('insertSubscriptionLog', type, subscription.publication, collection, JSON.stringify(subscription.subscriptionData));
+                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);
                     }
-                    for (i = this._subCache.length - 1; i >= 0; i--) {
+                    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);
                         }
                     }
-                    (_a = that._publications[subscription.publication].function).call.apply(_a, __spreadArrays([Object.assign({}, that, SubscriptionManager.prototype)], subscription.subscriptionData)).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);
-                        }
-                        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 (!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);
                         }
-                        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);
-                                        }
-                                    });
+                    }
+                    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);
+                                    }
                                 });
-                            }
-                        }
-                        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);
-                                }
                             });
+                        }
+                    }
+                    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);
+                            }
                         });
-                        reject(err);
                     });
-                }
-                return [2 /*return*/];
-            });
-        }); });
-    };
-    SubscriptionManager.prototype.sendWS = function (ws, data) {
+                    reject(err);
+                });
+            }
+        });
+    }
+    sendWS(ws, data) {
         this._sendQueue.splice(0, 0, {
             id_ws: ws['id_socket'],
             data: data
         });
-    };
-    return SubscriptionManager;
-}());
-exports.SubscriptionManager = SubscriptionManager;
+    }
+}
 
 //# sourceMappingURL=subscription.manager.js.map