@resolveio/server-lib 9.0.32 → 9.0.34

package/methods/flags.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadFlagMethods = void 0;
-function loadFlagMethods(methodManager) {
+export 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,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}"]}
+{"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}"]}

package/methods/logs.js

@@ -1,55 +1,16 @@
-"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) {
+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) {
     methodManager.methods({
         insertErrorLog: {
             skipQueue: true,
             function: function (message, data) {
-                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(),
+                this.sendEmail('dev@resolveio.com', 'Error Detected - ' + ResolveIOServer.getClientName(), this.user + '\n' + message + '\n' + JSON.stringify(data, null, 2));
+                return Logs.create({
+                    _id: objectIdHexString(),
                     type: 'error',
                     collection: '',
                     id_document: '',
@@ -66,8 +27,8 @@ function loadLogMethods(methodManager) {
         insertSubscriptionLog: {
             skipQueue: true,
             function: function (type, subscription, collection_name, subData) {
-                return log_subscription_collection_1.LogSubscriptions.create({
-                    _id: mongo_manager_1.objectIdHexString(),
+                return LogSubscriptions.create({
+                    _id: objectIdHexString(),
                     __v: 0,
                     date: new Date(),
                     type: type,
@@ -81,8 +42,8 @@ function loadLogMethods(methodManager) {
         insertMethodLatencyLog: {
             skipQueue: true,
             function: function (method) {
-                return log_method_latency_collection_1.LogMethodLatencies.create({
-                    _id: mongo_manager_1.objectIdHexString(),
+                return LogMethodLatencies.create({
+                    _id: objectIdHexString(),
                     __v: 0,
                     date_start: new Date(),
                     date_end: null,
@@ -95,281 +56,265 @@ function loadLogMethods(methodManager) {
         superadminAPM: {
             skipQueue: true,
             function: function (date_start, date_end, graphInterval) {
-                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([
+                return new Promise(async (resolve, reject) => {
+                    let latencies = await LogMethodLatencies.aggregate([
+                        {
+                            $match: {
+                                $and: [
                                     {
-                                        $match: {
-                                            $and: [
-                                                {
-                                                    createdAt: { $gte: date_start }
-                                                },
-                                                {
-                                                    createdAt: { $lte: date_end }
-                                                }
-                                            ]
-                                        }
+                                        createdAt: { $gte: date_start }
                                     },
                                     {
-                                        $group: {
-                                            _id: '$method',
-                                            method: { $first: '$method' },
-                                            count: { $sum: 1 },
-                                            latency_min: { $min: '$latency_ms' },
-                                            latency_avg: { $avg: '$latency_ms' },
-                                            latency_max: { $max: '$latency_ms' }
-                                        }
+                                        createdAt: { $lte: date_end }
                                     }
-                                ], { 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
-                                    };
+                                ]
+                            }
+                        },
+                        {
+                            $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"
                                 }
-                                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
-                                    };
+                            }
+                        };
+                        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 === '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
-                                    };
+                            },
+                            day: {
+                                $dayOfMonth: {
+                                    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
-                                    };
+                            },
+                            month: {
+                                $month: {
+                                    date: '$createdAt',
+                                    timezone: "America/Chicago"
                                 }
-                                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*/];
+                            },
+                            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
                         }
+                    ], { allowDiskUse: true });
+                    resolve({
+                        methods: latencies,
+                        subscriptions: subscriptions,
+                        methodGraphData: methodGraphData,
+                        subGraphData: subGraphData
                     });
-                }); });
+                });
             },
             skipValidation: true
         }
     });
 }
-exports.loadLogMethods = loadLogMethods;
 
 //# sourceMappingURL=logs.js.map