@abyss-project/monitor 1.0.67 → 1.0.69

package/dist/api/report.admin.api.d.ts

@@ -1,2 +1,3 @@
-import { GetReportAdminBody, GetReportAdminResponse } from '../types';
+import { GetReportAdminBody, GetReportAdminResponse, GetGlobalReportAdminBody } from '../types';
 export declare const getReportAdmin: (body: GetReportAdminBody) => Promise<GetReportAdminResponse>;
+export declare const getGlobalReportAdmin: (body: GetGlobalReportAdminBody) => Promise<GetReportAdminResponse>;

package/dist/api/report.admin.api.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getReportAdmin = void 0;
+exports.getGlobalReportAdmin = exports.getReportAdmin = void 0;
 const __1 = require("..");
 const getReportAdmin = async (body) => {
     return (await __1.AbyssMonitorCore.axios.post(`report/admin/report`, body))
         .data;
 };
 exports.getReportAdmin = getReportAdmin;
+const getGlobalReportAdmin = async (body) => {
+    return (await __1.AbyssMonitorCore.axios.post(`report/admin/global-report`, body)).data;
+};
+exports.getGlobalReportAdmin = getGlobalReportAdmin;

package/dist/frameworks/express/decorators.js

@@ -7,6 +7,7 @@ exports.Killable = exports.Query = exports.Params = exports.Body = exports.Middl
 const types_1 = require("../../types");
 const _1 = require(".");
 const joi_to_swagger_1 = __importDefault(require("joi-to-swagger"));
