@resolveio/server-lib 12.5.54 → 12.5.55

package/managers/subscription.manager.js

@@ -0,0 +1,1091 @@
+"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 (g && (g = 0, op[0] && (_ = 0)), _) 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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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 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_responses_1 = require("../publications/method-responses");
+var index_1 = require("../index");
+var notifications_1 = require("../publications/notifications");
+var report_builder_reports_1 = require("../publications/report-builder-reports");
+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 common_1 = require("../util/common");
+var NodeCache = require("node-cache");
+var flag_collection_1 = require("../collections/flag.collection");
+var os_1 = require("os");
+var numCPUs = (0, os_1.cpus)().length;
+var v8 = require('v8');
+// interface CurrentPerformanceMonitor {
+// 	_id: number;
+// 	function: string;
+// 	publication: string;
+// 	subscriptionData: any[];
+// 	date_start: Date;
+// 	date_end: Date;
+// 	duration: number;
+// 	result: string;
+// }
+var SubscriptionManager = /** @class */ (function () {
+    // private currentPerfomanceMonitor: CurrentPerformanceMonitor[] = [];
+    // private idPerformance: number = 0;
+    // private performanceThread;
+    function SubscriptionManager(mainServer, wss, serverConfig, monitorManagerFunction) {
+        var _this = this;
+        this._publications = {};
+        this._subscriptions = [];
+        this._loggedInUsers = [];
+        this._mongoQueue = [];
+        this._mongoQueueId = 0;
+        this._sendQueue = [];
+        this._runningQueue = false;
+        this._cacheId = 1;
+        this._heapStats = v8.getHeapStatistics();
+        this._heapLimit = this._heapStats.heap_size_limit / numCPUs / 8;
+        this._enableDebug = false;
+        this._debugOplogCollections = [];
+        this._debugOplogHits = 0;
+        this._debugSubCollections = [];
+        this._debugSubHits = 0;
+        this._debugUnSubHits = 0;
+        this._debugUnSubAllHits = 0;
+        this._debugMongoQueueHits = 0;
+        this._debugMongoQueueCollections = [];
+        this._debugSendQueueHits = 0;
+        this._debugRemoveCacheHits = 0;
+        this._oplogRetryCount = 0;
+        this._mainServer = mainServer;
+        this._monitorManagerFunction = monitorManagerFunction;
+        this._nodeCache = new NodeCache({ stdTTL: 0, checkperiod: 0 });
+        // setTimeout(() => {
+        // 	console.log('Setting up performance thread');
+        // 	this.performanceThread = new Worker(path.join(__dirname, './subscription.performance.js'));
+        // 	this.performanceThread.on('exit', code => {
+        // 		console.error(new Date(), 'THREAD EXITED!!!!!!!!!!!!!!!!!!', code);
+        // 	});
+        // 	this.performanceThread.on('error', code => {
+        // 		console.error(new Date(), 'THREAD RECV ERROR !!!!!!!!!!!!!!!!!!', code);
+        // 	});
+        // }, 5000);
+        // setInterval(() => {
+        // 	console.log('Post thread msg');
+        // 	this.performanceThread.postMessage(this.currentPerfomanceMonitor);
+        // 	this.currentPerfomanceMonitor = [];
+        // }, 10000);
+        this.serverConfig = serverConfig;
+        this._wss = wss;
+        // Publications
+        (0, super_admin_1.loadSuperAdminPublications)(this);
+        (0, app_status_1.loadAppStatusPublications)(this);
+        (0, logs_1.loadLogPublications)(this);
+        (0, files_1.loadFilePublications)(this);
+        (0, cron_jobs_1.loadCronJobPublications)(this);
+        (0, flags_1.loadFlagsPublications)(this);
+        (0, method_responses_1.loadMethodResponsePublications)(this);
+        (0, notifications_1.loadNotificationPublications)(this);
+        (0, report_builder_reports_1.loadReportBuilderReportPublications)(this);
+        (0, report_builder_libraries_1.loadReportBuilderLibraryPublications)(this);
+        (0, user_groups_1.loadUserGroupPublications)(this);
+        (0, user_guides_1.loadUserGuidePublications)(this);
+        (0, report_builder_dashboard_builders_1.loadReportBuilderDashboardBuilderPublications)(this);
+        this.tailOpLog();
+        setInterval(function () {
+            _this._oplogRetryCount = 0;
+        }, 15000);
+        setInterval(function () {
+            if (_this.getEnableDebug()) {
+                console.log(new Date(), 'Sub Manager', 'Subs', _this._subscriptions.length);
+                console.log(new Date(), 'Sub Manager', 'Logged In Users', _this._loggedInUsers.length);
+                console.log(new Date(), 'Sub Manager', 'Mongo Queue', _this._mongoQueue.length);
+                console.log(new Date(), 'Sub Manager', 'Mongo Queue Hits', _this._debugMongoQueueHits);
+                console.log(new Date(), 'Sub Manager', 'Mongo Queue Collections', JSON.stringify(_this._debugMongoQueueCollections.sort(function (a, b) { return a.collection.localeCompare(b.collection) || a.publication.localeCompare(b.publication); }), null, 2));
+                console.log(new Date(), 'Sub Manager', 'Oplog Hits', _this._debugOplogHits);
+                console.log(new Date(), 'Sub Manager', 'Oplog Collections', JSON.stringify(_this._debugOplogCollections.sort(function (a, b) { return a.collection.localeCompare(b.collection) || a.type.localeCompare(b.type); }), null, 2));
+                console.log(new Date(), 'Sub Manager', 'Send Queue Hits', _this._debugSendQueueHits);
+                console.log(new Date(), 'Sub Manager', 'Sub Hits', _this._debugSubHits);
+                console.log(new Date(), 'Sub Manager', 'Sub Collections', JSON.stringify(_this._debugSubCollections.sort(function (a, b) { return a.publication.localeCompare(b.publication); }), null, 2));
+                console.log(new Date(), 'Sub Manager', 'Unsub Hits', _this._debugUnSubHits);
+                console.log(new Date(), 'Sub Manager', 'Unsub All Hits', _this._debugUnSubAllHits);
+                console.log(new Date(), 'Sub Manager', 'Cache Cleanup Hits', _this._debugRemoveCacheHits);
+            }
+            _this._debugOplogHits = 0;
+            _this._debugOplogCollections = [];
+            _this._debugSubCollections = [];
+            _this._debugMongoQueueHits = 0;
+            _this._debugMongoQueueCollections = [];
+            _this._debugSendQueueHits = 0;
+            _this._debugSubHits = 0;
+            _this._debugUnSubHits = 0;
+            _this._debugUnSubAllHits = 0;
+            _this._debugRemoveCacheHits = 0;
+        }, 60000);
+        setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _loop_1, this_1, i, queueArr, _loop_2, this_2, i;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!this._runningQueue) {
+                    this._runningQueue = true;
+                    if (this._sendQueue.length) {
+                        _loop_1 = function (i) {
+                            this_1._debugSendQueueHits += 1;
+                            var ws = this_1._mainServer.getWS(this_1._sendQueue[i].id_ws);
+                            if (ws && ws.readyState === ws.OPEN) {
+                                if (ws.bufferedAmount < 20480) {
+                                    var sendItem = this_1._sendQueue.pop();
+                                    ws.send(JSON.stringify(sendItem.data), function (error) {
+                                        if (error) {
+                                            console.log('Error on WS: ', error);
+                                            if (_this.getEnableDebug()) {
+                                                console.log(new Date(), 'Sub Manager', 'Unsub WS', ws['user'], ws['id_socket'], 1);
+                                            }
+                                            _this.unsubscribeAll(ws);
+                                        }
+                                    });
+                                }
+                            }
+                            else {
+                                this_1._sendQueue.splice(i, 1);
+                            }
+                        };
+                        this_1 = this;
+                        // let startDate = new Date();
+                        for (i = this._sendQueue.length - 1; i >= 0; i--) {
+                            _loop_1(i);
+                        }
+                        // let endDate = new Date();
+                        // this.currentPerfomanceMonitor.push({
+                        // 	_id: this.idPerformance++,
+                        // 	function: 'sendInterval',
+                        // 	publication: '',
+                        // 	subscriptionData: [],
+                        // 	date_start: startDate,
+                        // 	date_end: endDate,
+                        // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                        // 	result: 'Done'
+                        // });
+                    }
+                    queueArr = this._mongoQueue.filter(function (a) { return !a.running; });
+                    if (queueArr.length) {
+                        queueArr.forEach(function (entry) {
+                            entry.running = true;
+                        });
+                        _loop_2 = function (i) {
+                            this_2._debugMongoQueueHits += 1;
+                            var mongoQueue = queueArr[i];
+                            if (!this_2._debugMongoQueueCollections.some(function (a) { return a.collection === mongoQueue.collection && a.publication === mongoQueue.subscription.publication; })) {
+                                this_2._debugMongoQueueCollections.push({
+                                    collection: mongoQueue.collection,
+                                    publication: mongoQueue.subscription.publication,
+                                    hits: 1
+                                });
+                            }
+                            else {
+                                this_2._debugMongoQueueCollections.filter(function (a) { return a.collection === mongoQueue.collection && a.publication === mongoQueue.subscription.publication; })[0].hits += 1;
+                            }
+                            if (this_2._publications[mongoQueue.subscription.publication].user_specific) {
+                                var promises = [];
+                                var _loop_3 = function (j) {
+                                    var client = mongoQueue.subscription.clients[j];
+                                    var ws = this_2._mainServer.getWS(client.id_socket);
+                                    if (ws && ws['id_socket'] === client.id_socket) {
+                                        promises.push(this_2.sendDataToOne(ws, client.messageId, mongoQueue.subscription, mongoQueue.type, mongoQueue.collection).catch(function (err) {
+                                            _this._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + _this.serverConfig['CLIENT_NAME'], 'Error Detected During sendDataToOne - User Specific - Socket: ' + client.id_socket + ', User: ' + client.id_user + ', MessageId: ' + client.messageId + ', Pub: ' + mongoQueue.subscription.publication + ', Err: ' + JSON.stringify(err, null, 2));
+                                            return null;
+                                        }));
+                                    }
+                                };
+                                for (var j = 0; j < mongoQueue.subscription.clients.length; j++) {
+                                    _loop_3(j);
+                                }
+                                Promise.all(promises).then(function () {
+                                    if (mongoQueue.run_again) {
+                                        mongoQueue.running = false;
+                                        mongoQueue.run_again = false;
+                                    }
+                                    else {
+                                        if (_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id) >= 0) {
+                                            _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id), 1);
+                                        }
+                                    }
+                                });
+                            }
+                            else {
+                                this_2.sendDataToAll(mongoQueue).then(function () {
+                                    if (mongoQueue.run_again) {
+                                        mongoQueue.running = false;
+                                        mongoQueue.run_again = false;
+                                    }
+                                    else {
+                                        if (_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id) >= 0) {
+                                            _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id), 1);
+                                        }
+                                    }
+                                }, function () {
+                                    if (_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id) >= 0) {
+                                        _this._mongoQueue.splice(_this._mongoQueue.map(function (a) { return a._id; }).indexOf(mongoQueue._id), 1);
+                                    }
+                                });
+                            }
+                        };
+                        this_2 = this;
+                        for (i = queueArr.length - 1; i >= 0; i--) {
+                            _loop_2(i);
+                        }
+                        // let endDate = new Date();
+                        // this.currentPerfomanceMonitor.push({
+                        // 	_id: this.idPerformance++,
+                        // 	function: 'mongoQueue',
+                        // 	publication: '',
+                        // 	subscriptionData: [],
+                        // 	date_start: startDate,
+                        // 	date_end: endDate,
+                        // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                        // 	result: 'Done'
+                        // });
+                    }
+                    this._runningQueue = false;
+                }
+                return [2 /*return*/];
+            });
+        }); }, 25);
+        setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _a, userCopy, _loop_4, this_3, i, i, sub, _loop_5, this_4, 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 = (0, common_1.deepCopy)(this._loggedInUsers);
+                        _loop_4 = function (i) {
+                            var loggedInUser = userCopy[i];
+                            if (!loggedInUser.date || Date.now() - loggedInUser.date.getTime() > 120000) {
+                                if (this_3._mainServer.getWS(loggedInUser.id_ws)) {
+                                    if (this_3.getEnableDebug()) {
+                                        console.log(new Date(), 'Sub Manager', 'Unsub WS', this_3._mainServer.getWS(loggedInUser.id_ws)['user'], this_3._mainServer.getWS(loggedInUser.id_ws)['id_socket'], 2);
+                                    }
+                                    this_3.unsubscribeAll(this_3._mainServer.getWS(loggedInUser.id_ws));
+                                }
+                                else {
+                                    this_3._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);
+                                            }
+                                        }
+                                    });
+                                    logged_in_users_collection_1.LoggedInUsers.deleteOne({ _id: loggedInUser._id });
+                                    if (this_3._loggedInUsers.findIndex(function (a) { return a._id === loggedInUser._id; }) >= 0) {
+                                        this_3._loggedInUsers.splice(this_3._loggedInUsers.findIndex(function (a) { return a._id === loggedInUser._id; }), 1);
+                                    }
+                                }
+                            }
+                        };
+                        this_3 = this;
+                        for (i = this._loggedInUsers.length - 1; i >= 0; i--) {
+                            _loop_4(i);
+                        }
+                        for (i = 0; i < this._subscriptions.length; i++) {
+                            sub = this._subscriptions[i];
+                            _loop_5 = function (j) {
+                                var client = sub.clients[j];
+                                if (!this_4._loggedInUsers.some(function (a) { return a.id_ws === client.id_socket; })) {
+                                    sub.clients.splice(j, 1);
+                                }
+                            };
+                            this_4 = this;
+                            for (j = sub.clients.length - 1; j >= 0; j--) {
+                                _loop_5(j);
+                            }
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); }, 30000);
+        flag_collection_1.Flags.findOne({ type: 'Enable Debug' }).then(function (flag) {
+            if (flag && flag.value) {
+                _this._enableDebug = true;
+            }
+            else {
+                _this._enableDebug = false;
+            }
+        });
+    }
+    SubscriptionManager.prototype.addToQueue = function (mongoQueue) {
+        // let startDate = new Date();
+        var _mongoQueue = this._mongoQueue.filter(function (a) { return a.subscription.publication === mongoQueue.subscription.publication && JSON.stringify(a.subscription.subscriptionData) === JSON.stringify(mongoQueue.subscription.subscriptionData); })[0];
+        if (_mongoQueue) {
+            if (_mongoQueue.running) {
+                _mongoQueue.run_again = true;
+                // let endDate = new Date();
+                // this.currentPerfomanceMonitor.push({
+                // 	_id: this.idPerformance++,
+                // 	function: 'addToQueue',
+                // 	publication: mongoQueue.subscription.publication,
+                // // 	subscriptionData: mongoQueue.subscription.subscriptionData,
+                // 	subscriptionData: [],
+                // 	date_start: startDate,
+                // 	date_end: endDate,
+                // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                // 	result: 'Run Again'
+                // });
+            }
+            // else {
+            // 	let endDate = new Date();
+            // 	this.currentPerfomanceMonitor.push({
+            // 		_id: this.idPerformance++,
+            // 		function: 'addToQueue',
+            // 		publication: mongoQueue.subscription.publication,
+            // // 	subscriptionData: mongoQueue.subscription.subscriptionData,
+            // 		subscriptionData: [],
+            // 		date_start: startDate,
+            // 		date_end: endDate,
+            // 		duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+            // 		result: 'Not Running Yet'
+            // 	});
+            // }
+        }
+        else {
+            mongoQueue._id = this._mongoQueueId;
+            this._mongoQueueId += 1;
+            this._mongoQueue.splice(0, 0, mongoQueue);
+            // let endDate = new Date();
+            // this.currentPerfomanceMonitor.push({
+            // 	_id: this.idPerformance++,
+            // 	function: 'addToQueue',
+            // 	publication: mongoQueue.subscription.publication,
+            // // 	subscriptionData: mongoQueue.subscription.subscriptionData,
+            // 	subscriptionData: [],
+            // 	date_start: startDate,
+            // 	date_end: endDate,
+            // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+            // 	result: 'Add to Queue'
+            // });
+        }
+    };
+    SubscriptionManager.prototype.invalidatePubsCache = function (collection, type) {
+        // let startDate = new Date();
+        index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(collection);
+        var collSubs = this._subscriptions.filter(function (a) { return a.collections.includes(collection); });
+        for (var i = collSubs.length - 1; i >= 0; i--) {
+            var sub = collSubs[i];
+            this.addToQueue({
+                _id: 0,
+                type: type,
+                collection: collection,
+                subscription: sub,
+                running: false,
+                run_again: false
+            });
+        }
+        // let endDate = new Date();
+        // this.currentPerfomanceMonitor.push({
+        // 	_id: this.idPerformance++,
+        // 	function: 'invalidatePubsCache',
+        // 	publication: collection,
+        // 	subscriptionData: [],
+        // 	date_start: startDate,
+        // 	date_end: endDate,
+        // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+        // 	result: 'Done'
+        // });
+    };
+    // Add all files to publications private object
+    SubscriptionManager.prototype.publications = function (method) {
+        this._publications = Object.assign(this._publications, method);
+    };
+    SubscriptionManager.prototype.loggedInLatency = function (ws) {
+        var _this = this;
+        var loggedInUser = this._loggedInUsers.filter(function (a) { return a.id_ws === ws['id_socket']; })[0];
+        if (loggedInUser) {
+            loggedInUser.date = new Date();
+            logged_in_users_collection_1.LoggedInUsers.updateOne({ id_ws: ws['id_socket'] }, { $set: { latency: ws['latency'], date: loggedInUser.date } }).then(function (res) {
+                if (!res) {
+                    _this.unsubscribeAll(ws);
+                    if (_this.getEnableDebug()) {
+                        console.log(new Date(), 'Sub Manager', 'Unsub WS', ws['user'], ws['id_socket'], 3);
+                    }
+                }
+            }, function () {
+                _this.unsubscribeAll(ws);
+                if (_this.getEnableDebug()) {
+                    console.log(new Date(), 'Sub Manager', 'Unsub WS', ws['user'], ws['id_socket'], 4);
+                }
+            });
+        }
+    };
+    // Subscribe to publication
+    SubscriptionManager.prototype.subscribe = function (messageRoute, messageDate, ws, messageId, publication, subscriptionData) {
+        var _this = this;
+        // let startDate = new Date();
+        this._debugSubHits += 1;
+        if (!this._debugSubCollections.some(function (a) { return a.publication === publication; })) {
+            this._debugSubCollections.push({
+                publication: publication,
+                hits: 1
+            });
+        }
+        else {
+            this._debugSubCollections.filter(function (a) { return a.publication === publication; })[0].hits += 1;
+        }
+        var pub = this._publications[publication];
+        if (!pub) {
+            console.error(new Date(), 'No Publication: ' + publication);
+            return;
+        }
+        else {
+            if (subscriptionData.length > 1 || subscriptionData[0]) {
+                if (!pub.check) {
+                    console.error(new Date(), 'No Check Function For Pub ' + publication);
+                    return;
+                }
+                else if (!pub.check._schema) {
+                    console.error(new Date(), 'No Check Schema For Pub ' + publication);
+                    return;
+                }
+                else {
+                    var valObj = {};
+                    var valKeys = Object.keys(pub.check._schema);
+                    var rootKeys = valKeys.filter(function (a) { return !a.includes('.'); });
+                    for (var i = 0; i < subscriptionData.length; i++) {
+                        valObj[rootKeys[i]] = subscriptionData[i];
+                    }
+                    try {
+                        pub.check.validate(valObj);
+                    }
+                    catch (errors) {
+                        if (errors) {
+                            console.error(new Date(), 'Error in Pub Check (' + publication + ')', errors);
+                            return;
+                        }
+                    }
+                }
+            }
+            if (messageRoute !== 'Bypass') {
+                var urlData = messageRoute.split('/');
+                var urlModule_1 = '';
+                var urlNext = urlData[0];
+                if (urlData[0] === '') {
+                    urlModule_1 = '/';
+                    urlNext = urlData[1];
+                }
+                urlModule_1 += urlNext;
+                if (urlData.length > 1) {
+                    urlModule_1 += '/';
+                }
+                var otherRouteSubs = this._subscriptions.filter(function (a) { return a.clients.some(function (b) { return b.id_socket === ws['id_socket'] && b.messageRoute !== 'Bypass' && b.messageRoute !== '/' && b.messageRoute !== messageRoute && !b.messageRoute.startsWith(urlModule_1); }); });
+                if (otherRouteSubs.length) {
+                    this._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Detected Undestroyed Subscription - ' + this.serverConfig['CLIENT_NAME'], 'USER: ' + ws['user'] + ' (Socket: ' + ws['id_socket'] + ') ' + ' is on route: ' + messageRoute + ' but has the following subscriptions on other routes:' + JSON.stringify(otherRouteSubs, null, 2));
+                    otherRouteSubs.forEach(function (otherSub) {
+                        otherSub.clients.filter(function (a) { return a.id_socket === ws['id_socket']; }).forEach(function (client) {
+                            _this.unsubscribe(client.messageRoute, new Date(), ws, client.messageId, otherSub.publication, otherSub.subscriptionData);
+                        });
+                    });
+                }
+            }
+            var sub_1 = this._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_1) {
+                if (!sub_1.clients.some(function (a) { return a.id_socket === ws['id_socket'] && a.messageId === messageId; })) {
+                    sub_1.clients.push({
+                        id_user: ws['id_user'],
+                        messageId: messageId,
+                        id_socket: ws['id_socket'],
+                        messageRoute: messageRoute
+                    });
+                }
+            }
+            // If sub not found, create new sub
+            else {
+                this._subscriptions.push({
+                    publication: publication,
+                    subscriptionData: subscriptionData,
+                    collections: this.getPublicationCollections(publication),
+                    clients: [{
+                            id_user: ws['id_user'],
+                            messageId: messageId,
+                            id_socket: ws['id_socket'],
+                            messageRoute: messageRoute
+                        }],
+                    cacheId: 0
+                });
+            }
+            if (!sub_1) {
+                sub_1 = this._subscriptions.filter(function (a) { return a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData); })[0];
+            }
+            if (!sub_1.cacheId && !this._mongoQueue.some(function (a) { return a.subscription.publication === sub_1.publication && JSON.stringify(a.subscription.subscriptionData) === JSON.stringify(sub_1.subscriptionData); })) {
+                this.addToQueue({
+                    _id: 0,
+                    type: 'newSub',
+                    collection: '',
+                    subscription: sub_1,
+                    running: false,
+                    run_again: false
+                });
+                // let endDate = new Date();
+                // this.currentPerfomanceMonitor.push({
+                // 	_id: this.idPerformance++,
+                // 	function: 'subscribe',
+                // 	publication: publication,
+                // // 	subscriptionData: subscriptionData,
+                // 	subscriptionData: [],
+                // 	date_start: startDate,
+                // 	date_end: endDate,
+                // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                // 	result: 'Add to Queue'
+                // });
+            }
+            else if (sub_1.cacheId) {
+                this.sendDataToOne(ws, messageId, sub_1, 'newSub', publication);
+                // let endDate = new Date();
+                // this.currentPerfomanceMonitor.push({
+                // 	_id: this.idPerformance++,
+                // 	function: 'subscribe',
+                // 	publication: publication,
+                // // 	subscriptionData: subscriptionData,
+                // 	subscriptionData: [],
+                // 	date_start: startDate,
+                // 	date_end: endDate,
+                // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                // 	result: 'Send Pub Data Once'
+                // });
+            }
+        }
+    };
+    SubscriptionManager.prototype.createLoggedInUser = function (id_ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                        var ws, user;
+                        return __generator(this, function (_a) {
+                            ws = this._mainServer.getWS(id_ws);
+                            if (ws) {
+                                user = {
+                                    _id: (0, 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(user);
+                                logged_in_users_collection_1.LoggedInUsers.insertOne(user);
+                                resolve(user);
+                            }
+                            else {
+                                resolve(null);
+                            }
+                            return [2 /*return*/];
+                        });
+                    }); })];
+            });
+        });
+    };
+    // Unsubscribe from publication 
+    SubscriptionManager.prototype.unsubscribe = function (messageRoute, messageDate, ws, messageId, publication, subscriptionData) {
+        this._debugUnSubHits += 1;
+        // let startDate = new Date();
+        // console.log('Before');
+        // console.dir(this._subscriptions.map(a => a.publication));
+        if (!this._publications[publication]) {
+            console.log('No Publication: ' + publication);
+            return;
+        }
+        else {
+            var sub = this._subscriptions.filter(function (a) { return a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData); })[0];
+            if (sub) {
+                for (var 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 endDate = new Date();
+        // this.currentPerfomanceMonitor.push({
+        // 	_id: this.idPerformance++,
+        // 	function: 'unsubscribe',
+        // 	publication: publication,
+        // // 	subscriptionData: subscriptionData,
+        // 	subscriptionData: [],
+        // 	date_start: startDate,
+        // 	date_end: endDate,
+        // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+        // 	result: 'Done'
+        // });
+    };
+    // Unsubscribe from publication
+    SubscriptionManager.prototype.unsubscribeAll = function (ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var loggedInUser, userSubs, i, sub, j;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._debugUnSubAllHits += 1;
+                        if (!ws) return [3 /*break*/, 2];
+                        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 = this._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.close();
+                        process.nextTick(function () {
+                            if ([ws.OPEN, ws.CLOSING].includes(ws.readyState)) {
+                                // Socket still hangs, hard close
+                                ws.terminate();
+                            }
+                        });
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SubscriptionManager.prototype.getActiveSubscriptions = function () {
+        return this._subscriptions;
+    };
+    // Get publication collection
+    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)
+    SubscriptionManager.prototype.tailOpLog = function (resumeToken) {
+        var _this = this;
+        if (!this._oplog || this._oplog.closed) {
+            this._oplogRetryCount += 1;
+            if (this._oplogRetryCount > 10) {
+                console.error('****************** TAIL OPLOG ERROR, RETRYING A BUNCH OF TIMES, KILLING PROCESS **************************');
+                process.exit(1);
+            }
+            var lastResumeToken_1;
+            if (resumeToken) {
+                lastResumeToken_1 = resumeToken;
+                try {
+                    this._oplog = index_1.ResolveIOServer.getMainDB().watch([], { resumeAfter: resumeToken });
+                }
+                catch (errOp) {
+                    if (this._oplog && !this._oplog.closed) {
+                        this._oplog.close();
+                    }
+                    else {
+                        this._oplog = index_1.ResolveIOServer.getMainDB().watch();
+                    }
+                }
+            }
+            else {
+                this._oplog = index_1.ResolveIOServer.getMainDB().watch();
+            }
+            console.log(new Date(), 'oplog started');
+            this._oplog.on('change', function (doc) {
+                // let startDate = new Date();
+                if (doc.ns) {
+                    var collection = doc.ns.coll;
+                    if (!_this._debugOplogCollections.some(function (a) { return a.collection === doc.ns.coll && a.type === doc.operationType; })) {
+                        _this._debugOplogCollections.push({
+                            collection: doc.ns.coll,
+                            type: doc.operationType,
+                            hits: 1
+                        });
+                    }
+                    else {
+                        _this._debugOplogCollections.filter(function (a) { return a.collection === doc.ns.coll && a.type === doc.operationType; })[0].hits += 1;
+                    }
+                    // console.log(new Date(), 'Op log doc', doc.operationType, collection);
+                    if (collection && !collection.endsWith('.versions') && !collection.startsWith('monitor-') && collection !== 'logs' && collection !== 'log-method-latencies' && collection !== 'log-subscriptions') {
+                        _this._debugOplogHits += 1;
+                        if (doc.operationType === 'insert') {
+                            if (collection === 'support-tickets') {
+                                if (_this.serverConfig['ROOT_URL'] === 'https://resolveio.com') {
+                                    _this._mainServer.getMethodManager().callMethodInternal.call(_this._mainServer.getMethodManager(), 'sendSupportTicketEmail', doc.documentKey['_id']);
+                                    _this.invalidatePubsCache(collection, 'insert');
+                                }
+                            }
+                            if (collection !== 'method-responses') {
+                                _this.invalidatePubsCache(collection, 'insert');
+                            }
+                            // let endDate = new Date();
+                            // this.currentPerfomanceMonitor.push({
+                            // 	_id: this.idPerformance++,
+                            // 	function: 'oplog',
+                            // 	publication: collection,
+                            // 	subscriptionData: [],
+                            // 	date_start: startDate,
+                            // 	date_end: endDate,
+                            // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                            // 	result: 'Insert'
+                            // });
+                        }
+                        else if (doc.operationType === 'update' || doc.operationType === 'replace') {
+                            if (collection !== 'method-responses') {
+                                _this.invalidatePubsCache(collection, 'update');
+                            }
+                            // let endDate = new Date();
+                            // this.currentPerfomanceMonitor.push({
+                            // 	_id: this.idPerformance++,
+                            // 	function: 'oplog',
+                            // 	publication: collection,
+                            // 	subscriptionData: [],
+                            // 	date_start: startDate,
+                            // 	date_end: endDate,
+                            // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                            // 	result: 'Update'
+                            // });
+                        }
+                        else if (doc.operationType === 'delete') {
+                            if (collection !== 'method-responses') {
+                                _this.invalidatePubsCache(collection, 'delete');
+                            }
+                            // let endDate = new Date();
+                            // this.currentPerfomanceMonitor.push({
+                            // 	_id: this.idPerformance++,
+                            // 	function: 'oplog',
+                            // 	publication: collection,
+                            // 	subscriptionData: [],
+                            // 	date_start: startDate,
+                            // 	date_end: endDate,
+                            // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                            // 	result: 'Delete'
+                            // });
+                        }
+                    }
+                    if (collection === 'flags') {
+                        flag_collection_1.Flags.findOne({ type: 'Enable Debug' }).then(function (flag) {
+                            if (flag && flag.value) {
+                                _this._enableDebug = true;
+                            }
+                            else {
+                                _this._enableDebug = false;
+                            }
+                        });
+                    }
+                    lastResumeToken_1 = doc._id;
+                }
+            });
+            this._oplog.on('error', function (error) {
+                console.log(new Date(), 'oplog error', error);
+                _this._oplog.close();
+            });
+            this._oplog.on('end', function () {
+                console.log(new Date(), 'oplog end');
+                _this._oplog.close();
+            });
+            this._oplog.on('close', function () {
+                _this._oplog = null;
+                console.log(new Date(), 'oplog close');
+                _this.tailOpLog(lastResumeToken_1);
+            });
+        }
+        else {
+            this._oplog.close();
+        }
+    };
+    // Fetch pub once, send to all clients linked to this pub
+    SubscriptionManager.prototype.sendDataToOne = function (ws, messageId, subscription, type, collection) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var cacheData, serverRes, monitor_1;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                // let startDate = new Date();
+                if (!this._publications[subscription.publication].user_specific) { // Same pub for all users
+                    if (subscription.cacheId) {
+                        try {
+                            cacheData = JSON.parse(this._nodeCache.get(subscription.cacheId), common_1.dateReviver);
+                            serverRes = {
+                                messageId: messageId,
+                                hasError: false,
+                                data: cacheData
+                            };
+                            this.sendWS(ws, serverRes);
+                        }
+                        catch (err) {
+                            this._nodeCache.del(subscription.cacheId);
+                            subscription.cacheId = 0;
+                            this.addToQueue({
+                                _id: 0,
+                                type: 'newSub',
+                                collection: '',
+                                subscription: subscription,
+                                running: false,
+                                run_again: false
+                            });
+                        }
+                        // let endDate = new Date();
+                        // this.currentPerfomanceMonitor.push({
+                        // 	_id: this.idPerformance++,
+                        // 	function: 'sendDataToOne',
+                        // 	publication: subscription.publication,
+                        // // 	subscriptionData: subscription.subscriptionData,
+                        // 	subscriptionData: [],
+                        // 	date_start: startDate,
+                        // 	date_end: endDate,
+                        // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                        // 	result: 'Send cache'
+                        // });
+                        resolve(true);
+                    }
+                    else {
+                        this._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], 'Error Detected During sendDataToOne - No Cache! - ' + subscription.publication + '\n\nData \n' + JSON.stringify(subscription.subscriptionData, null, 2));
+                        resolve(false);
+                    }
+                }
+                else { // Pub is different for each user (Look at users publication) [MUCH SLOWER, RE-RUNS FOR EACH USER]
+                    monitor_1 = this._monitorManagerFunction.startMonitorFunction('User Specific Publication', subscription.publication, '', '', subscription.subscriptionData);
+                    (_a = this._publications[subscription.publication].function).call.apply(_a, __spreadArray([Object.assign({}, this, SubscriptionManager.prototype), ws['id_user']], subscription.subscriptionData, false)).then(function (res) {
+                        _this._monitorManagerFunction.finishMonitorFunction(monitor_1);
+                        var serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: res
+                        };
+                        // console.log('Send Pub Data Once 2', new Date(), 'Success', subscription);
+                        _this.sendWS(ws, serverRes);
+                        // let endDate = new Date();
+                        // this.currentPerfomanceMonitor.push({
+                        // 	_id: this.idPerformance++,
+                        // 	function: 'sendDataToOne',
+                        // 	publication: subscription.publication,
+                        // // 	subscriptionData: subscription.subscriptionData,
+                        // 	subscriptionData: [],
+                        // 	date_start: startDate,
+                        // 	date_end: endDate,
+                        // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                        // 	result: 'Send ws spec data'
+                        // });
+                        resolve(true);
+                    }, function (err) {
+                        _this._monitorManagerFunction.finishMonitorFunction(monitor_1);
+                        var serverRes = {
+                            messageId: messageId,
+                            hasError: true,
+                            data: err
+                        };
+                        // console.log('Send Pub Data Once 2', new Date(), 'Error', subscription);
+                        _this.sendWS(ws, serverRes);
+                        _this._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + _this.serverConfig['CLIENT_NAME'], 'Error Detected During Subscription ' + subscription.publication + ' - (sendDataToOne - WS)\n\nData \n' + JSON.stringify(subscription.subscriptionData, null, 2) + '\n\nErrors\n' + JSON.stringify(err, null, 2));
+                        reject(err);
+                    });
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    // Fetch pub once, send to all clients linked to this pub
+    SubscriptionManager.prototype.sendDataToAll = function (mongoQueue) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var monitor_2;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                // let startDate = new Date();
+                if (!mongoQueue.subscription.clients.length) {
+                    if (mongoQueue.subscription.cacheId) {
+                        this._nodeCache.del(mongoQueue.subscription.cacheId);
+                    }
+                    if (this._subscriptions.findIndex(function (a) { return a.publication === mongoQueue.subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(mongoQueue.subscription.subscriptionData); }) >= 0) {
+                        this._subscriptions.splice(this._subscriptions.findIndex(function (a) { return a.publication === mongoQueue.subscription.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(mongoQueue.subscription.subscriptionData); }), 1);
+                    }
+                    resolve(false);
+                }
+                else {
+                    if (mongoQueue.subscription.publication !== 'superadminAPM' && mongoQueue.subscription.publication !== 'loggedInUsers') {
+                        this._mainServer.getMethodManager().callMethodInternal.call(this._mainServer.getMethodManager(), 'insertSubscriptionLog', mongoQueue.type, mongoQueue.subscription.publication, mongoQueue.collection, JSON.stringify(mongoQueue.subscription.subscriptionData));
+                    }
+                    monitor_2 = this._monitorManagerFunction.startMonitorFunction('Publication', mongoQueue.subscription.publication, '', '', mongoQueue.subscription.subscriptionData);
+                    (_a = this._publications[mongoQueue.subscription.publication].function).call.apply(_a, __spreadArray([Object.assign({}, this, SubscriptionManager.prototype)], mongoQueue.subscription.subscriptionData, false)).then(function (res) {
+                        _this._monitorManagerFunction.finishMonitorFunction(monitor_2);
+                        if (!mongoQueue.subscription.clients.length) {
+                            var nodeCacheSize = _this._nodeCache.getStats().vsize;
+                            if (nodeCacheSize > _this._heapLimit) {
+                                var deleteCount = 0;
+                                var subArr = _this._subscriptions.filter(function (a) { return a.cacheId && !a.clients.length; });
+                                for (var zz = 0; zz < subArr.length; zz++) {
+                                    _this._debugRemoveCacheHits += 1;
+                                    _this._nodeCache.del(subArr[zz].cacheId);
+                                    subArr[zz].cacheId = 0;
+                                    deleteCount += 1;
+                                    nodeCacheSize = _this._nodeCache.getStats().vsize;
+                                    if (nodeCacheSize < _this._heapLimit * 0.75) {
+                                        break;
+                                    }
+                                }
+                                console.log('Sub Cache: ' + 'Too Big - ' + mongoQueue.subscription.publication + ' - Deleted: ' + deleteCount + ' - ' + nodeCacheSize);
+                            }
+                            if (mongoQueue.subscription.cacheId) {
+                                _this._nodeCache.del(mongoQueue.subscription.cacheId);
+                            }
+                            var cacheId = _this._cacheId;
+                            _this._cacheId += 1;
+                            _this._nodeCache.set(cacheId, JSON.stringify(res));
+                            mongoQueue.subscription.cacheId = cacheId;
+                            // let endDate = new Date();
+                            // this.currentPerfomanceMonitor.push({
+                            // 	_id: this.idPerformance++,
+                            // 	function: 'sendPubData',
+                            // 	publication: subscription.publication,
+                            // // 	subscriptionData: subscription.subscriptionData,
+                            // 	subscriptionData: [],
+                            // 	date_start: startDate,
+                            // 	date_end: endDate,
+                            // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                            // 	result: 'No clients'
+                            // });
+                            resolve(false);
+                        }
+                        else {
+                            if (!mongoQueue.subscription.cacheId || _this._nodeCache.get(mongoQueue.subscription.cacheId) !== JSON.stringify(res)) {
+                                mongoQueue.subscription.clients.forEach(function (client) {
+                                    var ws = _this._mainServer.getWS(client.id_socket);
+                                    if (ws) {
+                                        var serverRes = {
+                                            messageId: client.messageId,
+                                            hasError: false,
+                                            data: res
+                                        };
+                                        _this.sendWS(ws, serverRes);
+                                    }
+                                });
+                                var nodeCacheSize = _this._nodeCache.getStats().vsize;
+                                if (nodeCacheSize > _this._heapLimit) {
+                                    var deleteCount = 0;
+                                    var subArr = _this._subscriptions.filter(function (a) { return a.cacheId && !a.clients.length; });
+                                    for (var zz = 0; zz < subArr.length; zz++) {
+                                        _this._nodeCache.del(subArr[zz].cacheId);
+                                        subArr[zz].cacheId = 0;
+                                        deleteCount += 1;
+                                        nodeCacheSize = _this._nodeCache.getStats().vsize;
+                                        if (nodeCacheSize < _this._heapLimit * 0.75) {
+                                            break;
+                                        }
+                                    }
+                                    console.log('Sub Cache: ' + 'Too Big - ' + mongoQueue.subscription.publication + ' - Deleted: ' + deleteCount + ' - ' + nodeCacheSize);
+                                }
+                                if (mongoQueue.subscription.cacheId) {
+                                    _this._nodeCache.del(mongoQueue.subscription.cacheId);
+                                }
+                                var cacheId = _this._cacheId;
+                                _this._cacheId += 1;
+                                _this._nodeCache.set(cacheId, JSON.stringify(res));
+                                mongoQueue.subscription.cacheId = cacheId;
+                                // let endDate = new Date();
+                                // this.currentPerfomanceMonitor.push({
+                                // 	_id: this.idPerformance++,
+                                // 	function: 'sendPubData',
+                                // 	publication: subscription.publication,
+                                // // 	subscriptionData: subscription.subscriptionData,
+                                // 	subscriptionData: [],
+                                // 	date_start: startDate,
+                                // 	date_end: endDate,
+                                // 	duration: moment(endDate).diff(moment(startDate), 'milliseconds', false),
+                                // 	result: 'Same data'
+                                // });
+                            }
+                            resolve(true);
+                        }
+                    }, function (err) {
+                        _this._monitorManagerFunction.finishMonitorFunction(monitor_2);
+                        _this._mainServer.getMethodManager().sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + _this.serverConfig['CLIENT_NAME'], 'Error Detected During Subscription ' + mongoQueue.subscription.publication + ' - (sendPubData)\n\nData \n' + JSON.stringify(mongoQueue.subscription.subscriptionData, null, 2) + '\n\nErrors\n' + JSON.stringify(err, null, 2));
+                        mongoQueue.subscription.clients.forEach(function (client) {
+                            var ws = _this._mainServer.getWS(client.id_socket);
+                            if (ws) {
+                                if (ws['id_socket'] === client.id_socket) {
+                                    var serverRes = {
+                                        messageId: client.messageId,
+                                        hasError: true,
+                                        data: err
+                                    };
+                                    _this.sendWS(ws, serverRes);
+                                }
+                            }
+                        });
+                        reject(err);
+                    });
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    SubscriptionManager.prototype.sendWS = function (ws, data) {
+        this._sendQueue.splice(0, 0, {
+            id_ws: ws['id_socket'],
+            data: data
+        });
+    };
+    SubscriptionManager.prototype.getEnableDebug = function () {
+        return this._enableDebug;
+    };
+    return SubscriptionManager;
+}());
+exports.SubscriptionManager = SubscriptionManager;
+
+//# sourceMappingURL=subscription.manager.js.map