@resolveio/server-lib 9.0.34 → 9.0.35

package/server-app.js

@@ -1,31 +1,77 @@
-import { createServer } from 'http';
-import * as express from 'express';
-import * as bodyParser from 'body-parser';
-import * as xmlParser from 'express-xml-bodyparser';
-import * as passport from 'passport';
-import * as passportlocal from 'passport-local';
-import * as WebSocket from 'ws';
-import * as jwt from 'jsonwebtoken';
-import * as uuid from 'uuid/v4';
-import * as SegfaultHandler from 'segfault-handler';
-import * as moment from 'moment';
-import { dateReviver, getBinarySize, deepCopy } from './util/common';
-import { objectIdHexString } from './managers/mongo.manager';
-import { CronManager } from './managers/cron.manager';
-import { MethodManager } from './managers/method.manager';
-import { SubscriptionManager } from './managers/subscription.manager';
-import { QueueMethodManager } from './managers/queue-method.manager';
-import { MonitorManager } from './managers/monitor.manager';
-import { MethodCalls } from './collections/method-call.collection';
-import { MethodResponses } from './collections/method-response.collection';
-import { Logs } from './collections/log.collection';
-import { LogMethodLatencies } from './collections/log-method-latency.collection';
-import { Users } from './collections/user.collection';
-import { setupHomeRoutes } from './http/home';
-import { setupAuthRoutes } from './http/auth';
-import { setupHealthRoutes } from './http/health';
-export default class ResolveIOMainServer {
-    constructor(mainServer, monitorAgent, serverConfig, clientRoutes, clientDir, sesMail, standardProgram) {
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var http_1 = require("http");
+var express = require("express");
+var bodyParser = require("body-parser");
+var xmlParser = require("express-xml-bodyparser");
+var passport = require("passport");
+var passportlocal = require("passport-local");
+var WebSocket = require("ws");
+var jwt = require("jsonwebtoken");
+var uuid = require("uuid/v4");
+var SegfaultHandler = require("segfault-handler");
+var moment = require("moment");
+var common_1 = require("./util/common");
+var mongo_manager_1 = require("./managers/mongo.manager");
+var cron_manager_1 = require("./managers/cron.manager");
+var method_manager_1 = require("./managers/method.manager");
+var subscription_manager_1 = require("./managers/subscription.manager");
+var queue_method_manager_1 = require("./managers/queue-method.manager");
+var monitor_manager_1 = require("./managers/monitor.manager");
+var method_call_collection_1 = require("./collections/method-call.collection");
+var method_response_collection_1 = require("./collections/method-response.collection");
+var log_collection_1 = require("./collections/log.collection");
+var log_method_latency_collection_1 = require("./collections/log-method-latency.collection");
+var user_collection_1 = require("./collections/user.collection");
+var home_1 = require("./http/home");
+var auth_1 = require("./http/auth");
+var health_1 = require("./http/health");
+var ResolveIOMainServer = /** @class */ (function () {
+    function ResolveIOMainServer(mainServer, monitorAgent, serverConfig, clientRoutes, clientDir, sesMail, standardProgram) {
+        var _this = this;
         this._msgQueue = [];
         this._msgQueueRunning = false;
         this.sesMail = false;
@@ -41,68 +87,105 @@ export default class ResolveIOMainServer {
         this._serverStartTime = new Date();
         this._lastErrorMsg = null;
         if (serverConfig['ROOT_URL'] !== 'http://localhost:4200') {
-            this._monitorManager = new MonitorManager(mainServer, monitorAgent, serverConfig);
+            this._monitorManager = new monitor_manager_1.MonitorManager(mainServer, monitorAgent, serverConfig);
         }
-        process.on('unhandledRejection', async (error, rej) => {
-            // console.error('Unhandled Rejection at Promise', [error, rej]);
-            let diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
-            if (error && error['name'] === 'MongoError' && error['message'] === 'not master') {
-                if (diffTimeSec > 60 && !this._lastErrorMsg) {
-                    this._lastErrorMsg = new Date();
-                    setTimeout(() => {
-                        this._lastErrorMsg = null;
-                    }, 60000);
-                    await this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - Quitting NodeJS - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
-                }
-                process.exit(1);
-            }
-            else if (error && error['name'] === 'MongoError' && error['message'] === 'not master and slaveOk=false') {
-                if (diffTimeSec > 60 && !this._lastErrorMsg) {
-                    this._lastErrorMsg = new Date();
-                    setTimeout(() => {
-                        this._lastErrorMsg = null;
-                    }, 60000);
-                    await this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - Quitting NodeJS - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
+        process.on('unhandledRejection', function (error, rej) { return __awaiter(_this, void 0, void 0, function () {
+            var diffTimeSec;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+                        if (!(error && error['name'] === 'MongoError' && error['message'] === 'not master')) return [3 /*break*/, 3];
+                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 2];
+                        this._lastErrorMsg = new Date();
+                        setTimeout(function () {
+                            _this._lastErrorMsg = null;
+                        }, 60000);
+                        return [4 /*yield*/, this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - Quitting NodeJS - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        process.exit(1);
+                        return [3 /*break*/, 7];
+                    case 3:
+                        if (!(error && error['name'] === 'MongoError' && error['message'] === 'not master and slaveOk=false')) return [3 /*break*/, 6];
+                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 5];
+                        this._lastErrorMsg = new Date();
+                        setTimeout(function () {
+                            _this._lastErrorMsg = null;
+                        }, 60000);
+                        return [4 /*yield*/, this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - Quitting NodeJS - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2))];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        process.exit(1);
+                        return [3 /*break*/, 7];
+                    case 6:
+                        if (error) {
+                            if (error['name'] !== 'StatusError' && error['message'] !== '') {
+                                if (diffTimeSec > 60 && !this._lastErrorMsg) {
+                                    this._lastErrorMsg = new Date();
+                                    setTimeout(function () {
+                                        _this._lastErrorMsg = null;
+                                    }, 60000);
+                                    this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
+                                }
+                            }
+                        }
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
                 }
-                process.exit(1);
-            }
-            else if (error) {
-                if (error['name'] !== 'StatusError' && error['message'] !== '') {
-                    if (diffTimeSec > 60 && !this._lastErrorMsg) {
+            });
+        }); });
+        process.on('uncaughtException', function (error) { return __awaiter(_this, void 0, void 0, function () {
+            var diffTimeSec;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.error(error, 'Uncaught Exception thrown');
+                        diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 2];
                         this._lastErrorMsg = new Date();
-                        setTimeout(() => {
-                            this._lastErrorMsg = null;
+                        setTimeout(function () {
+                            _this._lastErrorMsg = null;
                         }, 60000);
-                        this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
-                    }
+                        return [4 /*yield*/, this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Exception - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        process.exit(1);
+                        return [2 /*return*/];
                 }
-            }
-        });
-        process.on('uncaughtException', async (error) => {
-            console.error(error, 'Uncaught Exception thrown');
-            let diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
-            if (diffTimeSec > 60 && !this._lastErrorMsg) {
-                this._lastErrorMsg = new Date();
-                setTimeout(() => {
-                    this._lastErrorMsg = null;
-                }, 60000);
-                await this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Exception - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
-            }
-            process.exit(1);
-        });
-        SegfaultHandler.registerHandler('crash.log', async (signal, address, stack) => {
-            // Do what you want with the signal, address, or stack (array)
-            // This callback will execute before the signal is forwarded on.
-            console.log('Segment Fault Detected');
-            console.log('Signal', JSON.stringify(signal, null, 2));
-            console.log('Address', JSON.stringify(address, null, 2));
-            console.log('Stack', JSON.stringify(stack, null, 2));
-            let diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
-            if (diffTimeSec > 60 && !this._lastErrorMsg) {
-                await this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Segfault - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([signal, address, stack], null, 2));
-            }
-            process.exit(1);
-        });
+            });
+        }); });
+        SegfaultHandler.registerHandler('crash.log', function (signal, address, stack) { return __awaiter(_this, void 0, void 0, function () {
+            var diffTimeSec;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Do what you want with the signal, address, or stack (array)
+                        // This callback will execute before the signal is forwarded on.
+                        console.log('Segment Fault Detected');
+                        console.log('Signal', JSON.stringify(signal, null, 2));
+                        console.log('Address', JSON.stringify(address, null, 2));
+                        console.log('Stack', JSON.stringify(stack, null, 2));
+                        diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Segfault - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([signal, address, stack], null, 2))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        process.exit(1);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         //SegfaultHandler.causeSegfault(); // simulates a buggy native module that dereferences NULL
         if (this.LOGGER === 'DEBUG') {
             console.log('Starting ResolveIO Server');
@@ -110,7 +193,7 @@ export default class ResolveIOMainServer {
         // Start express app
         this._app = express();
         // Use body parser for http call (login)
-        this._app.use(bodyParser.json({ limit: '50mb', reviver: dateReviver }));
+        this._app.use(bodyParser.json({ limit: '50mb', reviver: common_1.dateReviver }));
         this._app.use(bodyParser.urlencoded({ limit: '50mb', extended: true, parameterLimit: 1000000 }));
         this._app.use(xmlParser());
         // Set port
@@ -143,151 +226,170 @@ export default class ResolveIOMainServer {
             console.log('Setup cors');
         }
         // Set up http login route
-        setupAuthRoutes(this, this._app, serverConfig);
-        setupHealthRoutes(this._app, serverConfig);
+        auth_1.setupAuthRoutes(this, this._app, serverConfig);
+        health_1.setupHealthRoutes(this._app, serverConfig);
         if (serverConfig['CLIENT_NAME'] === 'ResolveIO' || this.standardProgram) {
-            setupHomeRoutes(this, this._app, serverConfig);
+            home_1.setupHomeRoutes(this, this._app, serverConfig);
         }
         if (this.LOGGER === 'DEBUG') {
             console.log('Setup express routes');
         }
     }
-    getWS(id_ws) {
-        let res = null;
-        this._wss.clients.forEach((ws) => {
+    ResolveIOMainServer.prototype.getWS = function (id_ws) {
+        var res = null;
+        this._wss.clients.forEach(function (ws) {
             if (ws['id_socket'] === id_ws) {
                 res = ws;
             }
         });
         return res;
-    }
-    getWSList() {
-        let res = [];
-        this._wss.clients.forEach((ws) => {
+    };
+    ResolveIOMainServer.prototype.getWSList = function () {
+        var res = [];
+        this._wss.clients.forEach(function (ws) {
             res.push(ws['id_socket']);
         });
         return res;
-    }
-    getWSUserList() {
-        let res = [];
-        this._wss.clients.forEach((ws) => {
+    };
+    ResolveIOMainServer.prototype.getWSUserList = function () {
+        var res = [];
+        this._wss.clients.forEach(function (ws) {
             res.push(ws['id_user']);
         });
         return res;
-    }
-    getHTTPServer() {
+    };
+    ResolveIOMainServer.prototype.getHTTPServer = function () {
         return this._server;
-    }
-    getCronManager() {
+    };
+    ResolveIOMainServer.prototype.getCronManager = function () {
         return this._cronManager;
-    }
-    getMethodManager() {
+    };
+    ResolveIOMainServer.prototype.getMethodManager = function () {
         return this._methodManager;
-    }
-    getSubscriptionManager() {
+    };
+    ResolveIOMainServer.prototype.getSubscriptionManager = function () {
         return this._subscriptionManager;
-    }
-    getQueueManager() {
+    };
+    ResolveIOMainServer.prototype.getQueueManager = function () {
         return this._queueManager;
-    }
-    getMonitorManager() {
+    };
+    ResolveIOMainServer.prototype.getMonitorManager = function () {
         return this._monitorManager;
-    }
-    createServer() {
+    };
+    ResolveIOMainServer.prototype.createServer = function () {
+        var _this = this;
         // Start express server
-        this._server = createServer(this._app);
+        this._server = http_1.createServer(this._app);
         this._server.keepAliveTimeout = 65000;
         this._server.headersTimeout = 66000; // This should be bigger than `keepAliveTimeout + your server's expected response time`
         // Start websocket server
         // Verify client with token before opening socket
         this._wss = new WebSocket.Server({
             server: this._server,
-            verifyClient: async (info, cb) => {
-                if (this.LOGGER === 'DEBUG') {
-                    console.log('Verify Client', info, cb);
-                }
-                let infoData = info.req.headers['sec-websocket-protocol'].split(/,/);
-                if (info.origin !== this._serverConfig['ROOT_URL'] && info.origin !== this._serverConfig['SEC_ROOT_URL'] && info.origin !== this._serverConfig['RESOLVEIO_URL'] && info.origin !== this._serverConfig['RESOLVEIO_SECONDARY_URL']) {
-                    cb(false, 401, 'Unauthorized');
-                }
-                else {
-                    if (infoData[1]) { //app version
-                        let token = infoData[0];
-                        if (!token) {
-                            cb(false, 401, 'Unauthorized');
+            verifyClient: function (info, cb) { return __awaiter(_this, void 0, void 0, function () {
+                var infoData, token;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (this.LOGGER === 'DEBUG') {
+                        console.log('Verify Client', info, cb);
+                    }
+                    infoData = info.req.headers['sec-websocket-protocol'].split(/,/);
+                    if (info.origin !== this._serverConfig['ROOT_URL'] && info.origin !== this._serverConfig['SEC_ROOT_URL'] && info.origin !== this._serverConfig['RESOLVEIO_URL'] && info.origin !== this._serverConfig['RESOLVEIO_SECONDARY_URL']) {
+                        cb(false, 401, 'Unauthorized');
+                    }
+                    else {
+                        if (infoData[1]) { //app version
+                            token = infoData[0];
+                            if (!token) {
+                                cb(false, 401, 'Unauthorized');
+                            }
+                            else {
+                                jwt.verify(token, this._serverConfig['JWT_SECRET'], function (err, decoded) { return __awaiter(_this, void 0, void 0, function () {
+                                    var user, err_1;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                if (!err) return [3 /*break*/, 1];
+                                                cb(false, 401, 'Unauthorized');
+                                                return [3 /*break*/, 5];
+                                            case 1:
+                                                info.req['id_user'] = decoded['id_user'];
+                                                _a.label = 2;
+                                            case 2:
+                                                _a.trys.push([2, 4, , 5]);
+                                                return [4 /*yield*/, user_collection_1.Users.findById(decoded['id_user'])];
+                                            case 3:
+                                                user = _a.sent();
+                                                if (user) {
+                                                    info.req['user'] = user.fullname;
+                                                    info.req['user_readonly'] = user.readonly || false;
+                                                    info.req['doc_user'] = user;
+                                                    cb(true);
+                                                }
+                                                else {
+                                                    cb(false);
+                                                }
+                                                return [3 /*break*/, 5];
+                                            case 4:
+                                                err_1 = _a.sent();
+                                                cb(false);
+                                                return [3 /*break*/, 5];
+                                            case 5: return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                            }
                         }
                         else {
-                            jwt.verify(token, this._serverConfig['JWT_SECRET'], async (err, decoded) => {
-                                if (err) {
-                                    cb(false, 401, 'Unauthorized');
-                                }
-                                else {
-                                    info.req['id_user'] = decoded['id_user'];
-                                    try {
-                                        let user = await Users.findById(decoded['id_user']);
-                                        if (user) {
-                                            info.req['user'] = user.fullname;
-                                            info.req['user_readonly'] = user.readonly || false;
-                                            info.req['doc_user'] = user;
-                                            cb(true);
-                                        }
-                                        else {
-                                            cb(false);
-                                        }
-                                    }
-                                    catch (err) {
-                                        cb(false);
-                                    }
-                                }
-                            });
+                            cb(false, 401, 'Invalid Version');
                         }
                     }
-                    else {
-                        cb(false, 401, 'Invalid Version');
-                    }
-                }
-            }
+                    return [2 /*return*/];
+                });
+            }); }
         });
         // Start MongoDB Connection
         this.setUpMongo();
-    }
-    setUpMongo() {
+    };
+    ResolveIOMainServer.prototype.setUpMongo = function () {
         this.setUpPassport();
         if (this.LOGGER === 'DEBUG') {
             console.log('Start Managers');
         }
         // Start Managers
-        this._subscriptionManager = new SubscriptionManager(this, this._wss, this._serverConfig);
-        this._methodManager = new MethodManager(this, this._serverConfig, this._clientDir);
-        this._cronManager = new CronManager(this);
-        this._queueManager = new QueueMethodManager(this);
+        this._subscriptionManager = new subscription_manager_1.SubscriptionManager(this, this._wss, this._serverConfig);
+        this._methodManager = new method_manager_1.MethodManager(this, this._serverConfig, this._clientDir);
+        this._cronManager = new cron_manager_1.CronManager(this);
+        this._queueManager = new queue_method_manager_1.QueueMethodManager(this);
         if (this.LOGGER === 'DEBUG') {
             console.log('End Managers');
         }
         this.listen();
-    }
-    setUpPassport() {
-        if (Users) {
+    };
+    ResolveIOMainServer.prototype.setUpPassport = function () {
+        var _this = this;
+        if (user_collection_1.Users) {
             // Set up login passort
             this._app.use(passport.initialize());
             // Start user authentication
-            passport.use(new passportlocal.Strategy(Users.authenticateStrategy()));
-            passport.serializeUser(Users.serializeUser());
-            passport.deserializeUser(Users.deserializeUser());
+            passport.use(new passportlocal.Strategy(user_collection_1.Users.authenticateStrategy()));
+            passport.serializeUser(user_collection_1.Users.serializeUser());
+            passport.deserializeUser(user_collection_1.Users.deserializeUser());
         }
         else {
-            setTimeout(() => {
-                this.setUpPassport();
+            setTimeout(function () {
+                _this.setUpPassport();
             }, 1);
         }
-    }
+    };
     // Listen to port for websocket
-    listen() {
-        this._server.listen(this._port, () => {
-            console.log('Running server on port %s', this._port);
+    ResolveIOMainServer.prototype.listen = function () {
+        var _this = this;
+        this._server.listen(this._port, function () {
+            console.log('Running server on port %s', _this._port);
         });
         // On websocket connection (already verified)
-        this._wss.on('connection', (ws, req) => {
+        this._wss.on('connection', function (ws, req) {
             // Get user from token
             ws['id_user'] = req.id_user;
             ws['user'] = req.user;
@@ -295,270 +397,309 @@ export default class ResolveIOMainServer {
             ws['doc_user'] = req.doc_user;
             ws['id_socket'] = uuid();
             ws['retryCnt'] = 0;
-            if (this.LOGGER === 'DEBUG') {
+            if (_this.LOGGER === 'DEBUG') {
                 console.log('Connection from: ' + req.user);
             }
             // Use for keeping connection alive (ping/pong)
             ws['isAlive'] = true;
-            ws.on('pong', () => {
+            ws.on('pong', function () {
                 ws['isAlive'] = true;
                 ws['pongTime'] = new Date();
                 ws['latency'] = moment.duration(moment(ws['pongTime']).diff(ws['pingTime'])).asMilliseconds();
-                this._subscriptionManager.loggedInLatency(ws);
+                _this._subscriptionManager.loggedInLatency(ws);
             });
-            ws['versionTimer'] = setTimeout(() => {
-                this.unsubscribeWS(ws);
+            ws['versionTimer'] = setTimeout(function () {
+                _this.unsubscribeWS(ws);
             }, 10000);
             // On data received (message)
-            ws.on('message', async (message) => {
-                if (this.LOGGER === 'DEBUG') {
-                    console.log('Message from: ' + ws['user'], message);
-                }
-                let parseErrorFound = false;
-                let socketData = null;
-                try {
-                    socketData = JSON.parse(message, dateReviver);
-                }
-                catch (e) {
-                    console.log('Error - JSON.parse', message);
-                    this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - JSON Parse Error - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([message, e]));
-                    parseErrorFound = true;
-                }
-                if (!parseErrorFound) {
-                    let data = deepCopy(socketData);
-                    if (data[0] === 'ping') {
-                        if (ws && ws.readyState === ws.OPEN) {
-                            ws.send('pong', (error) => {
-                                if (error) {
-                                    console.log('Error on WS: ', error);
-                                    this.unsubscribeWS(ws);
-                                }
-                            });
-                        }
-                        return;
+            ws.on('message', function (message) { return __awaiter(_this, void 0, void 0, function () {
+                var parseErrorFound, socketData, data, messageRoute_1, messageDate, messageId, type, subType, pub;
+                var _a, _b;
+                var _this = this;
+                return __generator(this, function (_c) {
+                    if (this.LOGGER === 'DEBUG') {
+                        console.log('Message from: ' + ws['user'], message);
                     }
-                    let messageRoute = data.shift();
-                    if (this._clientRoutes.some(a => messageRoute.includes(a)) && !ws['doc_user'].roles.groups.some(a => a.views.some(b => messageRoute.includes(b))) && !ws['doc_user'].roles.super_admin) {
-                        return;
+                    parseErrorFound = false;
+                    socketData = null;
+                    try {
+                        socketData = JSON.parse(message, common_1.dateReviver);
                     }
-                    let messageDate = data.shift();
-                    let messageId = data.shift();
-                    let type = data.shift();
-                    if (type === 'subscription') {
-                        let subType = data.shift();
-                        let pub = data.shift();
-                        // Subscribe
-                        if (subType === 'sub') {
-                            this._subscriptionManager.subscribe(messageDate, ws, messageId, pub, ...data);
+                    catch (e) {
+                        console.log('Error - JSON.parse', message);
+                        this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - JSON Parse Error - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([message, e]));
+                        parseErrorFound = true;
+                    }
+                    if (!parseErrorFound) {
+                        data = common_1.deepCopy(socketData);
+                        if (data[0] === 'ping') {
+                            if (ws && ws.readyState === ws.OPEN) {
+                                ws.send('pong', function (error) {
+                                    if (error) {
+                                        console.log('Error on WS: ', error);
+                                        _this.unsubscribeWS(ws);
+                                    }
+                                });
+                            }
+                            return [2 /*return*/];
+                        }
+                        messageRoute_1 = data.shift();
+                        if (this._clientRoutes.some(function (a) { return messageRoute_1.includes(a); }) && !ws['doc_user'].roles.groups.some(function (a) { return a.views.some(function (b) { return messageRoute_1.includes(b); }); }) && !ws['doc_user'].roles.super_admin) {
+                            return [2 /*return*/];
+                        }
+                        messageDate = data.shift();
+                        messageId = data.shift();
+                        type = data.shift();
+                        if (type === 'subscription') {
+                            subType = data.shift();
+                            pub = data.shift();
+                            // Subscribe
+                            if (subType === 'sub') {
+                                (_a = this._subscriptionManager).subscribe.apply(_a, __spreadArrays([messageDate, ws, messageId, pub], data));
+                            }
+                            // Unsubscribe
+                            else {
+                                (_b = this._subscriptionManager).unsubscribe.apply(_b, __spreadArrays([messageDate, ws, messageId, pub], data));
+                            }
                         }
-                        // Unsubscribe
                         else {
-                            this._subscriptionManager.unsubscribe(messageDate, ws, messageId, pub, ...data);
+                            this._msgQueue.splice(0, 0, {
+                                ws: ws,
+                                data: socketData
+                            });
                         }
                     }
-                    else {
-                        this._msgQueue.splice(0, 0, {
-                            ws: ws,
-                            data: socketData
-                        });
-                    }
-                }
+                    return [2 /*return*/];
+                });
+            }); });
+            ws.on('close', function () {
+                _this.unsubscribeWS(ws);
             });
-            ws.on('close', () => {
-                this.unsubscribeWS(ws);
-            });
-            ws.on('error', error => {
+            ws.on('error', function (error) {
                 console.log(error);
-                this.unsubscribeWS(ws);
+                _this.unsubscribeWS(ws);
             });
         });
         // Keep alive timer to ping/pong
-        setInterval(() => {
-            this._wss.clients.forEach((ws) => {
+        setInterval(function () {
+            _this._wss.clients.forEach(function (ws) {
                 if (ws['isAlive'] === false) {
                     ws['retryCnt']++;
                     if (ws['retryCnt'] >= 60) {
-                        this.unsubscribeWS(ws);
+                        _this.unsubscribeWS(ws);
                     }
                     else {
                         ws['pingTime'] = new Date();
-                        ws.ping(() => { });
+                        ws.ping(function () { });
                     }
                 }
                 else {
                     ws['retryCnt'] = 0;
                     ws['isAlive'] = false;
                     ws['pingTime'] = new Date();
-                    ws.ping(() => { });
+                    ws.ping(function () { });
                 }
             });
         }, 5000);
-        setInterval(async () => {
-            // console.log(data);
-            if (!this._msgQueueRunning) {
-                this._msgQueueRunning = true;
-                for (let i = this._msgQueue.length - 1; i >= 0; i--) {
-                    let msg = this._msgQueue.pop();
-                    let data = msg.data;
-                    let ws = msg.ws;
-                    let messageRoute = data.shift();
-                    let messageDate = data.shift();
-                    let messageId = data.shift();
-                    let type = data.shift();
-                    // Method call
-                    if (type === 'method') {
-                        let method = data.shift();
-                        if (method === 'setWSAppVersion') {
-                            clearTimeout(ws['versionTimer']);
-                        }
-                        if (method === 'disconnectWSCommand') {
-                            setTimeout(() => {
-                                this.unsubscribeWS(ws);
-                            }, 1000);
-                        }
-                        if (ws['user_readonly']) {
-                            continue;
-                        }
-                        let methodLatencyId = objectIdHexString();
-                        LogMethodLatencies.create({
-                            _id: methodLatencyId,
-                            __v: 0,
-                            date_start: new Date(),
-                            date_end: null,
-                            latency_ms: 0,
-                            method: method
-                        });
-                        if (method !== 'reportBuilderGetResults' && method !== 'reportBuilderGetDistinctValue' && method !== 'reportBuilderBuildTree' && method !== 'generatePDF' && method !== 'getWOOfflineData' && method !== 'countQuery' && method !== 'countWithQuery' && method !== 'countCollectionWithQuery' && method !== 'find' && method !== 'findOne' && method !== 'findWithOptions' && method !== 'setWSAppVersion' && method !== 'getDrivers') {
-                            Logs.create({
-                                _id: objectIdHexString(),
-                                type: 'client-request',
-                                collection: '',
-                                id_document: '',
-                                payload: getBinarySize(JSON.stringify(data)) < 200000 ? JSON.stringify(data, null, 2) : 'Too Big',
-                                method: method,
-                                id_user: ws['id_user'],
-                                user: ws['user'],
-                                messageId: messageId.toString(),
-                                route: messageRoute
-                            });
-                        }
-                        let serverRes = {
-                            messageId: messageId,
-                            hasError: false,
-                            data: 'ACK'
-                        };
-                        if (ws && ws.readyState === ws.OPEN) {
-                            ws.send(JSON.stringify(serverRes), (error) => {
-                                if (error) {
-                                    console.log('Error on WS: ', error);
-                                    this.unsubscribeWS(ws);
-                                }
-                            });
-                        }
-                        if (this._methodManager._methods[method]) {
-                            let query = { $and: [
-                                    { id_user: ws['id_user'] },
-                                    { message_id: messageId },
-                                    { date: messageDate }
-                                ] };
-                            if (method !== 'updateDocumentOffline' && method !== 'updateDocumentPropsOffline') {
-                                query.$and.push({ method: method });
-                            }
-                            else {
-                                if (method === 'updateDocumentOffline') {
-                                    query.$and.push({
-                                        $or: [
-                                            { method: method },
-                                            { method: 'updateDocument' }
-                                        ]
-                                    });
-                                }
-                                else if (method === 'updateDocumentPropsOffline') {
-                                    query.$and.push({
-                                        $or: [
-                                            { method: method },
-                                            { method: 'updateDocumentProps' }
-                                        ]
-                                    });
-                                }
-                            }
-                            let methodCall = await MethodCalls.findOne(query);
-                            if (!methodCall) {
-                                MethodCalls.create({
-                                    _id: objectIdHexString(),
-                                    __v: 0,
-                                    id_user: ws['id_user'],
-                                    message_id: messageId.toString(),
-                                    method: method,
-                                    date: messageDate
-                                });
-                                if (this._methodManager._methods[method]) {
-                                    if (this._methodManager._methods[method].skipQueue) {
-                                        this._methodManager.callMethod(methodLatencyId, ws, messageDate, messageId, method, ...data);
-                                    }
-                                    else {
-                                        this._queueManager.addMethodToQueue(methodLatencyId, ws['id_socket'], ws['id_user'], ws['user'], messageDate, messageId, method, data);
-                                    }
-                                }
-                                else {
-                                    console.log('Could not find method: ' + method);
-                                }
-                            }
-                            else {
-                                MethodResponses.findOne({ $and: [
-                                        { id_user: ws['id_user'] },
-                                        { message_id: messageId.toString() },
-                                        { method: method },
-                                        { date: messageDate }
-                                    ] }).then(res => {
-                                    if (res) {
+        setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _loop_1, this_1, i;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this._msgQueueRunning) return [3 /*break*/, 5];
+                        this._msgQueueRunning = true;
+                        _loop_1 = function (i) {
+                            var msg, data, ws, messageRoute, messageDate, messageId, type, method, methodLatencyId, serverRes, query, methodCall, method;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        msg = this_1._msgQueue.pop();
+                                        data = msg.data;
+                                        ws = msg.ws;
+                                        messageRoute = data.shift();
+                                        messageDate = data.shift();
+                                        messageId = data.shift();
+                                        type = data.shift();
+                                        if (!(type === 'method')) return [3 /*break*/, 4];
+                                        method = data.shift();
+                                        if (method === 'setWSAppVersion') {
+                                            clearTimeout(ws['versionTimer']);
+                                        }
+                                        if (method === 'disconnectWSCommand') {
+                                            setTimeout(function () {
+                                                _this.unsubscribeWS(ws);
+                                            }, 1000);
+                                        }
+                                        if (ws['user_readonly']) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        methodLatencyId = mongo_manager_1.objectIdHexString();
+                                        log_method_latency_collection_1.LogMethodLatencies.create({
+                                            _id: methodLatencyId,
+                                            __v: 0,
+                                            date_start: new Date(),
+                                            date_end: null,
+                                            latency_ms: 0,
+                                            method: method
+                                        });
+                                        if (method !== 'reportBuilderGetResults' && method !== 'reportBuilderGetDistinctValue' && method !== 'reportBuilderBuildTree' && method !== 'generatePDF' && method !== 'getWOOfflineData' && method !== 'countQuery' && method !== 'countWithQuery' && method !== 'countCollectionWithQuery' && method !== 'find' && method !== 'findOne' && method !== 'findWithOptions' && method !== 'setWSAppVersion' && method !== 'getDrivers') {
+                                            log_collection_1.Logs.create({
+                                                _id: mongo_manager_1.objectIdHexString(),
+                                                type: 'client-request',
+                                                collection: '',
+                                                id_document: '',
+                                                payload: common_1.getBinarySize(JSON.stringify(data)) < 200000 ? JSON.stringify(data, null, 2) : 'Too Big',
+                                                method: method,
+                                                id_user: ws['id_user'],
+                                                user: ws['user'],
+                                                messageId: messageId.toString(),
+                                                route: messageRoute
+                                            });
+                                        }
+                                        serverRes = {
+                                            messageId: messageId,
+                                            hasError: false,
+                                            data: 'ACK'
+                                        };
                                         if (ws && ws.readyState === ws.OPEN) {
-                                            ws.send(JSON.stringify(res.response), (error) => {
+                                            ws.send(JSON.stringify(serverRes), function (error) {
                                                 if (error) {
                                                     console.log('Error on WS: ', error);
-                                                    this.unsubscribeWS(ws);
+                                                    _this.unsubscribeWS(ws);
                                                 }
                                             });
                                         }
-                                    }
-                                }, err => { });
-                            }
-                        }
-                        else {
-                            console.log('Could not find method: ' + method);
-                        }
-                    }
-                    else if (type === 'methodResponse') {
-                        let method = data.shift();
-                        MethodResponses.findOne({ $and: [
-                                { id_user: ws['id_user'] },
-                                { message_id: messageId.toString() },
-                                { method: method },
-                                { date: messageDate }
-                            ] }).then(res => {
-                            if (res) {
-                                if (ws && ws.readyState === ws.OPEN) {
-                                    ws.send(JSON.stringify(res.response), (error) => {
-                                        if (error) {
-                                            console.log('Error on WS: ', error);
-                                            this.unsubscribeWS(ws);
+                                        if (!this_1._methodManager._methods[method]) return [3 /*break*/, 2];
+                                        query = { $and: [
+                                                { id_user: ws['id_user'] },
+                                                { message_id: messageId },
+                                                { date: messageDate }
+                                            ] };
+                                        if (method !== 'updateDocumentOffline' && method !== 'updateDocumentPropsOffline') {
+                                            query.$and.push({ method: method });
                                         }
-                                    });
+                                        else {
+                                            if (method === 'updateDocumentOffline') {
+                                                query.$and.push({
+                                                    $or: [
+                                                        { method: method },
+                                                        { method: 'updateDocument' }
+                                                    ]
+                                                });
+                                            }
+                                            else if (method === 'updateDocumentPropsOffline') {
+                                                query.$and.push({
+                                                    $or: [
+                                                        { method: method },
+                                                        { method: 'updateDocumentProps' }
+                                                    ]
+                                                });
+                                            }
+                                        }
+                                        return [4 /*yield*/, method_call_collection_1.MethodCalls.findOne(query)];
+                                    case 1:
+                                        methodCall = _b.sent();
+                                        if (!methodCall) {
+                                            method_call_collection_1.MethodCalls.create({
+                                                _id: mongo_manager_1.objectIdHexString(),
+                                                __v: 0,
+                                                id_user: ws['id_user'],
+                                                message_id: messageId.toString(),
+                                                method: method,
+                                                date: messageDate
+                                            });
+                                            if (this_1._methodManager._methods[method]) {
+                                                if (this_1._methodManager._methods[method].skipQueue) {
+                                                    (_a = this_1._methodManager).callMethod.apply(_a, __spreadArrays([methodLatencyId, ws, messageDate, messageId, method], data));
+                                                }
+                                                else {
+                                                    this_1._queueManager.addMethodToQueue(methodLatencyId, ws['id_socket'], ws['id_user'], ws['user'], messageDate, messageId, method, data);
+                                                }
+                                            }
+                                            else {
+                                                console.log('Could not find method: ' + method);
+                                            }
+                                        }
+                                        else {
+                                            method_response_collection_1.MethodResponses.findOne({ $and: [
+                                                    { id_user: ws['id_user'] },
+                                                    { message_id: messageId.toString() },
+                                                    { method: method },
+                                                    { date: messageDate }
+                                                ] }).then(function (res) {
+                                                if (res) {
+                                                    if (ws && ws.readyState === ws.OPEN) {
+                                                        ws.send(JSON.stringify(res.response), function (error) {
+                                                            if (error) {
+                                                                console.log('Error on WS: ', error);
+                                                                _this.unsubscribeWS(ws);
+                                                            }
+                                                        });
+                                                    }
+                                                }
+                                            }, function (err) { });
+                                        }
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        console.log('Could not find method: ' + method);
+                                        _b.label = 3;
+                                    case 3: return [3 /*break*/, 5];
+                                    case 4:
+                                        if (type === 'methodResponse') {
+                                            method = data.shift();
+                                            method_response_collection_1.MethodResponses.findOne({ $and: [
+                                                    { id_user: ws['id_user'] },
+                                                    { message_id: messageId.toString() },
+                                                    { method: method },
+                                                    { date: messageDate }
+                                                ] }).then(function (res) {
+                                                if (res) {
+                                                    if (ws && ws.readyState === ws.OPEN) {
+                                                        ws.send(JSON.stringify(res.response), function (error) {
+                                                            if (error) {
+                                                                console.log('Error on WS: ', error);
+                                                                _this.unsubscribeWS(ws);
+                                                            }
+                                                        });
+                                                    }
+                                                }
+                                            }, function (err) { });
+                                        }
+                                        _b.label = 5;
+                                    case 5: return [2 /*return*/];
                                 }
-                            }
-                        }, err => { });
-                    }
+                            });
+                        };
+                        this_1 = this;
+                        i = this._msgQueue.length - 1;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i >= 0)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1(i)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        i--;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        this._msgQueueRunning = false;
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
                 }
-                this._msgQueueRunning = false;
-            }
-        }, 10);
-    }
-    unsubscribeWS(ws) {
+            });
+        }); }, 10);
+    };
+    ResolveIOMainServer.prototype.unsubscribeWS = function (ws) {
         this._subscriptionManager.unsubscribeAll(ws);
-    }
-    getApp() {
+    };
+    ResolveIOMainServer.prototype.getApp = function () {
         return this._app;
-    }
-}
+    };
+    return ResolveIOMainServer;
+}());
+exports.default = ResolveIOMainServer;
 
 //# sourceMappingURL=server-app.js.map