@resolveio/server-lib 9.0.34 → 9.0.36

package/methods/flags.js

@@ -1,5 +1,9 @@
-export function loadFlagMethods(methodManager) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFlagMethods = void 0;
+function loadFlagMethods(methodManager) {
     methodManager.methods({});
 }
+exports.loadFlagMethods = loadFlagMethods;
 
 //# sourceMappingURL=flags.js.map

package/methods/flags.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/methods/flags.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,eAAe,CAAC,aAA4B;IAC3D,aAAa,CAAC,OAAO,CAAC,EAErB,CAAC,CAAC;AACJ,CAAC","file":"flags.js","sourcesContent":["import { MethodManager } from '../managers/method.manager';\n\nexport function loadFlagMethods(methodManager: MethodManager) {\n\tmethodManager.methods({\n\t\t\n\t});\n}"]}
+{"version":3,"sources":["../../src/methods/flags.ts"],"names":[],"mappings":";;;AAEA,SAAgB,eAAe,CAAC,aAA4B;IAC3D,aAAa,CAAC,OAAO,CAAC,EAErB,CAAC,CAAC;AACJ,CAAC;AAJD,0CAIC","file":"flags.js","sourcesContent":["import { MethodManager } from '../managers/method.manager';\n\nexport function loadFlagMethods(methodManager: MethodManager) {\n\tmethodManager.methods({\n\t\t\n\t});\n}"]}

package/methods/logs.js

