@resolveio/server-lib 3.2.11 → 3.2.12

package/server-app.js

@@ -0,0 +1,638 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var http_1 = require("http");
+var express = require("express");
+var mongoose = require("mongoose");
+var bodyParser = require("body-parser");
+var passport = require("passport");
+var passportlocal = require("passport-local");
+var WebSocket = require("ws");
+var jwt = require("jsonwebtoken");
+var uuid = require("uuid/v4");
+var auth_1 = require("./http/auth");
+var common_1 = require("./util/common");
+var health_1 = require("./http/health");
+var method_call_collection_1 = require("./collections/method-call.collection");
+var mongoose_1 = require("mongoose");
+var method_response_collection_1 = require("./collections/method-response.collection");
+var log_collection_1 = require("./collections/log.collection");
+var moment = require("moment");
+var user_collection_1 = require("./collections/user.collection");
+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 support_manager_1 = require("./managers/support.manager");
+var queue_method_manager_1 = require("./managers/queue-method.manager");
+var common_2 = require("./util/common");
+var ResolveIOMainServer = /** @class */ (function () {
+    function ResolveIOMainServer(mainServer, serverConfig, clientDir) {
+        this._msgQueue = [];
+        this._msgQueueRunning = false;
+        this._resolveioServer = mainServer;
+        this._serverConfig = serverConfig;
+        this._clientDir = clientDir;
+        // process.on('unhandledException').
+        // Start express app
+        this._app = express();
+        // Use body parser for http call (login)
+        this._app.use(bodyParser.json({ limit: '5mb' }));
+        this._app.use(bodyParser.urlencoded({ limit: '5mb', extended: true }));
+        // Set port
+        this._port = process.env.PORT || serverConfig['PORT'];
+        // Create http server and websock server
+        this.createServer();
+        // Set CORS
+        this._app.use(function (req, res, next) {
+            // Website you wish to allow to connect
+            // res.setHeader('Access-Control-Allow-Origin', serverConfig['ROOT_URL']);
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            // Request methods you wish to allow
+            // res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
+            // Request headers you wish to allow
+            res.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');
+            // Set to true if you need the website to include cookies in the requests sent
+            // to the API (e.g. in case you use sessions)
+            res.setHeader('Access-Control-Allow-Credentials', 'false');
+            // Pass to next layer of middleware
+            next();
+        });
+        // Set up http login route
+        auth_1.setupAuthRoutes(this, this._app, serverConfig);
+        health_1.setupHealthRoutes(this._app, serverConfig);
+    }
+    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;
+    };
+    ResolveIOMainServer.prototype.getWSList = function () {
+        var res = [];
+        this._wss.clients.forEach(function (ws) {
+            res.push(ws['id_socket']);
+        });
+        return res;
+    };
+    ResolveIOMainServer.prototype.getCronManager = function () {
+        return this._cronManager;
+    };
+    ResolveIOMainServer.prototype.getMethodManager = function () {
+        return this._methodManager;
+    };
+    ResolveIOMainServer.prototype.getSubscriptionManager = function () {
+        return this._subscriptionManager;
+    };
+    ResolveIOMainServer.prototype.getQueueManager = function () {
+        return this._queueManager;
+    };
+    ResolveIOMainServer.prototype.getSupportManager = function () {
+        return this._supportManager;
+    };
+    ResolveIOMainServer.prototype.createServer = function () {
+        var _this = this;
+        // Start express server
+        this._server = http_1.createServer(this._app);
+        // 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) {
+                    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']).exec()];
+                                            case 3:
+                                                user = _a.sent();
+                                                if (user) {
+                                                    info.req['user'] = user.fullname;
+                                                    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 {
+                            cb(false, 401, 'Invalid Version');
+                        }
+                    }
+                    return [2 /*return*/];
+                });
+            }); }
+        });
+        // Start Mongoose (MongoDB Connection)
+        this.setUpMongoose();
+    };
+    ResolveIOMainServer.prototype.setUpMongoose = function () {
+        this.setUpPassport();
+        // Enable lean by default
+        var __setOptions = mongoose_1.Query.prototype.setOptions;
+        mongoose_1.Query.prototype.setOptions = function (options) {
+            if (this._mongooseOptions.lean == null && this.mongooseCollection.collectionName !== 'users') {
+                this._mongooseOptions.lean = true;
+            }
+            __setOptions.apply(this, arguments);
+            return this;
+        };
+        // 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._supportManager = new support_manager_1.SupportManager(this, this._serverConfig, this._clientDir);
+        this._cronManager = new cron_manager_1.CronManager(this);
+        this._queueManager = new queue_method_manager_1.QueueMethodManager(this);
+        this.listen();
+        mongoose.set('useFindAndModify', false);
+        // mongoose.set('useCreateIndexes', true);
+    };
+    ResolveIOMainServer.prototype.setUpPassport = function () {
+        // Set up login passort
+        this._app.use(passport.initialize());
+        // Start user authentication
+        passport.use(new passportlocal.Strategy(user_collection_1.Users.authenticate()));
+        passport.serializeUser(user_collection_1.Users.serializeUser());
+        passport.deserializeUser(user_collection_1.Users.deserializeUser());
+    };
+    // Listen to port for http/websocket
+    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', function (ws, req) {
+            // Get user from token
+            ws['id_user'] = req.id_user;
+            ws['user'] = req.user;
+            ws['id_socket'] = uuid();
+            ws['retryCnt'] = 0;
+            // Use for keeping connection alive (ping/pong)
+            ws['isAlive'] = true;
+            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);
+            });
+            ws['versionTimer'] = setTimeout(function () {
+                _this.unsubscribeWS(ws);
+                ws.terminate();
+            }, 10000);
+            // On data received (message)
+            ws.on('message', function (message) { return __awaiter(_this, void 0, void 0, function () {
+                var socketData, data, messageDate, messageId, type, subType, pub;
+                var _a, _b;
+                var _this = this;
+                return __generator(this, function (_c) {
+                    socketData = JSON.parse(message, common_1.dateReviver);
+                    data = common_2.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*/];
+                    }
+                    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, [ws, messageId, pub].concat(data));
+                        }
+                        // Unsubscribe
+                        else {
+                            (_b = this._subscriptionManager).unsubscribe.apply(_b, [ws, messageId, pub].concat(data));
+                        }
+                    }
+                    else {
+                        this._msgQueue.splice(0, 0, {
+                            ws: ws,
+                            data: socketData
+                        });
+                    }
+                    return [2 /*return*/];
+                });
+            }); });
+            ws.on('close', function () {
+                _this.unsubscribeWS(ws);
+            });
+        });
+        // Keep alive timer to ping/pong
+        setInterval(function () {
+            _this._wss.clients.forEach(function (ws) {
+                if (ws['isAlive'] === false) {
+                    ws['retryCnt']++;
+                    if (ws['retryCnt'] >= 60) {
+                        _this.unsubscribeWS(ws);
+                        ws.terminate();
+                    }
+                    else {
+                        ws['pingTime'] = new Date();
+                        ws.ping(function () { });
+                    }
+                }
+                else {
+                    ws['retryCnt'] = 0;
+                    ws['isAlive'] = false;
+                    ws['pingTime'] = new Date();
+                    ws.ping(function () { });
+                }
+            });
+        }, 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, messageDate, messageId, type, method, serverRes, query, methodCall, supportMethod, serverRes;
+                            var _a, _b;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        msg = this_1._msgQueue.pop();
+                                        data = msg.data;
+                                        ws = msg.ws;
+                                        messageDate = data.shift();
+                                        messageId = data.shift();
+                                        type = data.shift();
+                                        method = '';
+                                        if (!(type === 'method')) return [3 /*break*/, 7];
+                                        method = data.shift();
+                                        if (method === 'setWSAppVersion') {
+                                            clearTimeout(ws['versionTimer']);
+                                        }
+                                        if (method === 'disconnectWSCommand') {
+                                            setTimeout(function () {
+                                                _this.unsubscribeWS(ws);
+                                                ws.terminate();
+                                            }, 5000);
+                                        }
+                                        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') {
+                                            if (common_1.getBinarySize(JSON.stringify(data)) < 200000) {
+                                                log_collection_1.Logs.create({
+                                                    _id: mongoose_1.Types.ObjectId().toHexString(),
+                                                    date: new Date(),
+                                                    type: 'client-request',
+                                                    title: 'Client Request - Method',
+                                                    message: 'User: ' + ws['user'] + ', Type: ' + type + ', MessageId: ' + messageId + ', Method: ' + method,
+                                                    payload: JSON.stringify(data),
+                                                    method: method,
+                                                    user: ws['user'],
+                                                    messageId: messageId
+                                                });
+                                            }
+                                            else {
+                                                log_collection_1.Logs.create({
+                                                    _id: mongoose_1.Types.ObjectId().toHexString(),
+                                                    date: new Date(),
+                                                    type: 'client-request',
+                                                    title: 'Client Request - Method',
+                                                    message: 'User: ' + ws['user'] + ', Type: ' + type + ', MessageId: ' + messageId + ', Method: ' + method,
+                                                    payload: 'Too Big',
+                                                    method: method,
+                                                    user: ws['user'],
+                                                    messageId: messageId
+                                                });
+                                            }
+                                        }
+                                        serverRes = {
+                                            messageId: messageId,
+                                            hasError: false,
+                                            data: 'ACK'
+                                        };
+                                        if (ws && ws.readyState === ws.OPEN) {
+                                            ws.send(JSON.stringify(serverRes), function (error) {
+                                                if (error) {
+                                                    console.log('Error on WS: ', error);
+                                                    _this.unsubscribeWS(ws);
+                                                }
+                                            });
+                                        }
+                                        if (!this_1._methodManager._methods[method]) return [3 /*break*/, 5];
+                                        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).exec()];
+                                    case 1:
+                                        methodCall = _c.sent();
+                                        if (!!methodCall) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, method_call_collection_1.MethodCalls.create({
+                                                _id: mongoose_1.Types.ObjectId().toHexString(),
+                                                __v: 0,
+                                                id_user: ws['id_user'],
+                                                message_id: messageId,
+                                                method: method,
+                                                date: messageDate
+                                            })];
+                                    case 2:
+                                        _c.sent();
+                                        if (this_1._methodManager._methods[method]) {
+                                            if (this_1._methodManager._methods[method].skipQueue) {
+                                                (_a = this_1._methodManager).callMethod.apply(_a, [ws, messageDate, messageId, method].concat(data));
+                                            }
+                                            else {
+                                                this_1._queueManager.addMethodToQueue(ws['id_socket'], ws['id_user'], ws['user'], messageDate, messageId, method, data);
+                                            }
+                                        }
+                                        else {
+                                            console.log('Could not find method: ' + method);
+                                        }
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        method_response_collection_1.MethodResponses.findOne({ $and: [
+                                                { id_user: ws['id_user'] },
+                                                { message_id: messageId },
+                                                { method: method },
+                                                { date: messageDate }
+                                            ] }).exec(function (err, 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);
+                                                        }
+                                                    });
+                                                }
+                                            }
+                                        });
+                                        _c.label = 4;
+                                    case 4: return [3 /*break*/, 6];
+                                    case 5:
+                                        console.log('Could not find method: ' + method);
+                                        _c.label = 6;
+                                    case 6: return [3 /*break*/, 8];
+                                    case 7:
+                                        if (type === 'methodRetry') {
+                                            method = data.shift();
+                                            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') {
+                                                if (common_1.getBinarySize(JSON.stringify(data)) < 200000) {
+                                                    log_collection_1.Logs.create({
+                                                        _id: mongoose_1.Types.ObjectId().toHexString(),
+                                                        date: new Date(),
+                                                        type: 'client-request',
+                                                        title: 'Client Request - Method Retry',
+                                                        message: 'User: ' + ws['user'] + ', Type: ' + type + ', MessageId: ' + messageId + ', Method: ' + method,
+                                                        payload: JSON.stringify(data),
+                                                        method: method,
+                                                        user: ws['user'],
+                                                        messageId: messageId
+                                                    });
+                                                }
+                                                else {
+                                                    log_collection_1.Logs.create({
+                                                        _id: mongoose_1.Types.ObjectId().toHexString(),
+                                                        date: new Date(),
+                                                        type: 'client-request',
+                                                        title: 'Client Request - Method Retry',
+                                                        message: 'User: ' + ws['user'] + ', Type: ' + type + ', MessageId: ' + messageId + ', Method: ' + method,
+                                                        payload: 'Too Big',
+                                                        method: method,
+                                                        user: ws['user'],
+                                                        messageId: messageId
+                                                    });
+                                                }
+                                            }
+                                            method_call_collection_1.MethodCalls.findOne({ $and: [
+                                                    { id_user: ws['id_user'] },
+                                                    { message_id: messageId },
+                                                    { method: method },
+                                                    { date: messageDate }
+                                                ] }).exec(function (err, res) {
+                                                if (res) {
+                                                    var serverRes = {
+                                                        messageId: messageId,
+                                                        hasError: false,
+                                                        data: 'ACK'
+                                                    };
+                                                    if (ws && ws.readyState === ws.OPEN) {
+                                                        ws.send(JSON.stringify(serverRes), function (error) {
+                                                            if (error) {
+                                                                console.log('Error on WS: ', error);
+                                                                _this.unsubscribeWS(ws);
+                                                            }
+                                                        });
+                                                    }
+                                                }
+                                                else {
+                                                    var serverRes = {
+                                                        messageId: messageId,
+                                                        hasError: false,
+                                                        data: 'NACK'
+                                                    };
+                                                    if (ws && ws.readyState === ws.OPEN) {
+                                                        ws.send(JSON.stringify(serverRes), function (error) {
+                                                            if (error) {
+                                                                console.log('Error on WS: ', error);
+                                                                _this.unsubscribeWS(ws);
+                                                            }
+                                                        });
+                                                    }
+                                                }
+                                            });
+                                        }
+                                        else if (type === 'methodResponse') {
+                                            method = data.shift();
+                                            method_response_collection_1.MethodResponses.findOne({ $and: [
+                                                    { id_user: ws['id_user'] },
+                                                    { message_id: messageId },
+                                                    { method: method },
+                                                    { date: messageDate }
+                                                ] }).exec(function (err, 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);
+                                                            }
+                                                        });
+                                                    }
+                                                }
+                                            });
+                                        }
+                                        else if (type === 'support') {
+                                            supportMethod = data.shift();
+                                            if (common_1.getBinarySize(JSON.stringify(data)) < 200000) {
+                                                log_collection_1.Logs.create({
+                                                    _id: mongoose_1.Types.ObjectId().toHexString(),
+                                                    date: new Date(),
+                                                    type: 'client-request',
+                                                    title: 'Client Request - Support',
+                                                    message: 'User: ' + ws['user'] + ', Type: ' + type + ', MessageId: ' + messageId + ', Support Method: ' + supportMethod,
+                                                    payload: JSON.stringify(data),
+                                                    method: supportMethod,
+                                                    user: ws['user'],
+                                                    messageId: messageId
+                                                });
+                                            }
+                                            else {
+                                                log_collection_1.Logs.create({
+                                                    _id: mongoose_1.Types.ObjectId().toHexString(),
+                                                    date: new Date(),
+                                                    type: 'client-request',
+                                                    title: 'Client Request - Support',
+                                                    message: 'User: ' + ws['user'] + ', Type: ' + type + ', MessageId: ' + messageId + ', Support Method: ' + supportMethod,
+                                                    payload: 'Too Big',
+                                                    method: supportMethod,
+                                                    user: ws['user'],
+                                                    messageId: messageId
+                                                });
+                                            }
+                                            serverRes = {
+                                                messageId: messageId,
+                                                hasError: false,
+                                                data: 'ACK'
+                                            };
+                                            if (ws && ws.readyState === ws.OPEN) {
+                                                ws.send(JSON.stringify(serverRes), function (error) {
+                                                    if (error) {
+                                                        console.log('Error on WS: ', error);
+                                                        _this.unsubscribeWS(ws);
+                                                    }
+                                                });
+                                            }
+                                            if (this_1._supportManager._supportMethods[supportMethod]) {
+                                                (_b = this_1._supportManager).callSupportMethod.apply(_b, [ws, messageId, supportMethod].concat(data));
+                                            }
+                                            else {
+                                                console.log('Could not find support method: ' + supportMethod);
+                                            }
+                                        }
+                                        _c.label = 8;
+                                    case 8: 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*/];
+                }
+            });
+        }); }, 25);
+    };
+    ResolveIOMainServer.prototype.unsubscribeWS = function (ws) {
+        this._subscriptionManager.unsubscribeAll(ws);
+    };
+    return ResolveIOMainServer;
+}());
+exports.default = ResolveIOMainServer;

package/support-methods/aws.d.ts

@@ -0,0 +1,2 @@
+import { SupportManager } from '../managers/support.manager';
+export declare function loadAWSMethods(supportManager: SupportManager): void;