+const utils_1 = require("../../utils");
 function Route(options) {
     return function (target, propertyKey, descriptor) {
         Reflect.defineMetadata(_1.ROUTE_WATERMARK, true, target, propertyKey);
@@ -106,7 +107,7 @@ function Body(schema, options) {
         Reflect.defineMetadata(_1.DOCS_WATERMARK, existingDocs, target, propertyKey);
         const originalMethod = descriptor.value;
         descriptor.value = function (...args) {
-            const result = schema.options({ presence: 'required' }).validate(args[0].body);
+            const result = schema.options({ presence: 'required' }).validate((0, utils_1.deepTrim)(args[0].body));
             if (result.error) {
                 throw result.error;
             }
@@ -128,7 +129,7 @@ function Params(schema, options) {
         Reflect.defineMetadata(_1.DOCS_WATERMARK, existingDocs, target, propertyKey);
         const originalMethod = descriptor.value;
         descriptor.value = function (...args) {
-            const result = schema.options({ presence: 'required' }).validate(args[0].params);
+            const result = schema.options({ presence: 'required' }).validate((0, utils_1.deepTrim)(args[0].params));
             if (result.error) {
                 throw result.error;
             }
@@ -150,7 +151,7 @@ function Query(schema, options) {
         Reflect.defineMetadata(_1.DOCS_WATERMARK, existingDocs, target, propertyKey);
         const originalMethod = descriptor.value;
         descriptor.value = function (...args) {
-            const result = schema.options({ presence: 'required' }).validate(args[0].query);
+            const result = schema.options({ presence: 'required' }).validate((0, utils_1.deepTrim)(args[0].query));
             if (result.error) {
                 throw result.error;
             }
@@ -161,7 +162,7 @@ function Query(schema, options) {
 }
 exports.Query = Query;
 function Killable() {
-    return function (target, propertyKey, descriptor) {
+    return function (target, propertyKey) {
         Reflect.defineMetadata(_1.KILLABLE_WATERMARK, true, target, propertyKey);
     };
 }

package/dist/frameworks/express/index.js

@@ -166,7 +166,7 @@ const isRoute = (target, propertyKey) => {
         return false;
     }
 };
-const setLocalsMiddleware = (controller, options = { prefix: '/' }, controllerPrefix, path, method, propertyKey) => (req, res, next) => {
+const setLocalsMiddleware = (controller, options = { prefix: '/' }, controllerPrefix, path, _method, _propertyKey) => (req, res, next) => {
     res.locals.controller = controller.name;
     res.locals.path = `${options.prefix}${controllerPrefix}${path !== null ? path || req.path : ''}`;
     next();

package/dist/index.d.ts

@@ -3,12 +3,176 @@ import { IAxiosRetryConfig } from 'axios-retry';
 import { StatsPublisher } from './models/stats-publisher.model';
 import { ApplicationAlertType } from './types';
 import { ParamsSendLogAlert, ParamsSendStatsAlert } from './utils';
+import * as applicationApi from './api/application.api';
+import * as applicationAdminApi from './api/application.admin.api';
+import * as applicationStatsApi from './api/application-stats.api';
+import * as applicationStatsAdminApi from './api/application-stats.admin.api';
+import * as applicationLogApi from './api/application-log.api';
+import * as applicationLogAdminApi from './api/application-log.admin.api';
+import * as applicationCronTaskApi from './api/application-cron-task.api';
+import * as applicationCronTaskAdminApi from './api/application-cron-task.admin.api';
+import * as applicationEventApi from './api/application-event.api';
+import * as applicationEventAdminApi from './api/application-event.admin.api';
+import * as applicationWebhookApi from './api/application-webhook.api';
+import * as applicationWebhookAdminApi from './api/application-webhook.admin.api';
+import * as applicationWebhookHistoryApi from './api/application-webhook-history.api';
+import * as applicationWebhookHistoryAdminApi from './api/application-webhook-history.admin.api';
+import * as applicationSentinelApi from './api/application-sentinel.api';
+import * as applicationSentinelAdminApi from './api/application-sentinel.admin.api';
+import * as metricsApi from './api/metrics.api';
+import * as hourlyMetricsApi from './api/hourly-metrics.api';
+import * as monitorApi from './api/monitor.api';
+import * as infrastructureAdminApi from './api/infrastructure.admin.api';
+import * as reportAdminApi from './api/report.admin.api';
 export * from './api';
 export * from './types';
 export * from './models';
 export * from './utils';
 export * from './middlewares';
 export * from './frameworks';
+type AbyssMonitorCoreSDK = {
+    application: {
+        get: typeof applicationApi.getApplication;
+        resetSecretPublishToken: typeof applicationApi.resetSecretPublishTokenApplication;
+        getLogAnalytics: typeof applicationApi.getLogAnalyticsApplication;
+        getAnalytics: typeof applicationApi.getAnalyticsApplication;
+        getStatsAnalytics: typeof applicationApi.getStatsAnalyticsApplication;
+        getEndpointAnalytics: typeof applicationApi.getEndpointAnalyticsApplication;
+        getEndpointOnPeriodAnalytics: typeof applicationApi.getEndpointOnPeriodAnalyticsApplication;
+        getSlowerEndpointAnalytics: typeof applicationApi.getSlowerEndpointAnalyticsApplication;
+        getCallPerControllerAnalytics: typeof applicationApi.getCallPerControllerAnalyticsApplication;
+        admin: {
+            paginate: typeof applicationAdminApi.paginateApplicationAdmin;
+            get: typeof applicationAdminApi.getApplicationAdmin;
+            resetApiKey: typeof applicationAdminApi.resetApiKeyApplicationAdmin;
+            create: typeof applicationAdminApi.createApplicationAdmin;
+            delete: typeof applicationAdminApi.deleteApplicationAdmin;
+            getMetrics: typeof applicationAdminApi.getMetricsApplicationAdmin;
+        };
+    };
+    applicationStats: {
+        get: typeof applicationStatsApi.getApplicationStats;
+        paginate: typeof applicationStatsApi.paginateApplicationStats;
+        create: typeof applicationStatsApi.createApplicationStats;
+        admin: {
+            get: typeof applicationStatsAdminApi.getApplicationStatsAdmin;
+            paginate: typeof applicationStatsAdminApi.paginateApplicationStatsAdmin;
+        };
+    };
+    applicationLog: {
+        get: typeof applicationLogApi.getApplicationLog;
+        paginate: typeof applicationLogApi.paginateApplicationLog;
+        create: typeof applicationLogApi.createApplicationLog;
+        admin: {
+            get: typeof applicationLogAdminApi.getApplicationLogAdmin;
+            paginate: typeof applicationLogAdminApi.paginateApplicationLogAdmin;
+        };
+    };
+    applicationCronTask: {
+        get: typeof applicationCronTaskApi.getApplicationCronTask;
+        paginate: typeof applicationCronTaskApi.paginateApplicationCronTask;
+        create: typeof applicationCronTaskApi.createApplicationCronTask;
+        update: typeof applicationCronTaskApi.updateApplicationCronTask;
+        delete: typeof applicationCronTaskApi.deleteApplicationCronTask;
+        getHistory: typeof applicationCronTaskApi.getHistoryApplicationCronTask;
+        paginateHistory: typeof applicationCronTaskApi.paginateHistoryApplicationCronTask;
+        regenerateSecret: typeof applicationCronTaskApi.regenerateSecretApplicationCronTask;
+        trigger: typeof applicationCronTaskApi.triggerApplicationCronTask;
+        admin: {
+            get: typeof applicationCronTaskAdminApi.getApplicationCronTaskAdmin;
+            paginate: typeof applicationCronTaskAdminApi.paginateApplicationCronTaskAdmin;
+            create: typeof applicationCronTaskAdminApi.createApplicationCronTaskAdmin;
+            update: typeof applicationCronTaskAdminApi.updateApplicationCronTaskAdmin;
+            delete: typeof applicationCronTaskAdminApi.deleteApplicationCronTaskAdmin;
+            getHistory: typeof applicationCronTaskAdminApi.getHistoryApplicationCronTaskAdmin;
+            paginateHistory: typeof applicationCronTaskAdminApi.paginateHistoryApplicationCronTaskAdmin;
+            regenerateSecret: typeof applicationCronTaskAdminApi.regenerateSecretApplicationCronTaskAdmin;
+            trigger: typeof applicationCronTaskAdminApi.triggerApplicationCronTaskAdmin;
+        };
+    };
+    applicationEvent: {
+        getCountPerDay: typeof applicationEventApi.getCountPerDayApplicationEvent;
+        getTotalCount: typeof applicationEventApi.getTotalCountApplicationEvent;
+        getMetrics: typeof applicationEventApi.getMetricsApplicationEvent;
+        get: typeof applicationEventApi.getApplicationEvent;
+        paginate: typeof applicationEventApi.paginateApplicationEvent;
+        create: typeof applicationEventApi.createApplicationEvent;
+        delete: typeof applicationEventApi.deleteApplicationEvent;
+        admin: {
+            get: typeof applicationEventAdminApi.getApplicationEventAdmin;
+            paginate: typeof applicationEventAdminApi.paginateApplicationEventAdmin;
+            delete: typeof applicationEventAdminApi.deleteApplicationEventAdmin;
+        };
+    };
+    applicationWebhook: {
+        get: typeof applicationWebhookApi.getApplicationWebhook;
+        delete: typeof applicationWebhookApi.deleteApplicationWebhook;
+        update: typeof applicationWebhookApi.updateApplicationWebhook;
+        resetSecret: typeof applicationWebhookApi.resetResetSecretApplicationWebhook;
+        create: typeof applicationWebhookApi.createApplicationWebhook;
+        paginate: typeof applicationWebhookApi.paginateApplicationWebhook;
+        admin: {
+            get: typeof applicationWebhookAdminApi.getApplicationWebhookAdmin;
+            delete: typeof applicationWebhookAdminApi.deleteApplicationWebhookAdmin;
+            update: typeof applicationWebhookAdminApi.updateApplicationWebhookAdmin;
+            resetSecret: typeof applicationWebhookAdminApi.resetResetSecretApplicationWebhookAdmin;
+            create: typeof applicationWebhookAdminApi.createApplicationWebhookAdmin;
+            paginate: typeof applicationWebhookAdminApi.paginateApplicationWebhookAdmin;
+        };
+    };
+    applicationWebhookHistory: {
+        get: typeof applicationWebhookHistoryApi.getApplicationWebhookHistory;
+        paginate: typeof applicationWebhookHistoryApi.paginateApplicationWebhookHistory;
+        admin: {
+            get: typeof applicationWebhookHistoryAdminApi.getApplicationWebhookHistoryAdmin;
+            paginate: typeof applicationWebhookHistoryAdminApi.paginateApplicationWebhookHistoryAdmin;
+        };
+    };
+    applicationSentinel: {
+        get: typeof applicationSentinelApi.getApplicationSentinel;
+        paginate: typeof applicationSentinelApi.paginateApplicationSentinel;
+        create: typeof applicationSentinelApi.createApplicationSentinel;
+        update: typeof applicationSentinelApi.updateApplicationSentinel;
+        delete: typeof applicationSentinelApi.deleteApplicationSentinel;
+        getHistory: typeof applicationSentinelApi.getHistoryApplicationSentinel;
+        paginateHistory: typeof applicationSentinelApi.paginateHistoryApplicationSentinel;
+        trigger: typeof applicationSentinelApi.triggerApplicationSentinel;
+        metricsLatency: typeof applicationSentinelApi.metricsLatencyApplicationSentinel;
+        admin: {
+            get: typeof applicationSentinelAdminApi.getApplicationSentinelAdmin;
+            paginate: typeof applicationSentinelAdminApi.paginateApplicationSentinelAdmin;
+            create: typeof applicationSentinelAdminApi.createApplicationSentinelAdmin;
+            update: typeof applicationSentinelAdminApi.updateApplicationSentinelAdmin;
+            delete: typeof applicationSentinelAdminApi.deleteApplicationSentinelAdmin;
+            getHistory: typeof applicationSentinelAdminApi.getHistoryApplicationSentinelAdmin;
+            paginateHistory: typeof applicationSentinelAdminApi.paginateHistoryApplicationSentinelAdmin;
+            trigger: typeof applicationSentinelAdminApi.triggerApplicationSentinelAdmin;
+        };
+    };
+    metrics: {
+        getSentinel: typeof metricsApi.getSentinelMetrics;
+        getLatencySentinel: typeof metricsApi.getLatencySentinelMetrics;
+        getLastIncidentSentinel: typeof metricsApi.getLastIncidentSentinelMetrics;
+    };
+    hourlyMetrics: {
+        get: typeof hourlyMetricsApi.getHourlyMetrics;
+    };
+    monitor: {
+        up: typeof monitorApi.upMonitor;
+    };
+    infrastructure: {
+        admin: {
+            createFuturePartitions: typeof infrastructureAdminApi.createFuturePartitionsInfrastructureAdmin;
+            getPartitionsInfo: typeof infrastructureAdminApi.getPartitionsInfoInfrastructureAdmin;
+        };
+    };
+    report: {
+        admin: {
+            getReport: typeof reportAdminApi.getReportAdmin;
+            getGlobalReport: typeof reportAdminApi.getGlobalReportAdmin;
+        };
+    };
+};
 export declare const API_KEY_APPLICATION_HEADER = "abyss-monitor-api-key-application";
 export declare const ADMIN_TOKEN_HEADER = "abyss-admin-token";
 export declare const HEADER_CRON_TASK_SIGNATURE_NAME = "abyss-monitor-cron-task-signature";
@@ -42,6 +206,9 @@ type CoreConfig = {
 export declare class AbyssMonitorCore {
     private static config;
     static StatsPublisher: typeof StatsPublisher;
+    private static _sdk;
+    static get sdk(): AbyssMonitorCoreSDK;
+    private static buildSDK;
     static axios: import("axios").AxiosInstance;
     static setConfig(config: Partial<CoreConfig>): void;
     static getConfig(): typeof AbyssMonitorCore.config;

package/dist/index.js

@@ -35,6 +35,27 @@ require("reflect-metadata");
 const axios_1 = __importDefault(require("axios"));
 const axios_retry_1 = __importStar(require("axios-retry"));
 const stats_publisher_model_1 = require("./models/stats-publisher.model");
+const applicationApi = __importStar(require("./api/application.api"));
+const applicationAdminApi = __importStar(require("./api/application.admin.api"));
+const applicationStatsApi = __importStar(require("./api/application-stats.api"));
+const applicationStatsAdminApi = __importStar(require("./api/application-stats.admin.api"));
+const applicationLogApi = __importStar(require("./api/application-log.api"));
+const applicationLogAdminApi = __importStar(require("./api/application-log.admin.api"));
+const applicationCronTaskApi = __importStar(require("./api/application-cron-task.api"));
+const applicationCronTaskAdminApi = __importStar(require("./api/application-cron-task.admin.api"));
+const applicationEventApi = __importStar(require("./api/application-event.api"));
+const applicationEventAdminApi = __importStar(require("./api/application-event.admin.api"));
+const applicationWebhookApi = __importStar(require("./api/application-webhook.api"));
+const applicationWebhookAdminApi = __importStar(require("./api/application-webhook.admin.api"));
+const applicationWebhookHistoryApi = __importStar(require("./api/application-webhook-history.api"));
+const applicationWebhookHistoryAdminApi = __importStar(require("./api/application-webhook-history.admin.api"));
+const applicationSentinelApi = __importStar(require("./api/application-sentinel.api"));
+const applicationSentinelAdminApi = __importStar(require("./api/application-sentinel.admin.api"));
+const metricsApi = __importStar(require("./api/metrics.api"));
+const hourlyMetricsApi = __importStar(require("./api/hourly-metrics.api"));
+const monitorApi = __importStar(require("./api/monitor.api"));
+const infrastructureAdminApi = __importStar(require("./api/infrastructure.admin.api"));
+const reportAdminApi = __importStar(require("./api/report.admin.api"));
 __exportStar(require("./api"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./models"), exports);
@@ -57,7 +78,159 @@ exports.RETRY_CODES = [
     503,
 ];
 class AbyssMonitorCore {
+    static get sdk() {
+        if (!_a._sdk) {
+            _a._sdk = _a.buildSDK();
+        }
+        return _a._sdk;
+    }
+    static buildSDK() {
+        return {
+            application: {
+                get: applicationApi.getApplication,
+                resetSecretPublishToken: applicationApi.resetSecretPublishTokenApplication,
+                getLogAnalytics: applicationApi.getLogAnalyticsApplication,
+                getAnalytics: applicationApi.getAnalyticsApplication,
+                getStatsAnalytics: applicationApi.getStatsAnalyticsApplication,
+                getEndpointAnalytics: applicationApi.getEndpointAnalyticsApplication,
+                getEndpointOnPeriodAnalytics: applicationApi.getEndpointOnPeriodAnalyticsApplication,
+                getSlowerEndpointAnalytics: applicationApi.getSlowerEndpointAnalyticsApplication,
+                getCallPerControllerAnalytics: applicationApi.getCallPerControllerAnalyticsApplication,
+                admin: {
+                    paginate: applicationAdminApi.paginateApplicationAdmin,
+                    get: applicationAdminApi.getApplicationAdmin,
+                    resetApiKey: applicationAdminApi.resetApiKeyApplicationAdmin,
+                    create: applicationAdminApi.createApplicationAdmin,
+                    delete: applicationAdminApi.deleteApplicationAdmin,
+                    getMetrics: applicationAdminApi.getMetricsApplicationAdmin,
+                },
+            },
+            applicationStats: {
+                get: applicationStatsApi.getApplicationStats,
+                paginate: applicationStatsApi.paginateApplicationStats,
+                create: applicationStatsApi.createApplicationStats,
+                admin: {
+                    get: applicationStatsAdminApi.getApplicationStatsAdmin,
+                    paginate: applicationStatsAdminApi.paginateApplicationStatsAdmin,
+                },
+            },
+            applicationLog: {
+                get: applicationLogApi.getApplicationLog,
+                paginate: applicationLogApi.paginateApplicationLog,
+                create: applicationLogApi.createApplicationLog,
+                admin: {
+                    get: applicationLogAdminApi.getApplicationLogAdmin,
+                    paginate: applicationLogAdminApi.paginateApplicationLogAdmin,
+                },
+            },
+            applicationCronTask: {
+                get: applicationCronTaskApi.getApplicationCronTask,
+                paginate: applicationCronTaskApi.paginateApplicationCronTask,
+                create: applicationCronTaskApi.createApplicationCronTask,
+                update: applicationCronTaskApi.updateApplicationCronTask,
+                delete: applicationCronTaskApi.deleteApplicationCronTask,
+                getHistory: applicationCronTaskApi.getHistoryApplicationCronTask,
+                paginateHistory: applicationCronTaskApi.paginateHistoryApplicationCronTask,
+                regenerateSecret: applicationCronTaskApi.regenerateSecretApplicationCronTask,
+                trigger: applicationCronTaskApi.triggerApplicationCronTask,
+                admin: {
+                    get: applicationCronTaskAdminApi.getApplicationCronTaskAdmin,
+                    paginate: applicationCronTaskAdminApi.paginateApplicationCronTaskAdmin,
+                    create: applicationCronTaskAdminApi.createApplicationCronTaskAdmin,
+                    update: applicationCronTaskAdminApi.updateApplicationCronTaskAdmin,
+                    delete: applicationCronTaskAdminApi.deleteApplicationCronTaskAdmin,
+                    getHistory: applicationCronTaskAdminApi.getHistoryApplicationCronTaskAdmin,
+                    paginateHistory: applicationCronTaskAdminApi.paginateHistoryApplicationCronTaskAdmin,
+                    regenerateSecret: applicationCronTaskAdminApi.regenerateSecretApplicationCronTaskAdmin,
+                    trigger: applicationCronTaskAdminApi.triggerApplicationCronTaskAdmin,
+                },
+            },
+            applicationEvent: {
+                getCountPerDay: applicationEventApi.getCountPerDayApplicationEvent,
+                getTotalCount: applicationEventApi.getTotalCountApplicationEvent,
+                getMetrics: applicationEventApi.getMetricsApplicationEvent,
+                get: applicationEventApi.getApplicationEvent,
+                paginate: applicationEventApi.paginateApplicationEvent,
+                create: applicationEventApi.createApplicationEvent,
+                delete: applicationEventApi.deleteApplicationEvent,
+                admin: {
+                    get: applicationEventAdminApi.getApplicationEventAdmin,
+                    paginate: applicationEventAdminApi.paginateApplicationEventAdmin,
+                    delete: applicationEventAdminApi.deleteApplicationEventAdmin,
+                },
+            },
+            applicationWebhook: {
+                get: applicationWebhookApi.getApplicationWebhook,
+                delete: applicationWebhookApi.deleteApplicationWebhook,
+                update: applicationWebhookApi.updateApplicationWebhook,
+                resetSecret: applicationWebhookApi.resetResetSecretApplicationWebhook,
+                create: applicationWebhookApi.createApplicationWebhook,
+                paginate: applicationWebhookApi.paginateApplicationWebhook,
+                admin: {
+                    get: applicationWebhookAdminApi.getApplicationWebhookAdmin,
+                    delete: applicationWebhookAdminApi.deleteApplicationWebhookAdmin,
+                    update: applicationWebhookAdminApi.updateApplicationWebhookAdmin,
+                    resetSecret: applicationWebhookAdminApi.resetResetSecretApplicationWebhookAdmin,
+                    create: applicationWebhookAdminApi.createApplicationWebhookAdmin,
+                    paginate: applicationWebhookAdminApi.paginateApplicationWebhookAdmin,
+                },
+            },
+            applicationWebhookHistory: {
+                get: applicationWebhookHistoryApi.getApplicationWebhookHistory,
+                paginate: applicationWebhookHistoryApi.paginateApplicationWebhookHistory,
+                admin: {
+                    get: applicationWebhookHistoryAdminApi.getApplicationWebhookHistoryAdmin,
+                    paginate: applicationWebhookHistoryAdminApi.paginateApplicationWebhookHistoryAdmin,
+                },
+            },
+            applicationSentinel: {
+                get: applicationSentinelApi.getApplicationSentinel,
+                paginate: applicationSentinelApi.paginateApplicationSentinel,
+                create: applicationSentinelApi.createApplicationSentinel,
+                update: applicationSentinelApi.updateApplicationSentinel,
+                delete: applicationSentinelApi.deleteApplicationSentinel,
+                getHistory: applicationSentinelApi.getHistoryApplicationSentinel,
+                paginateHistory: applicationSentinelApi.paginateHistoryApplicationSentinel,
+                trigger: applicationSentinelApi.triggerApplicationSentinel,
+                metricsLatency: applicationSentinelApi.metricsLatencyApplicationSentinel,
+                admin: {
+                    get: applicationSentinelAdminApi.getApplicationSentinelAdmin,
+                    paginate: applicationSentinelAdminApi.paginateApplicationSentinelAdmin,
+                    create: applicationSentinelAdminApi.createApplicationSentinelAdmin,
+                    update: applicationSentinelAdminApi.updateApplicationSentinelAdmin,
+                    delete: applicationSentinelAdminApi.deleteApplicationSentinelAdmin,
+                    getHistory: applicationSentinelAdminApi.getHistoryApplicationSentinelAdmin,
+                    paginateHistory: applicationSentinelAdminApi.paginateHistoryApplicationSentinelAdmin,
+                    trigger: applicationSentinelAdminApi.triggerApplicationSentinelAdmin,
+                },
+            },
+            metrics: {
+                getSentinel: metricsApi.getSentinelMetrics,
+                getLatencySentinel: metricsApi.getLatencySentinelMetrics,
+                getLastIncidentSentinel: metricsApi.getLastIncidentSentinelMetrics,
+            },
+            hourlyMetrics: {
+                get: hourlyMetricsApi.getHourlyMetrics,
+            },
+            monitor: {
+                up: monitorApi.upMonitor,
+            },
+            infrastructure: {
+                admin: {
+                    createFuturePartitions: infrastructureAdminApi.createFuturePartitionsInfrastructureAdmin,
+                    getPartitionsInfo: infrastructureAdminApi.getPartitionsInfoInfrastructureAdmin,
+                },
+            },
+            report: {
+                admin: {
+                    getReport: reportAdminApi.getReportAdmin,
+                    getGlobalReport: reportAdminApi.getGlobalReportAdmin,
+                },
+            },
+        };
+    }
     static setConfig(config) {
+        _a._sdk = null;
         _a.config = { ..._a.config, ...config };
         if (config.baseURL) {
             _a.axios.defaults.baseURL = config.baseURL;
@@ -105,6 +278,7 @@ AbyssMonitorCore.config = {
     getWebhookUrl: async () => null,
 };
 AbyssMonitorCore.StatsPublisher = stats_publisher_model_1.StatsPublisher;
+AbyssMonitorCore._sdk = null;
 AbyssMonitorCore.axios = axios_1.default.create({
     baseURL: _a.config.baseURL,
     withCredentials: true,

package/dist/types/interface/api/requests/report.admin.request.d.ts

@@ -4,3 +4,8 @@ export interface GetReportAdminBody {
     endDate: Date;
     timePeriod?: 'minute' | 'hour' | 'day' | 'month';
 }
+export interface GetGlobalReportAdminBody {
+    startDate: Date;
+    endDate: Date;
+    timePeriod?: 'minute' | 'hour' | 'day' | 'month';
+}

package/dist/utils/index.d.ts

@@ -5,3 +5,4 @@ export * from './alert.utils';
 export * from './non-blocking-promise.utils';
 export * from './request-tracker.utils';
 export * from './graceful-shutdown.utils';
+export * from './string.utils';

package/dist/utils/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./alert.utils"), exports);
 __exportStar(require("./non-blocking-promise.utils"), exports);
 __exportStar(require("./request-tracker.utils"), exports);
 __exportStar(require("./graceful-shutdown.utils"), exports);
+__exportStar(require("./string.utils"), exports);

package/dist/utils/string.utils.d.ts

@@ -0,0 +1 @@
+export declare const deepTrim: <T extends unknown>(input: T) => T;

package/dist/utils/string.utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepTrim = void 0;
+const deepTrim = (input) => {
+    try {
+        if (typeof input === 'string')
+            return input.trim();
+        if (Array.isArray(input))
+            return input.map(exports.deepTrim);
+        if (input !== null && typeof input === 'object') {
+            return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, (0, exports.deepTrim)(v)]));
+        }
+        return input;
+    }
+    catch (err) {
+        console.error('[deepTrim] Unexpected error, returning original input:', err);
+        return input;
+    }
+};
+exports.deepTrim = deepTrim;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abyss-project/monitor",
-  "version": "1.0.67",
+  "version": "1.0.69",
   "description": "Core package to interact with Abyss-Monitor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,13 +50,15 @@
     "eslint-plugin-promise": "^5.1.0",
     "prettier": "2.3.1",
     "sequelize-cli": "^6.2.0",
-    "typescript": "5.4.2"
+    "typescript": "5.4.2",
+    "tsc-watch": "^4.6.2"
   },
   "scripts": {
     "lint": "eslint \"{src,apps,libs,test,core}/**/*.ts\" --fix",
     "lint:check": "eslint \"{src,apps,libs,test,core}/**/*.ts\" --max-warnings 0",
     "tsc": "tsc",
     "build": "tsc",
-    "prepublish": "tsc"
+    "prepublish": "tsc",
+    "dev": "tsc-watch --onSuccess 'yalc push'"
   }
 }