@resolveio/server-lib 9.0.32 → 9.0.34

package/server-app.js

@@ -1,77 +1,31 @@
-"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;
+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) {
         this._msgQueue = [];
         this._msgQueueRunning = false;
         this.sesMail = false;
@@ -87,105 +41,68 @@ var ResolveIOMainServer = /** @class */ (function () {
         this._serverStartTime = new Date();
         this._lastErrorMsg = null;
         if (serverConfig['ROOT_URL'] !== 'http://localhost:4200') {
-            this._monitorManager = new monitor_manager_1.MonitorManager(mainServer, monitorAgent, serverConfig);
+            this._monitorManager = new MonitorManager(mainServer, monitorAgent, serverConfig);
         }
-        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.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.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];
+                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.exit(1);
+            }
+            else if (error) {
+                if (error['name'] !== 'StatusError' && error['message'] !== '') {
+                    if (diffTimeSec > 60 && !this._lastErrorMsg) {
                         this._lastErrorMsg = new Date();
-                        setTimeout(function () {
-                            _this._lastErrorMsg = null;
+                        setTimeout(() => {
+                            this._lastErrorMsg = null;
                         }, 60000);
-                        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*/];
-                }
-            });
-        }); });
-        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*/];
+                        this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
+                    }
                 }
-            });
-        }); });
+            }
+        });
+        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.causeSegfault(); // simulates a buggy native module that dereferences NULL
         if (this.LOGGER === 'DEBUG') {
             console.log('Starting ResolveIO Server');
@@ -193,7 +110,7 @@ var ResolveIOMainServer = /** @class */ (function () {
         // Start express app
         this._app = express();
         // Use body parser for http call (login)
-        this._app.use(bodyParser.json({ limit: '50mb', reviver: common_1.dateReviver }));
+        this._app.use(bodyParser.json({ limit: '50mb', reviver: dateReviver }));
         this._app.use(bodyParser.urlencoded({ limit: '50mb', extended: true, parameterLimit: 1000000 }));
         this._app.use(xmlParser());
         // Set port
@@ -226,170 +143,151 @@ var ResolveIOMainServer = /** @class */ (function () {
             console.log('Setup cors');
         }
         // Set up http login route
-        auth_1.setupAuthRoutes(this, this._app, serverConfig);
-        health_1.setupHealthRoutes(this._app, serverConfig);
+        setupAuthRoutes(this, this._app, serverConfig);
+        setupHealthRoutes(this._app, serverConfig);
         if (serverConfig['CLIENT_NAME'] === 'ResolveIO' || this.standardProgram) {
-            home_1.setupHomeRoutes(this, this._app, serverConfig);
+            setupHomeRoutes(this, this._app, serverConfig);
         }
         if (this.LOGGER === 'DEBUG') {
             console.log('Setup express routes');
         }
     }
-    ResolveIOMainServer.prototype.getWS = function (id_ws) {
-        var res = null;
-        this._wss.clients.forEach(function (ws) {
+    getWS(id_ws) {
+        let res = null;
+        this._wss.clients.forEach((ws) => {
             if (ws['id_socket'] === id_ws) {
                 res = ws;
             }
         });
         return res;
-    };
-    ResolveIOMainServer.prototype.getWSList = function () {
-        var res = [];
-        this._wss.clients.forEach(function (ws) {
+    }
+    getWSList() {
+        let res = [];
+        this._wss.clients.forEach((ws) => {
             res.push(ws['id_socket']);
         });
         return res;
-    };
-    ResolveIOMainServer.prototype.getWSUserList = function () {
-        var res = [];
-        this._wss.clients.forEach(function (ws) {
+    }
+    getWSUserList() {
+        let res = [];
+        this._wss.clients.forEach((ws) => {
             res.push(ws['id_user']);
         });
         return res;
-    };
-    ResolveIOMainServer.prototype.getHTTPServer = function () {
+    }
+    getHTTPServer() {
         return this._server;
-    };
-    ResolveIOMainServer.prototype.getCronManager = function () {
+    }
+    getCronManager() {
         return this._cronManager;
-    };
-    ResolveIOMainServer.prototype.getMethodManager = function () {
+    }
+    getMethodManager() {
         return this._methodManager;
-    };
-    ResolveIOMainServer.prototype.getSubscriptionManager = function () {
+    }
+    getSubscriptionManager() {
         return this._subscriptionManager;
-    };
-    ResolveIOMainServer.prototype.getQueueManager = function () {
+    }
+    getQueueManager() {
         return this._queueManager;
-    };
-    ResolveIOMainServer.prototype.getMonitorManager = function () {
+    }
+    getMonitorManager() {
         return this._monitorManager;
-    };
-    ResolveIOMainServer.prototype.createServer = function () {
-        var _this = this;
+    }
+    createServer() {
         // Start express server
-        this._server = http_1.createServer(this._app);
+        this._server = 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: 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*/];
-                                        }
-                                    });
-                                }); });
-                            }
+            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');
                         }
                         else {
-                            cb(false, 401, 'Invalid Version');
+                            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);
+                                    }
+                                }
+                            });
                         }
                     }
-                    return [2 /*return*/];
-                });
-            }); }
+                    else {
+                        cb(false, 401, 'Invalid Version');
+                    }
+                }
+            }
         });
         // Start MongoDB Connection
         this.setUpMongo();