@@ -1,16 +1,55 @@
-import { Logs } from '../collections/log.collection';
-import { LogSubscriptions } from '../collections/log-subscription.collection';
-import { ResolveIOServer } from '../index';
-import { LogMethodLatencies } from '../collections/log-method-latency.collection';
-import { objectIdHexString } from '../managers/mongo.manager';
-export function loadLogMethods(methodManager) {
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadLogMethods = void 0;
+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");
+var mongo_manager_1 = require("../managers/mongo.manager");
+function loadLogMethods(methodManager) {
     methodManager.methods({
         insertErrorLog: {
             skipQueue: true,
             function: function (message, data) {
-                this.sendEmail('dev@resolveio.com', 'Error Detected - ' + ResolveIOServer.getClientName(), this.user + '\n' + message + '\n' + JSON.stringify(data, null, 2));
-                return Logs.create({
-                    _id: objectIdHexString(),
+                this.sendEmail('dev@resolveio.com', 'Error Detected - ' + index_1.ResolveIOServer.getClientName(), this.user + '\n' + message + '\n' + JSON.stringify(data, null, 2));
+                return log_collection_1.Logs.create({
+                    _id: mongo_manager_1.objectIdHexString(),
                     type: 'error',
                     collection: '',
                     id_document: '',
@@ -27,8 +66,8 @@ export function loadLogMethods(methodManager) {
         insertSubscriptionLog: {
             skipQueue: true,
             function: function (type, subscription, collection_name, subData) {
-                return LogSubscriptions.create({
-                    _id: objectIdHexString(),
+                return log_subscription_collection_1.LogSubscriptions.create({
+                    _id: mongo_manager_1.objectIdHexString(),
                     __v: 0,
                     date: new Date(),
                     type: type,
@@ -42,8 +81,8 @@ export function loadLogMethods(methodManager) {
         insertMethodLatencyLog: {
             skipQueue: true,
             function: function (method) {
-                return LogMethodLatencies.create({
-                    _id: objectIdHexString(),
+                return log_method_latency_collection_1.LogMethodLatencies.create({
+                    _id: mongo_manager_1.objectIdHexString(),
                     __v: 0,
                     date_start: new Date(),
                     date_end: null,
@@ -56,265 +95,281 @@ export function loadLogMethods(methodManager) {
         superadminAPM: {
             skipQueue: true,
             function: function (date_start, date_end, graphInterval) {
-                return new Promise(async (resolve, reject) => {
-                    let latencies = await LogMethodLatencies.aggregate([
-                        {
-                            $match: {
-                                $and: [
+                var _this = this;
+                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                    var latencies, subscriptions, groupId, groupSort, methodGraphData, subGraphData;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, log_method_latency_collection_1.LogMethodLatencies.aggregate([
                                     {
-                                        createdAt: { $gte: date_start }
+                                        $match: {
+                                            $and: [
+                                                {
+                                                    createdAt: { $gte: date_start }
+                                                },
+                                                {
+                                                    createdAt: { $lte: date_end }
+                                                }
+                                            ]
+                                        }
                                     },
                                     {
-                                        createdAt: { $lte: date_end }
+                                        $group: {
+                                            _id: '$method',
+                                            method: { $first: '$method' },
+                                            count: { $sum: 1 },
+                                            latency_min: { $min: '$latency_ms' },
+                                            latency_avg: { $avg: '$latency_ms' },
+                                            latency_max: { $max: '$latency_ms' }
+                                        }
                                     }
-                                ]
-                            }
-                        },
-                        {
-                            $group: {
-                                _id: '$method',
-                                method: { $first: '$method' },
-                                count: { $sum: 1 },
-                                latency_min: { $min: '$latency_ms' },
-                                latency_avg: { $avg: '$latency_ms' },
-                                latency_max: { $max: '$latency_ms' }
-                            }
-                        }
-                    ], { allowDiskUse: true });
-                    let subscriptions = await LogSubscriptions.aggregate([
-                        {
-                            $match: {
-                                $and: [
-                                    {
-                                        createdAt: { $gte: date_start }
-                                    },
-                                    {
-                                        createdAt: { $lte: date_end }
-                                    }
-                                ]
-                            }
-                        },
-                        {
-                            $group: {
-                                _id: '$subscription',
-                                subscription: { $first: '$subscription' },
-                                count: { $sum: 1 }
-                            }
-                        }
-                    ], { allowDiskUse: true });
-                    let groupId = {};
-                    let groupSort = {};
-                    if (graphInterval === 'seconds') {
-                        groupId = {
-                            second: {
-                                $second: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            minute: {
-                                $minute: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            hour: {
-                                $hour: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            day: {
-                                $dayOfMonth: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            month: {
-                                $month: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            year: {
-                                $year: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            }
-                        };
-                        groupSort = {
-                            '_id.year': 1,
-                            '_id.month': 1,
-                            '_id.day': 1,
-                            '_id.hour': 1,
-                            '_id.minute': 1,
-                            '_id.second': 1
-                        };
-                    }
-                    else if (graphInterval === 'minutes') {
-                        groupId = {
-                            minute: {
-                                $minute: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            hour: {
-                                $hour: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            day: {
-                                $dayOfMonth: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            month: {
-                                $month: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            year: {
-                                $year: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
+                                ], { allowDiskUse: true })];
+                            case 1:
+                                latencies = _a.sent();
+                                return [4 /*yield*/, log_subscription_collection_1.LogSubscriptions.aggregate([
+                                        {
+                                            $match: {
+                                                $and: [
+                                                    {
+                                                        createdAt: { $gte: date_start }
+                                                    },
+                                                    {
+                                                        createdAt: { $lte: date_end }
+                                                    }
+                                                ]
+                                            }
+                                        },
+                                        {
+                                            $group: {
+                                                _id: '$subscription',
+                                                subscription: { $first: '$subscription' },
+                                                count: { $sum: 1 }
+                                            }
+                                        }
+                                    ], { allowDiskUse: true })];
+                            case 2:
+                                subscriptions = _a.sent();
+                                groupId = {};
+                                groupSort = {};
+                                if (graphInterval === 'seconds') {
+                                    groupId = {
+                                        second: {
+                                            $second: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        minute: {
+                                            $minute: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        hour: {
+                                            $hour: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        day: {
+                                            $dayOfMonth: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        month: {
+                                            $month: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        year: {
+                                            $year: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        }
+                                    };
+                                    groupSort = {
+                                        '_id.year': 1,
+                                        '_id.month': 1,
+                                        '_id.day': 1,
+                                        '_id.hour': 1,
+                                        '_id.minute': 1,
+                                        '_id.second': 1
+                                    };
                                 }
-                            }
-                        };
-                        groupSort = {
-                            '_id.year': 1,
-                            '_id.month': 1,
-                            '_id.day': 1,
-                            '_id.hour': 1,
-                            '_id.minute': 1
-                        };
-                    }
-                    else if (graphInterval === 'hours') {
-                        groupId = {
-                            hour: {
-                                $hour: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
+                                else if (graphInterval === 'minutes') {
+                                    groupId = {
+                                        minute: {
+                                            $minute: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        hour: {
+                                            $hour: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        day: {
+                                            $dayOfMonth: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        month: {
+                                            $month: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        year: {
+                                            $year: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        }
+                                    };
+                                    groupSort = {
+                                        '_id.year': 1,
+                                        '_id.month': 1,
+                                        '_id.day': 1,
+                                        '_id.hour': 1,
+                                        '_id.minute': 1
+                                    };
                                 }
-                            },
-                            day: {
-                                $dayOfMonth: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
+                                else if (graphInterval === 'hours') {
+                                    groupId = {
+                                        hour: {
+                                            $hour: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        day: {
+                                            $dayOfMonth: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        month: {
+                                            $month: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        year: {
+                                            $year: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        }
+                                    };
+                                    groupSort = {
+                                        '_id.year': 1,
+                                        '_id.month': 1,
+                                        '_id.day': 1,
+                                        '_id.hour': 1
+                                    };
                                 }
-                            },
-                            month: {
-                                $month: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
+                                else {
+                                    groupId = {
+                                        day: {
+                                            $dayOfMonth: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        month: {
+                                            $month: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        year: {
+                                            $year: {
+                                                date: '$createdAt',
+                                                timezone: "America/Chicago"
+                                            }
+                                        }
+                                    };
+                                    groupSort = {
+                                        '_id.year': 1,
+                                        '_id.month': 1,
+                                        '_id.day': 1
+                                    };
                                 }
-                            },
-                            year: {
-                                $year: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            }
-                        };
-                        groupSort = {
-                            '_id.year': 1,
-                            '_id.month': 1,
-                            '_id.day': 1,
-                            '_id.hour': 1
-                        };
-                    }
-                    else {
-                        groupId = {
-                            day: {
-                                $dayOfMonth: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            month: {
-                                $month: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            year: {
-                                $year: {
-                                    date: '$createdAt',
-                                    timezone: "America/Chicago"
-                                }
-                            }
-                        };
-                        groupSort = {
-                            '_id.year': 1,
-                            '_id.month': 1,
-                            '_id.day': 1
-                        };
-                    }
-                    let methodGraphData = await LogMethodLatencies.aggregate([
-                        {
-                            $match: {
-                                $and: [
-                                    {
-                                        createdAt: { $gte: date_start }
-                                    },
-                                    {
-                                        createdAt: { $lte: date_end }
-                                    }
-                                ]
-                            }
-                        },
-                        {
-                            $group: {
-                                _id: groupId,
-                                count: {
-                                    $sum: 1
-                                }
-                            }
-                        },
-                        {
-                            $sort: groupSort
-                        }
-                    ], { allowDiskUse: true });
-                    let subGraphData = await LogSubscriptions.aggregate([
-                        {
-                            $match: {
-                                $and: [
-                                    {
-                                        createdAt: { $gte: date_start }
-                                    },
-                                    {
-                                        createdAt: { $lte: date_end }
-                                    }
-                                ]
-                            }
-                        },
-                        {
-                            $group: {
-                                _id: groupId,
-                                count: {
-                                    $sum: 1
-                                }
-                            }
-                        },
-                        {
-                            $sort: groupSort
+                                return [4 /*yield*/, log_method_latency_collection_1.LogMethodLatencies.aggregate([
+                                        {
+                                            $match: {
+                                                $and: [
+                                                    {
+                                                        createdAt: { $gte: date_start }
+                                                    },
+                                                    {
+                                                        createdAt: { $lte: date_end }
+                                                    }
+                                                ]
+                                            }
+                                        },
+                                        {
+                                            $group: {
+                                                _id: groupId,
+                                                count: {
+                                                    $sum: 1
+                                                }
+                                            }
+                                        },
+                                        {
+                                            $sort: groupSort
+                                        }
+                                    ], { allowDiskUse: true })];
+                            case 3:
+                                methodGraphData = _a.sent();
+                                return [4 /*yield*/, log_subscription_collection_1.LogSubscriptions.aggregate([
+                                        {
+                                            $match: {
+                                                $and: [
+                                                    {
+                                                        createdAt: { $gte: date_start }
+                                                    },
+                                                    {
+                                                        createdAt: { $lte: date_end }
+                                                    }
+                                                ]
+                                            }
+                                        },
+                                        {
+                                            $group: {
+                                                _id: groupId,
+                                                count: {
+                                                    $sum: 1
+                                                }
+                                            }
+                                        },
+                                        {
+                                            $sort: groupSort
+                                        }
+                                    ], { allowDiskUse: true })];
+                            case 4:
+                                subGraphData = _a.sent();
+                                resolve({
+                                    methods: latencies,
+                                    subscriptions: subscriptions,
+                                    methodGraphData: methodGraphData,
+                                    subGraphData: subGraphData
+                                });
+                                return [2 /*return*/];
                         }
-                    ], { allowDiskUse: true });
-                    resolve({
-                        methods: latencies,
-                        subscriptions: subscriptions,
-                        methodGraphData: methodGraphData,
-                        subGraphData: subGraphData
                     });
-                });
+                }); });
             },
             skipValidation: true
         }
     });
 }
+exports.loadLogMethods = loadLogMethods;
 
 //# sourceMappingURL=logs.js.map