@resolveio/server-lib 4.0.21-newrole → 4.0.22

package/collections/log-method-latency.collection.d.ts

@@ -0,0 +1,7 @@
+import { Model, Document } from 'mongoose';
+import { LogMethodLatencyModel } from '../models/log-method-latency.model';
+interface ResolveIOModel extends LogMethodLatencyModel, Document {
+}
+export declare const LogMethodLatencies: Model<ResolveIOModel>;
+export declare const LogMethodLatencyVersions: Model<ResolveIOModel>;
+export {};

package/collections/log-method-latency.collection.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    date_start: {
+        type: Date
+    },
+    date_end: {
+        type: Date,
+        optional: true
+    },
+    latency_ms: {
+        type: Number
+    },
+    method: {
+        type: String
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+DefaultSchema.index({ createdAt: 1 }, { expireAfterSeconds: 60 * 60 * 24 * 30 });
+DefaultSchema.index({ latency_ms: 1 });
+DefaultSchema.index({ method: 1 });
+exports.LogMethodLatencies = index_1.ResolveIOServer.getMainDB().model('log-method-latencies', DefaultSchema);
+schema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.LogMethodLatencies['versionCollection'] = 'log-method-latencies.versions';
+exports.LogMethodLatencyVersions = index_1.ResolveIOServer.getMainDB().model(exports.LogMethodLatencies['versionCollection'], VersionSchema);

package/collections/queue-method.collection.js

@@ -55,6 +55,9 @@ var mongooseSchema = {
     },
     date: {
         type: Date
+    },
+    id_methodLatency: {
+        type: String
     }
 };
 var DefaultSchema = new mongoose_1.Schema(mongooseSchema, {

package/collections/user.collection.js

@@ -21,6 +21,13 @@ var schema = {
         type: Date,
         optional: true
     },
+    readonly: {
+        type: Boolean,
+        optional: true
+    },
+    active: {
+        type: Boolean
+    },
     attempts: {
         type: Number,
         optional: true
@@ -57,67 +64,53 @@ var schema = {
         type: String
     },
     roles: {
-        type: Object
-    },
-    'roles.super_admin': {
-        type: Boolean
-    },
-    'roles.approvals': {
         type: Array
     },
-    'roles.approvals.$': {
-        type: Object
-    },
-    'roles.approvals.$.name': {
+    'roles.$': {
         type: String
     },
-    'roles.approvals.$.type': {
-        type: String
+    phonenumber: {
+        type: String,
+        optional: true
     },
-    'roles.approvals.$.accounting_code': {
-        type: String
+    other: {
+        type: Object,
+        blackbox: true,
+        optional: true
     },
-    'roles.groups': {
-        type: Array
+    assets: {
+        type: Array,
+        optional: true
     },
-    'roles.groups.$': {
+    'assets.$': {
         type: Object
     },
-    'roles.groups.$.name': {
+    'assets.$.type': {
         type: String
     },
-    'roles.groups.$.views': {
-        type: Array
-    },
-    'roles.groups.$.views.$': {
+    'assets.$.id_asset': {
         type: String
     },
-    'roles.groups.$.yard': {
-        type: String,
-        optional: true
+    'assets.$.asset_number': {
+        type: String
     },
-    'roles.notifications': {
-        type: Array
+    'assets.$.ownership': {
+        type: String
     },
-    'roles.notifications.$': {
+    'assets.$.ownership_driver': {
         type: String
     },
-    'roles.miscs': {
-        type: Array
+    'assets.$.date_start': {
+        type: Date
     },
-    'roles.miscs.$': {
-        type: String
+    'assets.$.date_end': {
+        type: Date,
+        optional: true
     },
-    active: Boolean,
-    phonenumber: {
+    id_function: {
         type: String,
         optional: true
     },
-    other: {
-        type: Object,
-        optional: true,
-        blackbox: true
-    },
     customers: {
         type: Array,
         optional: true,

package/fixtures/init.js

@@ -37,8 +37,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var app_version_collection_1 = require("../collections/app-version.collection");
 var logged_in_users_collection_1 = require("../collections/logged-in-users.collection");
-var mongoose_1 = require("mongoose");
 var active_subscription_collection_1 = require("../collections/active-subscription.collection");
+var mongoose_1 = require("mongoose");
 function loadServerInit() {
     return __awaiter(this, void 0, void 0, function () {
         var appVersion;

package/index.d.ts

@@ -8,7 +8,7 @@ export declare class ResolveIOServer {
     private static _clientDir;
     private static _dontRunSupport;
     constructor(serverConfig: any, client: string, clientDir: any, _dontRunSupport?: any);
-    static connectAndRun(): Promise<unknown>;
+    static connectAndRun(): Promise<{}>;
     static getClientName(): string;
     static getMainServer(): ResolveIOMainServer;
     static getMainDB(): any;

package/managers/method.manager.d.ts

@@ -16,13 +16,13 @@ export declare class MethodManager {
     getMainServer(): ResolveIOMainServer;
     methods(method: MethodModel): void;
     callMethodCron(method: string, ...methodData: any[]): void;
-    callMethodQueue(update: QueueMethodModel): Promise<unknown>;
-    callMethod(ws: WebSocket, messageDate: Date, messageId: number, method: string, ...methodData: any[]): void;
+    callMethodQueue(update: QueueMethodModel): Promise<{}>;
+    callMethod(id_methodLatency: string, ws: WebSocket, messageDate: Date, messageId: number, method: string, ...methodData: any[]): void;
     callMethodInternal(method: any, ...methodData: any[]): Promise<any>;
     callSupportMethodInternal(supportMethod: any, ...methodData: any[]): Promise<any>;
     private sendWS;
     sendEmail(sendTo: string, subject: string, text?: string, html?: string, attachments?: any[], send_from?: string): void;
     getAWS(): aws.S3;
-    readFile(fileName: any): Promise<unknown>;
-    readImage(fileName: any): Promise<unknown>;
+    readFile(fileName: any): Promise<{}>;
+    readImage(fileName: any): Promise<{}>;
 }

package/managers/method.manager.js

@@ -1,4 +1,39 @@
 "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 collections_1 = require("../methods/collections");
 var logs_1 = require("../methods/logs");
@@ -20,6 +55,8 @@ var mongoose_1 = require("mongoose");
 var common_1 = require("../util/common");
 var log_collection_1 = require("../collections/log.collection");
 var support_manager_1 = require("./support.manager");
+var log_method_latency_collection_1 = require("../collections/log-method-latency.collection");
+var moment = require("moment");
 var MethodManager = /** @class */ (function () {
     function MethodManager(mainServer, serverConfig, clientDir) {
         var _this = this;
@@ -282,6 +319,7 @@ var MethodManager = /** @class */ (function () {
                     data: 'Internal Error'
                 };
                 _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                 return resolve('No Method: ' + update.method);
             }
             if ((update.method_data.length > 1 || update.method_data[0]) && !that._methods[update.method].skipValidation) {
@@ -294,6 +332,7 @@ var MethodManager = /** @class */ (function () {
                         data: 'Internal Error'
                     };
                     _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                    log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                     return resolve('No Check Function For Method ' + update.method);
                 }
                 else if (!that._methods[update.method].check._schema) {
@@ -305,6 +344,7 @@ var MethodManager = /** @class */ (function () {
                         data: 'Internal Error'
                     };
                     _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                    log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                     return resolve('No Check Schema For Method ' + update.method);
                 }
                 else {
@@ -327,6 +367,7 @@ var MethodManager = /** @class */ (function () {
                                 data: 'Internal Error'
                             };
                             _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                             return resolve('Error in Method Check (' + update.method + ')');
                         }
                     }
@@ -338,16 +379,29 @@ var MethodManager = /** @class */ (function () {
                 resolve('Timeout');
             }, 5000);
             // console.log('Run Method', update.method);
-            (_a = that._methods[update.method].function).call.apply(_a, [Object.assign({}, that, MethodManager.prototype, { id_user: update.id_user, user: update.user, id_ws: update.id_ws })].concat(update.method_data)).then(function (res) {
-                var serverRes = {
-                    messageId: update.messageId,
-                    hasError: false,
-                    data: res
-                };
-                _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                clearTimeout(timeout);
-                resolve(serverRes);
-            }, function (err) {
+            (_a = that._methods[update.method].function).call.apply(_a, [Object.assign({}, that, MethodManager.prototype, { id_user: update.id_user, user: update.user, id_ws: update.id_ws })].concat(update.method_data)).then(function (res) { return __awaiter(_this, void 0, void 0, function () {
+                var serverRes, latency;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            serverRes = {
+                                messageId: update.messageId,
+                                hasError: false,
+                                data: res
+                            };
+                            this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                            clearTimeout(timeout);
+                            return [4 /*yield*/, log_method_latency_collection_1.LogMethodLatencies.findById(update.id_methodLatency)];
+                        case 1:
+                            latency = _a.sent();
+                            if (latency) {
+                                log_method_latency_collection_1.LogMethodLatencies.updateOne({ _id: update.id_methodLatency }, { $set: { date_end: new Date(), latency_ms: moment().diff(moment(latency.date_start), 'milliseconds', true) } });
+                            }
+                            resolve(serverRes);
+                            return [2 /*return*/];
+                    }
+                });
+            }); }, function (err) {
                 var serverRes = {
                     messageId: update.messageId,
                     hasError: true,
@@ -355,17 +409,18 @@ var MethodManager = /** @class */ (function () {
                 };
                 _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
                 clearTimeout(timeout);
+                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                 resolve(serverRes);
             });
         });
     };
     // Call/run method (Emit on Socket)
-    MethodManager.prototype.callMethod = function (ws, messageDate, messageId, method) {
-        var _a;
+    MethodManager.prototype.callMethod = function (id_methodLatency, ws, messageDate, messageId, method) {
         var _this = this;
+        var _a;
         var methodData = [];
-        for (var _i = 4; _i < arguments.length; _i++) {
-            methodData[_i - 4] = arguments[_i];
+        for (var _i = 5; _i < arguments.length; _i++) {
+            methodData[_i - 5] = arguments[_i];
         }
         var that = this;
         if (!that._methods[method]) {
@@ -377,6 +432,7 @@ var MethodManager = /** @class */ (function () {
                 data: 'Internal Error'
             };
             this.sendWS(ws, messageDate, method, methodData, serverRes);
+            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
             return;
         }
         if ((methodData.length > 1 || methodData[0]) && !that._methods[method].skipValidation) {
@@ -389,6 +445,7 @@ var MethodManager = /** @class */ (function () {
                     data: 'Internal Error'
                 };
                 this.sendWS(ws, messageDate, method, methodData, serverRes);
+                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
                 return;
             }
             else if (!that._methods[method].check._schema) {
@@ -399,6 +456,7 @@ var MethodManager = /** @class */ (function () {
                     hasError: true,
                     data: 'Internal Error'
                 };
+                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
                 this.sendWS(ws, messageDate, method, methodData, serverRes);
                 return;
             }
@@ -422,25 +480,40 @@ var MethodManager = /** @class */ (function () {
                             data: 'Internal Error'
                         };
                         this.sendWS(ws, messageDate, method, methodData, serverRes);
+                        log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
                         return;
                     }
                 }
             }
         }
-        (_a = that._methods[method].function).call.apply(_a, [Object.assign({}, that, MethodManager.prototype, { id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket'] })].concat(methodData)).then(function (res) {
-            var serverRes = {
-                messageId: messageId,
-                hasError: false,
-                data: res
-            };
-            _this.sendWS(ws, messageDate, method, methodData, serverRes);
-        }, function (err) {
+        (_a = that._methods[method].function).call.apply(_a, [Object.assign({}, that, MethodManager.prototype, { id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket'] })].concat(methodData)).then(function (res) { return __awaiter(_this, void 0, void 0, function () {
+            var serverRes, latency;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: res
+                        };
+                        this.sendWS(ws, messageDate, method, methodData, serverRes);
+                        return [4 /*yield*/, log_method_latency_collection_1.LogMethodLatencies.findById(id_methodLatency)];
+                    case 1:
+                        latency = _a.sent();
+                        if (latency) {
+                            log_method_latency_collection_1.LogMethodLatencies.updateOne({ _id: id_methodLatency }, { $set: { date_end: new Date(), latency_ms: moment().diff(moment(latency.date_start), 'milliseconds', true) } });
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); }, function (err) {
             var serverRes = {
                 messageId: messageId,
                 hasError: true,
                 data: err
             };
             _this.sendWS(ws, messageDate, method, methodData, serverRes);
+            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
         });
     };
     // Call/run method internal (No Emit on Socket)

package/managers/queue-method.manager.d.ts

@@ -6,7 +6,7 @@ export declare class QueueMethodManager {
     private _runningQueue;
     private _runningMethodResponse;
     constructor(mainServer: any);
-    addMethodToQueue(id_ws: string, id_user: string, user: string, messageDate: Date, messageId: string, method: string, data: any[]): void;
+    addMethodToQueue(id_methodLatency: string, id_ws: string, id_user: string, user: string, messageDate: Date, messageId: string, method: string, data: any[]): void;
     runMethodQueue(count?: number): Promise<void>;
     addMethodResponse(update: QueueMethodModel, response: ServerResponseModel): void;
     runMethodResponse(): Promise<void>;

package/managers/queue-method.manager.js

@@ -111,7 +111,7 @@ var QueueMethodManager = /** @class */ (function () {
             }
         }, 25);
     }
-    QueueMethodManager.prototype.addMethodToQueue = function (id_ws, id_user, user, messageDate, messageId, method, data) {
+    QueueMethodManager.prototype.addMethodToQueue = function (id_methodLatency, id_ws, id_user, user, messageDate, messageId, method, data) {
         // console.log('Add Method To Queue', method);
         queue_method_collection_1.QueueMethods.create({
             _id: mongoose_1.Types.ObjectId().toHexString(),
@@ -122,7 +122,8 @@ var QueueMethodManager = /** @class */ (function () {
             method_data: data,
             id_user: id_user,
             user: user,
-            date: messageDate
+            date: messageDate,
+            id_methodLatency: id_methodLatency
         });
     };
     QueueMethodManager.prototype.runMethodQueue = function (count) {

package/managers/subscription.manager.js

@@ -136,8 +136,7 @@ var SubscriptionManager = /** @class */ (function () {
             subscriptionData[_i - 3] = arguments[_i];
         }
         return __awaiter(this, void 0, void 0, function () {
-            var that, pub, valObj, valKeys, rootKeys, i, sub, _a, newActiveSub, begDate, endDate, billUser;
-            var _b;
+            var _a, that, pub, valObj, valKeys, rootKeys, i, sub, _b, newActiveSub, begDate, endDate, billUser;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -202,10 +201,10 @@ var SubscriptionManager = /** @class */ (function () {
                         // Send pub data to client who just subscribed only, don't want to send to existing clients since nothing has changed
                         that.sendPubDataOnce(ws, messageId, sub, 'newSub', that.getPublicationCollections(publication)[0]);
                         if (!(that._publications[sub.publication].preFunction && !sub.preSubscriptionData)) return [3 /*break*/, 3];
-                        _a = sub;
-                        return [4 /*yield*/, (_b = that._publications[sub.publication]).preFunction.apply(_b, sub.subscriptionData)];
+                        _b = sub;
+                        return [4 /*yield*/, (_a = that._publications[sub.publication]).preFunction.apply(_a, sub.subscriptionData)];
                     case 2:
-                        _a.preSubscriptionData = _c.sent();
+                        _b.preSubscriptionData = _c.sent();
                         _c.label = 3;
                     case 3:
                         newActiveSub = new active_subscription_collection_1.ActiveSubscriptions({
@@ -557,8 +556,7 @@ var SubscriptionManager = /** @class */ (function () {
         if (noFetchFunction === void 0) { noFetchFunction = false; }
         var that = this;
         that._subscriptions.filter(function (a) { return a.collections.includes(collection); }).forEach(function (sub) { return __awaiter(_this, void 0, void 0, function () {
-            var schemaErrors, _a, _b;
-            var _c, _d;
+            var _a, _b, schemaErrors, _c, _d;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
@@ -578,18 +576,18 @@ var SubscriptionManager = /** @class */ (function () {
                         if (!sub.preSubscriptionData) return [3 /*break*/, 4];
                         if (!that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) return [3 /*break*/, 4];
                         that.sendPubData(sub, type, collection);
-                        _a = sub;
-                        return [4 /*yield*/, (_c = that._publications[sub.publication]).preFunction.apply(_c, sub.subscriptionData)];
+                        _c = sub;
+                        return [4 /*yield*/, (_a = that._publications[sub.publication]).preFunction.apply(_a, sub.subscriptionData)];
                     case 3:
-                        _a.preSubscriptionData = _e.sent();
+                        _c.preSubscriptionData = _e.sent();
                         return [2 /*return*/];
                     case 4:
                         if (!that._publications[sub.publication].preFunction) return [3 /*break*/, 7];
                         if (!!noFetchFunction) return [3 /*break*/, 6];
-                        _b = sub;
+                        _d = sub;
                         return [4 /*yield*/, that._publications[sub.publication].preFunction(sub.subscriptionData)];
                     case 5:
-                        _b.preSubscriptionData = _e.sent();
+                        _d.preSubscriptionData = _e.sent();
                         if (that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) {
                             that.sendPubData(sub, type, collection);
                         }
@@ -622,7 +620,7 @@ var SubscriptionManager = /** @class */ (function () {
                         else {
                             if (that._publications[sub.publication].fetchFunction) {
                                 if (!noFetchFunction) {
-                                    if ((_d = that._publications[sub.publication]).fetchFunction.apply(_d, [document].concat(sub.subscriptionData))) {
+                                    if ((_b = that._publications[sub.publication]).fetchFunction.apply(_b, [document].concat(sub.subscriptionData))) {
                                         that.sendPubData(sub, type, collection);
                                     }
                                 }
@@ -641,8 +639,7 @@ var SubscriptionManager = /** @class */ (function () {
         var _this = this;
         var that = this;
         that._subscriptions.filter(function (a) { return a.collections.includes(collection); }).forEach(function (sub) { return __awaiter(_this, void 0, void 0, function () {
-            var schemaErrors, _a, _b;
-            var _c, _d, _e;
+            var _a, _b, _c, schemaErrors, _d, _e;
             return __generator(this, function (_f) {
                 switch (_f.label) {
                     case 0:
@@ -662,17 +659,17 @@ var SubscriptionManager = /** @class */ (function () {
                         if (!sub.preSubscriptionData) return [3 /*break*/, 4];
                         if (!that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) return [3 /*break*/, 4];
                         that.sendPubData(sub, 'support', collection);
-                        _a = sub;
-                        return [4 /*yield*/, (_c = that._publications[sub.publication]).preFunction.apply(_c, sub.subscriptionData)];
+                        _d = sub;
+                        return [4 /*yield*/, (_a = that._publications[sub.publication]).preFunction.apply(_a, sub.subscriptionData)];
                     case 3:
-                        _a.preSubscriptionData = _f.sent();
+                        _d.preSubscriptionData = _f.sent();
                         return [2 /*return*/];
                     case 4:
                         if (!that._publications[sub.publication].preFunction) return [3 /*break*/, 6];
-                        _b = sub;
-                        return [4 /*yield*/, (_d = that._publications[sub.publication]).preFunction.apply(_d, sub.subscriptionData)];
+                        _e = sub;
+                        return [4 /*yield*/, (_b = that._publications[sub.publication]).preFunction.apply(_b, sub.subscriptionData)];
                     case 5:
-                        _b.preSubscriptionData = _f.sent();
+                        _e.preSubscriptionData = _f.sent();
                         if (that._publications[sub.publication].fetchFunction(document, sub.preSubscriptionData)) {
                             that.sendPubData(sub, 'support', collection);
                         }
@@ -701,7 +698,7 @@ var SubscriptionManager = /** @class */ (function () {
                         }
                         else {
                             if (that._publications[sub.publication].fetchFunction) {
-                                if ((_e = that._publications[sub.publication]).fetchFunction.apply(_e, [document].concat(sub.subscriptionData))) {
+                                if ((_c = that._publications[sub.publication]).fetchFunction.apply(_c, [document].concat(sub.subscriptionData))) {
                                     that.sendPubData(sub, 'support', collection);
                                 }
                             }
@@ -718,8 +715,7 @@ var SubscriptionManager = /** @class */ (function () {
     // Fetch pub once, send to all clients linked to this pub
     SubscriptionManager.prototype.sendPubDataOnce = function (ws, messageId, subscription, type, collection) {
         return __awaiter(this, void 0, void 0, function () {
-            var that;
-            var _a, _b;
+            var _a, _b, that;
             var _this = this;
             return __generator(this, function (_c) {
                 that = this;
@@ -765,8 +761,7 @@ var SubscriptionManager = /** @class */ (function () {
     // Fetch pub once, send to all clients linked to this pub
     SubscriptionManager.prototype.sendPubData = function (subscription, type, collection) {
         return __awaiter(this, void 0, void 0, function () {
-            var that;
-            var _a;
+            var _a, that;
             var _this = this;
             return __generator(this, function (_b) {
                 that = this;

package/managers/support.manager.d.ts

@@ -17,6 +17,6 @@ export declare class SupportManager {
     callMethodInternal(method: any, ...methodData: any[]): Promise<any>;
     private sendWS;
     sendEmail(sendTo: string, subject: string, text?: string, html?: string, attachments?: any[], from?: string): void;
-    readFile(fileName: any): Promise<unknown>;
-    readImage(fileName: any): Promise<unknown>;
+    readFile(fileName: any): Promise<{}>;
+    readImage(fileName: any): Promise<{}>;
 }

package/managers/support.manager.js

@@ -102,8 +102,8 @@ var SupportManager = /** @class */ (function () {
     };
     // Call/run method (Emit on Socket)
     SupportManager.prototype.callSupportMethod = function (ws, messageId, supportMethod) {
-        var _a;
         var _this = this;
+        var _a;
         var methodData = [];
         for (var _i = 3; _i < arguments.length; _i++) {
             methodData[_i - 3] = arguments[_i];

package/methods/logs.js

@@ -4,6 +4,7 @@ var mongoose_1 = require("mongoose");
 var log_collection_1 = require("../collections/log.collection");
 var log_subscription_collection_1 = require("../collections/log-subscription.collection");
 var index_1 = require("../index");
+var log_method_latency_collection_1 = require("../collections/log-method-latency.collection");
 function loadLogMethods(methodManager) {
     methodManager.methods({
         insertErrorLog: {
@@ -38,6 +39,20 @@ function loadLogMethods(methodManager) {
                 });
             },
             skipValidation: true
+        },
+        insertMethodLatencyLog: {
+            skipQueue: true,
+            function: function (method) {
+                return log_method_latency_collection_1.LogMethodLatencies.create({
+                    _id: mongoose_1.Types.ObjectId().toHexString(),
+                    __v: 0,
+                    date_start: new Date(),
+                    date_end: null,
+                    latency: 0,
+                    method: method
+                });
+            },
+            skipValidation: true
         }
     });
 }

package/models/log-method-latency.model.d.ts

@@ -0,0 +1,7 @@
+import { CollectionDocument } from './collection-document.model';
+export interface LogMethodLatencyModel extends CollectionDocument {
+    date_start: Date;
+    date_end?: Date;
+    latency_ms: number;
+    method: string;
+}

package/models/log-method-latency.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/models/queue-method.model.d.ts

@@ -7,4 +7,5 @@ export interface QueueMethodModel extends CollectionDocument {
     id_user: string;
     user: string;
     date: Date;
+    id_methodLatency: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "4.0.21-newrole",
+  "version": "4.0.22",
   "description": "",
   "main": "index.ts",
   "scripts": {

package/server-app.js

@@ -59,6 +59,7 @@ 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 log_method_latency_collection_1 = require("./collections/log-method-latency.collection");
 var ResolveIOMainServer = /** @class */ (function () {
     function ResolveIOMainServer(mainServer, serverConfig, clientDir) {
         this._msgQueue = [];
@@ -253,8 +254,7 @@ var ResolveIOMainServer = /** @class */ (function () {
             }, 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 _a, _b, socketData, data, messageDate, messageId, type, subType, pub;
                 var _this = this;
                 return __generator(this, function (_c) {
                     socketData = JSON.parse(message, common_1.dateReviver);
@@ -329,8 +329,7 @@ var ResolveIOMainServer = /** @class */ (function () {
                         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;
+                            var _a, _b, msg, data, ws, messageDate, messageId, type, method, methodLatency, serverRes, query, methodCall, supportMethod, serverRes;
                             return __generator(this, function (_c) {
                                 switch (_c.label) {
                                     case 0:
@@ -341,7 +340,7 @@ var ResolveIOMainServer = /** @class */ (function () {
                                         messageId = data.shift();
                                         type = data.shift();
                                         method = '';
-                                        if (!(type === 'method')) return [3 /*break*/, 7];
+                                        if (!(type === 'method')) return [3 /*break*/, 8];
                                         method = data.shift();
                                         if (method === 'setWSAppVersion') {
                                             clearTimeout(ws['versionTimer']);
@@ -355,6 +354,16 @@ var ResolveIOMainServer = /** @class */ (function () {
                                         if (ws['user_readonly']) {
                                             return [2 /*return*/, "continue"];
                                         }
+                                        return [4 /*yield*/, log_method_latency_collection_1.LogMethodLatencies.create({
+                                                _id: mongoose_1.Types.ObjectId().toHexString(),
+                                                __v: 0,
+                                                date_start: new Date(),
+                                                date_end: null,
+                                                latency_ms: 0,
+                                                method: method
+                                            })];
+                                    case 1:
+                                        methodLatency = _c.sent();
                                         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({
@@ -396,7 +405,7 @@ var ResolveIOMainServer = /** @class */ (function () {
                                                 }
                                             });
                                         }
-                                        if (!this_1._methodManager._methods[method]) return [3 /*break*/, 5];
+                                        if (!this_1._methodManager._methods[method]) return [3 /*break*/, 6];
                                         query = { $and: [
                                                 { id_user: ws['id_user'] },
                                                 { message_id: messageId },
@@ -424,9 +433,9 @@ var ResolveIOMainServer = /** @class */ (function () {
                                             }
                                         }
                                         return [4 /*yield*/, method_call_collection_1.MethodCalls.findOne(query).exec()];
-                                    case 1:
+                                    case 2:
                                         methodCall = _c.sent();
-                                        if (!!methodCall) return [3 /*break*/, 3];
+                                        if (!!methodCall) return [3 /*break*/, 4];
                                         return [4 /*yield*/, method_call_collection_1.MethodCalls.create({
                                                 _id: mongoose_1.Types.ObjectId().toHexString(),
                                                 __v: 0,
@@ -435,21 +444,21 @@ var ResolveIOMainServer = /** @class */ (function () {
                                                 method: method,
                                                 date: messageDate
                                             })];
-                                    case 2:
+                                    case 3:
                                         _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));
+                                                (_a = this_1._methodManager).callMethod.apply(_a, [methodLatency._id, ws, messageDate, messageId, method].concat(data));
                                             }
                                             else {
-                                                this_1._queueManager.addMethodToQueue(ws['id_socket'], ws['id_user'], ws['user'], messageDate, messageId, method, data);
+                                                this_1._queueManager.addMethodToQueue(methodLatency._id, 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:
+                                        return [3 /*break*/, 5];
+                                    case 4:
                                         method_response_collection_1.MethodResponses.findOne({ $and: [
                                                 { id_user: ws['id_user'] },
                                                 { message_id: messageId },
@@ -467,13 +476,13 @@ var ResolveIOMainServer = /** @class */ (function () {
                                                 }
                                             }
                                         });
-                                        _c.label = 4;
-                                    case 4: return [3 /*break*/, 6];
-                                    case 5:
+                                        _c.label = 5;
+                                    case 5: return [3 /*break*/, 7];
+                                    case 6:
                                         console.log('Could not find method: ' + method);
-                                        _c.label = 6;
-                                    case 6: return [3 /*break*/, 8];
-                                    case 7:
+                                        _c.label = 7;
+                                    case 7: return [3 /*break*/, 9];
+                                    case 8:
                                         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') {
@@ -610,8 +619,8 @@ var ResolveIOMainServer = /** @class */ (function () {
                                                 console.log('Could not find support method: ' + supportMethod);
                                             }
                                         }
-                                        _c.label = 8;
-                                    case 8: return [2 /*return*/];
+                                        _c.label = 9;
+                                    case 9: return [2 /*return*/];
                                 }
                             });
                         };