-    };
-    ResolveIOMainServer.prototype.setUpMongo = function () {
+    }
+    setUpMongo() {
         this.setUpPassport();
         if (this.LOGGER === 'DEBUG') {
             console.log('Start Managers');
         }
         // Start Managers
-        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);
+        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);
         if (this.LOGGER === 'DEBUG') {
             console.log('End Managers');
         }
         this.listen();
-    };
-    ResolveIOMainServer.prototype.setUpPassport = function () {
-        var _this = this;
-        if (user_collection_1.Users) {
+    }
+    setUpPassport() {
+        if (Users) {
             // Set up login passort
             this._app.use(passport.initialize());
             // Start user authentication
-            passport.use(new passportlocal.Strategy(user_collection_1.Users.authenticateStrategy()));
-            passport.serializeUser(user_collection_1.Users.serializeUser());
-            passport.deserializeUser(user_collection_1.Users.deserializeUser());
+            passport.use(new passportlocal.Strategy(Users.authenticateStrategy()));
+            passport.serializeUser(Users.serializeUser());
+            passport.deserializeUser(Users.deserializeUser());
         }
         else {
-            setTimeout(function () {
-                _this.setUpPassport();
+            setTimeout(() => {
+                this.setUpPassport();
             }, 1);
         }
-    };
+    }
     // Listen to port for websocket
-    ResolveIOMainServer.prototype.listen = function () {
-        var _this = this;
-        this._server.listen(this._port, function () {
-            console.log('Running server on port %s', _this._port);
+    listen() {
+        this._server.listen(this._port, () => {
+            console.log('Running server on port %s', this._port);
         });
         // On websocket connection (already verified)
-        this._wss.on('connection', function (ws, req) {
+        this._wss.on('connection', (ws, req) => {
             // Get user from token
             ws['id_user'] = req.id_user;
             ws['user'] = req.user;
@@ -397,309 +295,270 @@ var ResolveIOMainServer = /** @class */ (function () {
             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', function () {
+            ws.on('pong', () => {
                 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(function () {
-                _this.unsubscribeWS(ws);
+            ws['versionTimer'] = setTimeout(() => {
+                this.unsubscribeWS(ws);
             }, 10000);
             // On data received (message)
-            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);
-                    }
-                    parseErrorFound = false;
-                    socketData = null;
-                    try {
-                        socketData = JSON.parse(message, common_1.dateReviver);
+            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;
                     }
-                    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;
+                    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;
                     }
-                    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));
-                            }
+                    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);
                         }
+                        // Unsubscribe
                         else {
-                            this._msgQueue.splice(0, 0, {
-                                ws: ws,
-                                data: socketData
-                            });
+                            this._subscriptionManager.unsubscribe(messageDate, ws, messageId, pub, ...data);
                         }
                     }
-                    return [2 /*return*/];
-                });
-            }); });
-            ws.on('close', function () {
-                _this.unsubscribeWS(ws);
+                    else {
+                        this._msgQueue.splice(0, 0, {
+                            ws: ws,
+                            data: socketData
+                        });
+                    }
+                }
             });
-            ws.on('error', function (error) {
+            ws.on('close', () => {
+                this.unsubscribeWS(ws);
+            });
+            ws.on('error', error => {
                 console.log(error);
-                _this.unsubscribeWS(ws);
+                this.unsubscribeWS(ws);
             });
         });
         // Keep alive timer to ping/pong
-        setInterval(function () {
-            _this._wss.clients.forEach(function (ws) {
+        setInterval(() => {
+            this._wss.clients.forEach((ws) => {
                 if (ws['isAlive'] === false) {
                     ws['retryCnt']++;
                     if (ws['retryCnt'] >= 60) {
-                        _this.unsubscribeWS(ws);
+                        this.unsubscribeWS(ws);
                     }
                     else {
                         ws['pingTime'] = new Date();
-                        ws.ping(function () { });
+                        ws.ping(() => { });
                     }
                 }
                 else {
                     ws['retryCnt'] = 0;
                     ws['isAlive'] = false;
                     ws['pingTime'] = new Date();
-                    ws.ping(function () { });
+                    ws.ping(() => { });
                 }
             });
         }, 5000);
-        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'
-                                        };
+        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) {
                                         if (ws && ws.readyState === ws.OPEN) {
-                                            ws.send(JSON.stringify(serverRes), function (error) {
+                                            ws.send(JSON.stringify(res.response), (error) => {
                                                 if (error) {
                                                     console.log('Error on WS: ', error);
-                                                    _this.unsubscribeWS(ws);
+                                                    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) { });
+                                    }
+                                }, 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);
                                         }
-                                        _b.label = 5;
-                                    case 5: return [2 /*return*/];
+                                    });
                                 }
-                            });
-                        };
-                        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*/];
+                            }
+                        }, err => { });
+                    }
                 }
-            });
-        }); }, 10);
-    };
-    ResolveIOMainServer.prototype.unsubscribeWS = function (ws) {
+                this._msgQueueRunning = false;
+            }
+        }, 10);
+    }
+    unsubscribeWS(ws) {
         this._subscriptionManager.unsubscribeAll(ws);
-    };
-    ResolveIOMainServer.prototype.getApp = function () {
+    }
+    getApp() {
         return this._app;
-    };
-    return ResolveIOMainServer;
-}());
-exports.default = ResolveIOMainServer;
+    }
+}
 
 //# sourceMappingURL=server-app.js.map