@resolveio/server-lib 3.2.11 → 3.2.12

package/managers/subscription.manager.js

@@ -0,0 +1,808 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var MongoOplog = require("mongo-oplog");
+var logs_1 = require("../publications/logs");
+var app_status_1 = require("../publications/app-status");
+var app_version_1 = require("../publications/app-version");
+var mongoose_1 = require("mongoose");
+var files_1 = require("../publications/files");
+var super_admin_1 = require("../publications/super-admin");
+var active_subscription_collection_1 = require("../collections/active-subscription.collection");
+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 support_tickets_1 = require("../publications/support-tickets");
+var index_1 = require("../index");
+var notifications_1 = require("../publications/notifications");
+var common_1 = require("../util/common");
+var billing_logged_in_users_collection_1 = require("../collections/billing-logged-in-users.collection");
+var moment = require("moment");
+var billing_logged_in_users_1 = require("../publications/billing-logged-in-users");
+var SubscriptionManager = /** @class */ (function () {
+    function SubscriptionManager(mainServer, wss, serverConfig) {
+        var _this = this;
+        this._publications = {};
+        this._subscriptions = [];
+        this._oplogQueue = [];
+        this._sendQueue = [];
+        this._runningQueue = false;
+        this._mainServer = mainServer;
+        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);
+        support_tickets_1.loadSupportTicketPublications(this);
+        billing_logged_in_users_1.loadBillingLoggedInUsersPublications(this);
+        notifications_1.loadNotificationPublications(this);
+        this.tailOpLog();
+        this.runOpLogQueue();
+        if (index_1.ResolveIOServer.getSupportDB()) {
+            this.tailOpLogSupport();
+        }
+        setInterval(function () {
+            if (!_this._runningQueue) {
+                if (_this._sendQueue.length) {
+                    _this._runningQueue = true;
+                    var _loop_1 = function (i) {
+                        var ws = _this._mainServer.getWS(_this._sendQueue[i].id_ws);
+                        if (ws && ws.readyState === ws.OPEN) {
+                            if (ws.bufferedAmount < 20480) {
+                                var sendItem = _this._sendQueue.pop();
+                                ws.send(JSON.stringify(sendItem.data), function (error) {
+                                    if (error) {
+                                        console.log('Error on WS: ', error);
+                                        _this._mainServer.unsubscribeWS(ws);
+                                    }
+                                });
+                            }
+                        }
+                        else {
+                            _this._sendQueue.splice(i, 1);
+                        }
+                    };
+                    for (var i = _this._sendQueue.length - 1; i >= 0; i--) {
+                        _loop_1(i);
+                    }
+                    _this._runningQueue = false;
+                }
+            }
+        }, 25);
+    }
+    // Add all files to publications private object
+    SubscriptionManager.prototype.publications = function (method) {
+        this._publications = Object.assign(this._publications, method);
+    };
+    SubscriptionManager.prototype.loggedInLatency = function (ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                logged_in_users_collection_1.LoggedInUsers.findOneAndUpdate({ id_ws: ws['id_socket'] }, { $set: { latency: ws['latency'] } }).exec(function (err, res) {
+                    if (err) {
+                        _this.unsubscribeAll(ws);
+                    }
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    // Subscribe to publication
+    SubscriptionManager.prototype.subscribe = function (ws, messageId, publication) {
+        var subscriptionData = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+            subscriptionData[_i - 3] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var that, pub, valObj, valKeys, rootKeys, i, sub, _a, newActiveSub, begDate, endDate, billUser;
+            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];
+                        }
+                        // 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);
+                        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:
+                        newActiveSub = new active_subscription_collection_1.ActiveSubscriptions({
+                            date: new Date(),
+                            publication: publication,
+                            subData: JSON.stringify(subscriptionData),
+                            collections: pub.collections,
+                            clients: sub.clients
+                        });
+                        active_subscription_collection_1.ActiveSubscriptions.findOneAndUpdate({
+                            $and: [
+                                { publication: publication },
+                                { subData: JSON.stringify(subscriptionData) }
+                            ]
+                        }, { $setOnInsert: { _id: mongoose_1.Types.ObjectId().toHexString(), __v: 0 }, $set: newActiveSub }, { upsert: true }).exec();
+                        _c.label = 4;
+                    case 4:
+                        if (!(publication === 'appversion')) return [3 /*break*/, 6];
+                        logged_in_users_collection_1.LoggedInUsers.create({
+                            _id: mongoose_1.Types.ObjectId().toHexString(),
+                            __v: 0,
+                            date: new Date(),
+                            id_user: ws['id_user'],
+                            user: ws['user'],
+                            id_ws: ws['id_socket']
+                        });
+                        if (!(ws['user'] !== 'Admin' && index_1.ResolveIOServer.getSupportDB())) return [3 /*break*/, 6];
+                        begDate = moment().startOf('month');
+                        endDate = moment().endOf('month');
+                        return [4 /*yield*/, billing_logged_in_users_collection_1.BillingLoggedInUsers.findOne({
+                                $and: [
+                                    {
+                                        client: index_1.ResolveIOServer.getClientName()
+                                    },
+                                    {
+                                        id_user: ws['id_user']
+                                    },
+                                    {
+                                        date: { $gte: begDate }
+                                    },
+                                    {
+                                        date: { $lte: endDate }
+                                    }
+                                ]
+                            })];
+                    case 5:
+                        billUser = _c.sent();
+                        if (!billUser) {
+                            billing_logged_in_users_collection_1.BillingLoggedInUsers.create({
+                                _id: mongoose_1.Types.ObjectId().toHexString(),
+                                __v: 0,
+                                id_user: ws['id_user'],
+                                user: ws['user'],
+                                date: new Date(),
+                                client: index_1.ResolveIOServer.getClientName()
+                            });
+                        }
+                        _c.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Unsubscribe from publication 
+    SubscriptionManager.prototype.unsubscribe = function (ws, messageId, publication) {
+        var subscriptionData = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+            subscriptionData[_i - 3] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var that, sub, i, activeSub;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        that = this;
+                        if (!!that._publications[publication]) return [3 /*break*/, 1];
+                        console.log('No Publication: ' + publication);
+                        return [2 /*return*/];
+                    case 1:
+                        sub = that._subscriptions.filter(function (a) { return a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData); })[0];
+                        if (!sub) return [3 /*break*/, 5];
+                        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);
+                            }
+                        }
+                        if (!!sub.clients.length) return [3 /*break*/, 2];
+                        that._subscriptions.splice(that._subscriptions.findIndex(function (a) { return a.publication === publication && JSON.stringify(a.subscriptionData) === JSON.stringify(subscriptionData); }), 1);
+                        active_subscription_collection_1.ActiveSubscriptions.deleteOne({
+                            $and: [
+                                { publication: publication },
+                                { subData: JSON.stringify(subscriptionData) }
+                            ]
+                        }).exec();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, active_subscription_collection_1.ActiveSubscriptions.findOne({
+                            $and: [
+                                { publication: publication },
+                                { subData: JSON.stringify(subscriptionData) }
+                            ]
+                        })];
+                    case 3:
+                        activeSub = _a.sent();
+                        if (activeSub) {
+                            active_subscription_collection_1.ActiveSubscriptions.updateOne({ _id: activeSub._id }, { $set: { clients: sub.clients } }).exec();
+                        }
+                        _a.label = 4;
+                    case 4: return [3 /*break*/, 6];
+                    case 5:
+                        console.log('Did not sub on unsubscribe');
+                        _a.label = 6;
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Unsubscribe from publication
+    SubscriptionManager.prototype.unsubscribeAll = function (ws) {
+        return __awaiter(this, void 0, void 0, function () {
+            var that, loggedInUser, userSubs, _loop_2, i, activeSubs;
+            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) {
+                            logged_in_users_collection_1.LoggedInUsers.deleteOne({ _id: loggedInUser._id }).exec();
+                        }
+                        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']; }); });
+                        _loop_2 = function (i) {
+                            var sub = userSubs[i];
+                            for (var j = sub.clients.length - 1; j >= 0; j--) {
+                                if (sub.clients[j].id_socket === ws['id_socket']) {
+                                    sub.clients.splice(j, 1);
+                                }
+                            }
+                            if (!sub.clients.length) {
+                                that._subscriptions.splice(that._subscriptions.findIndex(function (a) { return a.publication === sub.publication && JSON.stringify(a.subscriptionData) === JSON.stringify(sub.subscriptionData); }), 1);
+                            }
+                        };
+                        for (i = userSubs.length - 1; i >= 0; i--) {
+                            _loop_2(i);
+                        }
+                        return [4 /*yield*/, active_subscription_collection_1.ActiveSubscriptions.find({ 'clients.id_socket': ws['id_socket'] })];
+                    case 2:
+                        activeSubs = _a.sent();
+                        activeSubs.forEach(function (sub) {
+                            for (var j = sub.clients.length - 1; j >= 0; j--) {
+                                if (sub.clients[j].id_socket === ws['id_socket']) {
+                                    sub.clients.splice(j, 1);
+                                }
+                            }
+                            if (!sub.clients.length) {
+                                active_subscription_collection_1.ActiveSubscriptions.deleteOne({ _id: sub._id }).exec();
+                            }
+                            else {
+                                for (var j = sub.clients.length - 1; j >= 0; j--) {
+                                    if (sub.clients[j].id_socket === ws['id_socket']) {
+                                        sub.clients.splice(j, 1);
+                                    }
+                                }
+                                active_subscription_collection_1.ActiveSubscriptions.updateOne({ _id: sub._id }, { $set: { clients: sub.clients } }).exec();
+                            }
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // 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 () {
+        var _this = this;
+        var that = this;
+        var oplog = MongoOplog(that.serverConfig['OPLOG_URL']);
+        oplog.tail().then(function () {
+            console.log('tail started');
+        });
+        oplog.on('insert', function (doc) {
+            var nsArray = doc.ns.split('.');
+            var collection = nsArray[1];
+            if (nsArray[2]) {
+                collection += '.' + nsArray[2];
+            }
+            if (collection === 'cron-jobs') {
+                _this._mainServer.getCronManager().checkCronJobsForUpdates();
+            }
+            else if (collection === 'queue-methods') {
+                _this._mainServer.getQueueManager().runMethodQueue();
+            }
+            else if (collection === 'queue-responses') {
+                _this._mainServer.getQueueManager().runMethodResponse();
+            }
+            else if (collection === 'support-tickets') {
+                _this._mainServer.getMethodManager().callMethodInternal('sendSupportTicketEmail', doc.o._id);
+            }
+            _this._oplogQueue.push({
+                type: 'insert',
+                collection: collection,
+                doc: doc.o
+            });
+        });
+        oplog.on('update', function (doc) {
+            var nsArray = doc.ns.split('.');
+            var collection = nsArray[1];
+            if (nsArray[2]) {
+                collection += '.' + nsArray[2];
+            }
+            doc.o['_id'] = doc.o2['_id'];
+            if (collection === 'cron-jobs') {
+                _this._mainServer.getCronManager().checkCronJobsForUpdates();
+            }
+            _this._oplogQueue.push({
+                type: 'update',
+                collection: collection,
+                doc: doc.o
+            });
+        });
+        oplog.on('delete', function (doc) {
+            var nsArray = doc.ns.split('.');
+            var collection = nsArray[1];
+            if (nsArray[2]) {
+                collection += '.' + nsArray[2];
+            }
+            that.resendPubsForDelete(collection);
+            if (collection === 'cron-jobs') {
+                _this._mainServer.getCronManager().checkCronJobsForUpdates();
+            }
+        });
+        oplog.on('error', function (error) {
+            console.log('Error', error);
+        });
+        oplog.on('end', function () {
+            console.log('oplog ended');
+            process.exit();
+        });
+        oplog.stop(function () {
+            console.log('oplog stopped');
+        });
+    };
+    SubscriptionManager.prototype.tailOpLogSupport = function () {
+        var that = this;
+        var oplog = MongoOplog(that.serverConfig['RESOLVEIO_SUPPORT_OPLOG_URL']);
+        oplog.tail().then(function () {
+            console.log('tail started support');
+        });
+        oplog.on('insert', function (doc) {
+            var nsArray = doc.ns.split('.');
+            var collection = nsArray[1];
+            if (nsArray[2]) {
+                collection += '.' + nsArray[2];
+            }
+            if (collection === 'support-tickets') {
+                that.checkSupportPubsForChanges(collection, doc.o);
+            }
+        });
+        oplog.on('update', function (doc) {
+            var nsArray = doc.ns.split('.');
+            var collection = nsArray[1];
+            if (nsArray[2]) {
+                collection += '.' + nsArray[2];
+            }
+            doc.o['_id'] = doc.o2['_id'];
+            if (collection === 'support-tickets') {
+                that.checkSupportPubsForChanges(collection, doc.o);
+            }
+        });
+        oplog.on('delete', function (doc) {
+            var nsArray = doc.ns.split('.');
+            var collection = nsArray[1];
+            if (nsArray[2]) {
+                collection += '.' + nsArray[2];
+            }
+            if (collection === 'support-tickets') {
+                that.resendPubsForDelete(collection);
+            }
+        });
+        oplog.on('error', function (error) {
+            console.log('Error support', error);
+        });
+        oplog.on('end', function () {
+            console.log('oplog ended support');
+            process.exit();
+        });
+        oplog.stop(function () {
+            console.log('oplog stopped support');
+        });
+    };
+    SubscriptionManager.prototype.runOpLogQueue = function () {
+        var _this = this;
+        setInterval(function () {
+            var oplogQueue = common_1.deepCopy(_this._oplogQueue);
+            var uniqueCollectionOplogQueue = oplogQueue.map(function (a) { return a.collection; }).filter(function (elem, index, self) {
+                return index === self.indexOf(elem);
+            });
+            uniqueCollectionOplogQueue.forEach(function (collection) {
+                var oplogQueueFiltered = oplogQueue.filter(function (a) { return a.collection === collection; });
+                if (oplogQueueFiltered.length === 1) {
+                    _this.checkPubsForChanges(oplogQueueFiltered[0].collection, oplogQueueFiltered[0].doc);
+                    _this._oplogQueue.splice(_this._oplogQueue.map(function (a) { return a.collection; }).indexOf(collection), 1);
+                }
+                else {
+                    oplogQueueFiltered.forEach(function (item) {
+                        _this.checkPubsForChanges(item.collection, item.doc, true);
+                    });
+                    _this.checkPubsForChanges(oplogQueueFiltered[oplogQueueFiltered.length - 1].collection, oplogQueueFiltered[oplogQueueFiltered.length - 1].doc, false, true);
+                    for (var i = _this._oplogQueue.length - 1; i >= 0; i--) {
+                        var item = _this._oplogQueue[i];
+                        if (item.collection === collection) {
+                            _this._oplogQueue.splice(i, 1);
+                        }
+                    }
+                }
+            });
+        }, 25);
+    };
+    SubscriptionManager.prototype.resendPubsForDelete = function (collection) {
+        var that = this;
+        that._subscriptions.filter(function (a) { return a.collections.includes(collection); }).forEach(function (sub) {
+            if (that._publications[sub.publication].ws_specific) {
+                sub.clients.forEach(function (client) {
+                    that._wss.clients.forEach(function (ws) {
+                        if (ws['id_socket'] === client.id_socket) {
+                            that.sendPubDataOnce(ws, client.messageId, sub);
+                        }
+                    });
+                });
+            }
+            else {
+                that.sendPubData(sub);
+            }
+        });
+    };
+    // Document: Inserted/Modified/Deleted 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, fetchFunctionOnly, noFetchFunction) {
+        var _this = this;
+        if (fetchFunctionOnly === void 0) { fetchFunctionOnly = false; }
+        if (noFetchFunction === void 0) { noFetchFunction = false; }
+        var that = this;
+        that._subscriptions.filter(function (a) { return a.collections.includes(collection); }).forEach(function (sub) { return __awaiter(_this, void 0, void 0, function () {
+            var schemaErrors, _a, _b;
+            var _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        schemaErrors = null;
+                        try {
+                            index_1.ResolveIOServer.getMainDB().model(collection)['simplschema'].validate(document);
+                        }
+                        catch (errors) {
+                            schemaErrors = errors;
+                        }
+                        if (!schemaErrors) return [3 /*break*/, 2];
+                        return [4 /*yield*/, index_1.ResolveIOServer.getMainDB().model(collection).findById(document['_id'])];
+                    case 1:
+                        document = _e.sent();
+                        _e.label = 2;
+                    case 2:
+                        if (!sub.preSubscriptionData) return [3 /*break*/, 4];
+                        if (!that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) return [3 /*break*/, 4];
+                        that.sendPubData(sub);
+                        _a = sub;
+                        return [4 /*yield*/, (_c = that._publications[sub.publication]).preFunction.apply(_c, sub.subscriptionData)];
+                    case 3:
+                        _a.preSubscriptionData = _e.sent();
+                        return [2 /*return*/];
+                    case 4:
+                        if (!that._publications[sub.publication].preFunction) return [3 /*break*/, 7];
+                        if (!!noFetchFunction) return [3 /*break*/, 6];
+                        _b = sub;
+                        return [4 /*yield*/, that._publications[sub.publication].preFunction(sub.subscriptionData)];
+                    case 5:
+                        _b.preSubscriptionData = _e.sent();
+                        if (that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) {
+                            that.sendPubData(sub);
+                        }
+                        _e.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        if (that._publications[sub.publication].ws_specific) {
+                            sub.clients.forEach(function (client) {
+                                var _a;
+                                if (that._publications[sub.publication].fetchFunction) {
+                                    if (!noFetchFunction) {
+                                        if ((_a = that._publications[sub.publication]).fetchFunction.apply(_a, [document, client.id_user].concat(sub.subscriptionData))) {
+                                            that._wss.clients.forEach(function (ws) {
+                                                if (ws['id_socket'] === client.id_socket) {
+                                                    that.sendPubDataOnce(ws, client.messageId, sub);
+                                                }
+                                            });
+                                        }
+                                    }
+                                }
+                                else if (!fetchFunctionOnly) {
+                                    that._wss.clients.forEach(function (ws) {
+                                        if (ws['id_socket'] === client.id_socket) {
+                                            that.sendPubDataOnce(ws, client.messageId, sub);
+                                        }
+                                    });
+                                }
+                            });
+                        }
+                        else {
+                            if (that._publications[sub.publication].fetchFunction) {
+                                if (!noFetchFunction) {
+                                    if ((_d = that._publications[sub.publication]).fetchFunction.apply(_d, [document].concat(sub.subscriptionData))) {
+                                        that.sendPubData(sub);
+                                    }
+                                }
+                            }
+                            else if (!fetchFunctionOnly) {
+                                that.sendPubData(sub);
+                            }
+                        }
+                        _e.label = 8;
+                    case 8: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    SubscriptionManager.prototype.checkSupportPubsForChanges = function (collection, document) {
+        var _this = this;
+        var that = this;
+        that._subscriptions.filter(function (a) { return a.collections.includes(collection); }).forEach(function (sub) { return __awaiter(_this, void 0, void 0, function () {
+            var schemaErrors, _a, _b;
+            var _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        schemaErrors = null;
+                        try {
+                            index_1.ResolveIOServer.getSupportDB().model(collection)['simplschema'].validate(document);
+                        }
+                        catch (errors) {
+                            schemaErrors = errors;
+                        }
+                        if (!schemaErrors) return [3 /*break*/, 2];
+                        return [4 /*yield*/, index_1.ResolveIOServer.getSupportDB().model(collection).findById(document['_id'])];
+                    case 1:
+                        document = _f.sent();
+                        _f.label = 2;
+                    case 2:
+                        if (!sub.preSubscriptionData) return [3 /*break*/, 4];
+                        if (!that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) return [3 /*break*/, 4];
+                        that.sendPubData(sub);
+                        _a = sub;
+                        return [4 /*yield*/, (_c = that._publications[sub.publication]).preFunction.apply(_c, sub.subscriptionData)];
+                    case 3:
+                        _a.preSubscriptionData = _f.sent();
+                        return [2 /*return*/];
+                    case 4:
+                        if (!that._publications[sub.publication].preFunction) return [3 /*break*/, 6];
+                        _b = sub;
+                        return [4 /*yield*/, (_d = that._publications[sub.publication]).preFunction.apply(_d, sub.subscriptionData)];
+                    case 5:
+                        _b.preSubscriptionData = _f.sent();
+                        if (that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) {
+                            that.sendPubData(sub);
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        if (that._publications[sub.publication].ws_specific) {
+                            sub.clients.forEach(function (client) {
+                                var _a;
+                                if (that._publications[sub.publication].fetchFunction) {
+                                    if ((_a = that._publications[sub.publication]).fetchFunction.apply(_a, [document, client.id_user].concat(sub.subscriptionData))) {
+                                        that._wss.clients.forEach(function (ws) {
+                                            if (ws['id_socket'] === client.id_socket) {
+                                                that.sendPubDataOnce(ws, client.messageId, sub);
+                                            }
+                                        });
+                                    }
+                                }
+                                else {
+                                    that._wss.clients.forEach(function (ws) {
+                                        if (ws['id_socket'] === client.id_socket) {
+                                            that.sendPubDataOnce(ws, client.messageId, sub);
+                                        }
+                                    });
+                                }
+                            });
+                        }
+                        else {
+                            if (that._publications[sub.publication].fetchFunction) {
+                                if ((_e = that._publications[sub.publication]).fetchFunction.apply(_e, [document].concat(sub.subscriptionData))) {
+                                    that.sendPubData(sub);
+                                }
+                            }
+                            else {
+                                that.sendPubData(sub);
+                            }
+                        }
+                        _f.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    // Fetch pub once, send to all clients linked to this pub
+    SubscriptionManager.prototype.sendPubDataOnce = function (ws, messageId, subscription) {
+        return __awaiter(this, void 0, void 0, function () {
+            var that;
+            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
+                    (_a = that._publications[subscription.publication].function).call.apply(_a, [Object.assign({}, that, SubscriptionManager.prototype)].concat(subscription.subscriptionData)).then(function (res) {
+                        var serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: res
+                        };
+                        _this.sendWS(ws, serverRes);
+                    }, function (err) {
+                        var serverRes = {
+                            messageId: messageId,
+                            hasError: true,
+                            data: err
+                        };
+                        _this.sendWS(ws, serverRes);
+                    });
+                }
+                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, [Object.assign({}, that, SubscriptionManager.prototype), ws['id_user']].concat(subscription.subscriptionData)).then(function (res) {
+                        var serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: res
+                        };
+                        _this.sendWS(ws, serverRes);
+                    }, function (err) {
+                        var serverRes = {
+                            messageId: messageId,
+                            hasError: true,
+                            data: err
+                        };
+                        _this.sendWS(ws, serverRes);
+                    });
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    // Fetch pub once, send to all clients linked to this pub
+    SubscriptionManager.prototype.sendPubData = function (subscription) {
+        return __awaiter(this, void 0, void 0, function () {
+            var that;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                that = this;
+                (_a = that._publications[subscription.publication].function).call.apply(_a, [Object.assign({}, that, SubscriptionManager.prototype)].concat(subscription.subscriptionData)).then(function (res) {
+                    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);
+                            }
+                        });
+                    });
+                }, 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);
+                            }
+                        });
+                    });
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    SubscriptionManager.prototype.sendWS = function (ws, data) {
+        this._sendQueue.splice(0, 0, {
+            id_ws: ws['id_socket'],
+            data: data
+        });
+    };
+    return SubscriptionManager;
+}());
+exports.SubscriptionManager = SubscriptionManager;