badmfck-api-server 2.8.4 → 2.8.6

package/dist/apiServer/APIService.d.ts

@@ -5,6 +5,10 @@ import { IBaseEndpoint } from './BaseEndpoint';
 import { HTTPRequestVO, IError, TransferPacketVO } from './structures/Interfaces';
 import { Req } from "badmfck-signal";
 import http from 'http';
+export interface IMonitorUser {
+    login: string;
+    password: string;
+}
 export interface APIServiceNetworkLogItem {
     id: number;
     created: number;
@@ -30,10 +34,7 @@ export interface APIServiceOptions {
     interceptor?: IBaseEndpoint;
     postproducer?: (req: HTTPRequestVO | undefined | null, res: Response, data: TransferPacketVO<any>, requestTime: number, endpoint?: string, log?: APIServiceNetworkLogItem | null) => Promise<TransferPacketVO>;
     preproducer?: (req: HTTPRequestVO | undefined | null) => any;
-    monitor?: {
-        login: string;
-        password: string;
-    }[];
+    monitor?: IMonitorUser[];
     appVersion?: string;
     fileTempDir: string;
     fileLimit: number;
@@ -47,15 +48,13 @@ export declare const REQ_HTTP_SERVER: Req<void, {
     http: http.Server;
 }>;
 export declare const REQ_INTERNAL_CALL: Req<HTTPRequestVO, IError | any>;
-export declare const REQ_MONITOR_USERS: Req<{
-    authorization: string;
-}, any>;
+export declare const REQ_MONITOR_USERS: Req<void, IMonitorUser[]>;
 export declare function Initializer(services: IBaseService[]): Promise<void>;
 export declare class APIService extends BaseService {
     private static nextLogID;
     private version;
     private options;
-    private monitor?;
+    private monitor;
     private monitorIndexFile?;
     private started;
     private requestsCount;

package/dist/apiServer/APIService.js

@@ -46,6 +46,7 @@ const http_1 = __importDefault(require("http"));
 const MysqlService_1 = require("./MysqlService");
 const StatService_1 = require("./StatService");
 const ExternalServiceEndpoint_1 = require("./external/ExternalServiceEndpoint");
+const MonitorService_1 = require("./MonitorService");
 function getDefaultOptions() {
     return {
         port: 8091,
@@ -74,7 +75,6 @@ exports.REQ_HTTP_SERVER = new badmfck_signal_1.Req(undefined, "REQ_HTTP_SERVER")
 exports.REQ_INTERNAL_CALL = new badmfck_signal_1.Req(undefined, "REQ_INTERNAL_CALL");
 exports.REQ_MONITOR_USERS = new badmfck_signal_1.Req(undefined, "REQ_MONITOR_USERS");
 const activeServices = [];
-const entryPoints = [];
 async function Initializer(services) {
     services.push(new StatService_1.StatService());
     for (let i of services) {
@@ -88,9 +88,9 @@ async function Initializer(services) {
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
     static nextLogID = 0;
-    version = "2.8.4";
+    version = "2.8.6";
     options;
-    monitor;
+    monitor = null;
     monitorIndexFile;
     started = new Date();
     requestsCount = 0;
@@ -105,24 +105,9 @@ class APIService extends BaseService_1.BaseService {
         if (!this.options.corsHostWhiteList.find(val => val === self))
             this.options.corsHostWhiteList.push();
         if (this.options.monitor && this.options.monitor.length > 0) {
-            this.monitor = new Monitor_1.Monitor();
-            this.options.endpoints.push(this.monitor);
-            console.warn("Service Monitor initialized");
-            console.warn("monitor links:");
-            for (let i of this.options.monitor) {
-                const hash = crypto_1.default.createHash("sha256").update(i.login + i.password).digest().toString("hex");
-                console.warn("Monitor link for: " + i.login + " -> /sm-" + hash);
-            }
-            exports.REQ_MONITOR_USERS.listener = async (req) => {
-                const result = [];
-                if (this.options.monitor) {
-                    for (let i of this.options.monitor) {
-                        const hash = crypto_1.default.createHash("sha256").update(i.login + i.password).digest().toString("hex");
-                        result.push(hash);
-                    }
-                }
-                return result;
-            };
+            exports.REQ_MONITOR_USERS.listener = async () => this.options.monitor ?? [];
+            this.monitor = new MonitorService_1.MonitorService();
+            this.options.endpoints.push(new Monitor_1.Monitor());
         }
         this.options.endpoints.push(new ExternalServiceEndpoint_1.ExternalServiceEndpoint());
         this.options.endpoints.push(new Liveness_1.Liveness(this.started), new Readiness_1.Readiness(this.started));
@@ -299,8 +284,6 @@ class APIService extends BaseService_1.BaseService {
                                     httpRequest.interceptorResult = interceptorResult;
                                 }
                             }
-                            if (i === this.monitor)
-                                httpRequest.precheck = { data: this.options.monitor };
                             const precheck = await i.precheck(httpRequest);
                             if (precheck && precheck.error) {
                                 this.sendResponse(req.get("Referer") ?? "", res, precheck, tme, ep, log, httpRequest);
@@ -313,8 +296,6 @@ class APIService extends BaseService_1.BaseService {
                             console.error(e);
                             if (this.options.onError)
                                 this.options.onError(e);
-                            if (this.monitor)
-                                this.monitor.registrateFatalError(ep);
                             let data = {
                                 error: {
                                     code: 10002,
@@ -388,8 +369,6 @@ class APIService extends BaseService_1.BaseService {
                 this.options.onNetworkLog(log);
             return;
         }
-        if (req && req.stream) {
-        }
         if (this.options.postproducer) {
             try {
                 data = await this.options.postproducer(req, res, data, requestTime, endpoint, log);
@@ -409,15 +388,12 @@ class APIService extends BaseService_1.BaseService {
             log.time = data.responseTime;
             log.referer = ref;
         }
-        if (this.monitor)
-            this.monitor.registrateResponse(data.endpoint, data.responseTime);
+        MonitorService_1.S_STAT_REGISTRATE_REQUEST.invoke(data);
         if (res.destroyed || res.closed) {
             if (log)
                 log.error = "Connection already closed, can't send response for: " + data.endpoint;
             if (this.options.onError)
                 this.options.onError("Connection already closed, can't send response: " + data.endpoint, data);
-            if (this.monitor)
-                this.monitor.registrateError(data.endpoint);
         }
         else {
             try {
@@ -426,8 +402,6 @@ class APIService extends BaseService_1.BaseService {
                         if (err) {
                             if (log)
                                 log.error = "Can't send file: " + data.file;
-                            if (this.monitor && data.endpoint)
-                                this.monitor.registrateAPIError(data.endpoint);
                             this.sendResponse(ref, res, {
                                 error: DefaultErrors_1.default.CANT_SEND_FILE,
                                 data: null,
@@ -460,8 +434,7 @@ class APIService extends BaseService_1.BaseService {
                         res.send(data);
                         if (log)
                             log.response = this.checkDataLength(data);
-                        if (data.error && this.monitor) {
-                            this.monitor.registrateAPIError(data.endpoint);
+                        if (data.error) {
                             if (log)
                                 log.error = data.error.message;
                         }
@@ -473,8 +446,6 @@ class APIService extends BaseService_1.BaseService {
                     this.options.onError("Can't send response", e);
                 if (log)
                     log.error = "Can't send response";
-                if (this.monitor)
-                    this.monitor.registrateError(data.endpoint);
             }
         }
         if (log && log.error && this.options.onError) {

package/dist/apiServer/MonitorService.d.ts

@@ -0,0 +1,27 @@
+import Signal, { Req } from "badmfck-signal";
+import { BaseService } from "./BaseService";
+import { TransferPacketVO } from "./structures/Interfaces";
+export interface IEPStat {
+    success: number;
+    fail: number;
+}
+export interface IEPStatReqFilter {
+    range: "minute" | "hour" | "day";
+    from: string;
+    to: string;
+    ep: string;
+}
+export interface IEPStatResult {
+}
+export declare const S_STAT_REGISTRATE_REQUEST: Signal<TransferPacketVO<any>>;
+export declare const REQ_EP_STAT: Req<IEPStatReqFilter, IEPStatResult>;
+export declare class MonitorService extends BaseService {
+    endpoints: Map<number, Map<string, IEPStat>>;
+    constructor();
+    getEPStat(req: IEPStatReqFilter): Promise<IEPStatResult>;
+    onStatRegistrate(data: TransferPacketVO): void;
+    pad(num: number): string;
+    getMinutes(date: Date): number;
+    getDate(minutes: number): Date;
+    getMinutesInMonth(date: Date): number;
+}

package/dist/apiServer/MonitorService.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonitorService = exports.REQ_EP_STAT = exports.S_STAT_REGISTRATE_REQUEST = void 0;
+const badmfck_signal_1 = __importStar(require("badmfck-signal"));
+const BaseService_1 = require("./BaseService");
+exports.S_STAT_REGISTRATE_REQUEST = new badmfck_signal_1.default();
+exports.REQ_EP_STAT = new badmfck_signal_1.Req(undefined, "REQ_EP_STAT");
+class MonitorService extends BaseService_1.BaseService {
+    endpoints = new Map();
+    constructor() {
+        super("MonitorService");
+        exports.S_STAT_REGISTRATE_REQUEST.subscribe(this.onStatRegistrate);
+        exports.REQ_EP_STAT.listener = async (req) => this.getEPStat(req);
+    }
+    async getEPStat(req) {
+        const result = new Map();
+        if (req.range === "hour") {
+            for (let [minute, minuteSlot] of this.endpoints) {
+                const date = this.getDate(minute);
+                let range = minute + "";
+                if (req.range === "hour")
+                    range = this.pad(this.getDate(minute).getHours());
+                else if (req.range === "day")
+                    range = this.pad(this.getDate(minute).getDate());
+                if (req.from) {
+                    if (range < req.from)
+                        continue;
+                }
+                if (req.to) {
+                    if (range > req.to)
+                        continue;
+                }
+                let resultSlot = result.get(range);
+                if (!resultSlot) {
+                    resultSlot = new Map();
+                    result.set(range, resultSlot);
+                }
+                let epSlot = resultSlot.get(req.ep);
+                if (!epSlot) {
+                    epSlot = { success: 0, fail: 0 };
+                    resultSlot.set(req.ep, epSlot);
+                }
+                for (let [ep, stat] of minuteSlot) {
+                    epSlot.success += stat.success;
+                    epSlot.fail += stat.fail;
+                }
+            }
+        }
+        const endResult = [];
+        for (let [date, obj] of result) {
+            const stat = {
+                date,
+                data: []
+            };
+            for (let [ep, s] of obj) {
+                const r = { ep, ...s };
+                stat.data.push(r);
+            }
+            endResult.push(stat);
+        }
+        return { filter: req, result: endResult };
+    }
+    onStatRegistrate(data) {
+        const minute = this.getMinutes(new Date());
+        let minuteSlot = this.endpoints.get(minute);
+        if (!minuteSlot) {
+            minuteSlot = new Map();
+            this.endpoints.set(minute, minuteSlot);
+        }
+        if (!data.endpoint)
+            data.endpoint = "unknown";
+        let epSlot = minuteSlot.get(data.endpoint);
+        if (!epSlot) {
+            epSlot = { success: 0, fail: 0 };
+            minuteSlot.set(data.endpoint, epSlot);
+        }
+        if (data.error) {
+            epSlot.fail++;
+        }
+        else {
+            epSlot.success++;
+        }
+        if (this.endpoints.size > 3000) {
+            const firstItem = this.endpoints.keys().next().value;
+            if (firstItem)
+                this.endpoints.delete(firstItem);
+        }
+    }
+    pad(num) {
+        return num.toString().padStart(2, '0');
+    }
+    getMinutes(date) {
+        const year = date.getFullYear();
+        const month = this.pad(date.getMonth() + 1);
+        const day = this.pad(date.getDate());
+        const hours = this.pad(date.getHours());
+        const minutes = this.pad(date.getMinutes());
+        return parseInt(`${year}${month}${day}${hours}${minutes}`);
+    }
+    getDate(minutes) {
+        const datetime = minutes.toString();
+        const year = parseInt(datetime.slice(0, 4));
+        const month = parseInt(datetime.slice(4, 6)) - 1;
+        const day = parseInt(datetime.slice(6, 8));
+        const hours = parseInt(datetime.slice(8, 10));
+        const min = parseInt(datetime.slice(10, 12));
+        return new Date(year, month, day, hours, min);
+    }
+    getMinutesInMonth(date) {
+        const daysInMonth = date.getDate();
+        return daysInMonth * 1440;
+    }
+}
+exports.MonitorService = MonitorService;

package/dist/apiServer/monitor/Monitor.d.ts

@@ -10,39 +10,15 @@ interface IStatObject {
     fatalErrors: Map<string, number>;
     apiErrors: Map<string, number>;
 }
-interface ISystemStat {
-    cpuUsage: any;
-    memoryTotal: number;
-    memoryUsage: any;
-}
 export declare const S_MONITOR_REGISTRATE_ACTION: Signal<IUserAction>;
 export declare class Monitor extends BaseEndpoint {
     ignoreHttpLogging: boolean;
-    private httpRequests;
-    private systemStat;
-    private userActions;
-    private registeredActions;
+    users: Map<string, IStatObject>;
     constructor();
-    registrateAction(data: IUserAction): void;
-    addSystemStat(): void;
-    registrateError(endpoint: string): void;
-    registrateFatalError(endpoint: string): void;
-    registrateAPIError(endpoint: string): void;
-    registrateResponse(endpoint: string, responseTime: number): void;
-    increaseStat(statObject: Map<string, number>, endpoint: string): void;
-    createStatObj(): IStatObject;
-    createSystemStatObj(): ISystemStat;
-    getDateIndex(d: Date): number;
-    getHourMinuteIndex(d: Date): string;
-    leadZero(i: number): string;
-    precheck(req: HTTPRequestVO): Promise<TransferPacketVO<any> | null>;
-    logs(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
-    netlog(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
-    metrics(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
-    serverStat(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
-    mapToKeyValue(map: Map<string, string | number>): {
-        name: string;
-        value: string | number;
-    }[];
+    logs(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    netlog(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    metrics(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    serverStat(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    checkAuthentication(req: HTTPRequestVO): Promise<boolean>;
 }
 export {};

package/dist/apiServer/monitor/Monitor.js

@@ -10,254 +10,71 @@ const BaseEndpoint_1 = require("../BaseEndpoint");
 const LogService_1 = require("../LogService");
 const crypto_1 = __importDefault(require("crypto"));
 const os_1 = __importDefault(require("os"));
+const DefaultErrors_1 = __importDefault(require("../structures/DefaultErrors"));
+const MonitorService_1 = require("../MonitorService");
 exports.S_MONITOR_REGISTRATE_ACTION = new badmfck_signal_1.Signal();
 class Monitor extends BaseEndpoint_1.BaseEndpoint {
     ignoreHttpLogging = true;
-    httpRequests = new Map();
-    systemStat = new Map();
-    userActions = new Map();
-    registeredActions = 0;
+    users = new Map();
     constructor() {
-        super("sys-monitor");
-        exports.S_MONITOR_REGISTRATE_ACTION.subscribe(data => this.registrateAction(data));
+        super("--sys-monitor");
         this.registerEndpoints([
             { ignoreInterceptor: true, endpoint: "log", handler: this.logs },
             { ignoreInterceptor: true, endpoint: "netlog", handler: this.netlog },
             { ignoreInterceptor: true, endpoint: "metrics", handler: this.metrics },
-            { ignoreInterceptor: true, endpoint: "server/stat", handler: this.serverStat }
+            { ignoreInterceptor: true, endpoint: "server", handler: this.serverStat }
         ]);
-        setInterval(() => {
-            this.addSystemStat();
-        }, 1000 * 60 * 10);
-        this.addSystemStat();
-    }
-    registrateAction(data) {
-        if (!data.action)
-            return;
-        if (typeof data.action !== "string")
-            return;
-        if (data.action.length > 20)
-            data.action = data.action.substring(0, 20);
-        const d = new Date();
-        const doy = this.getDateIndex(d);
-        let day = this.userActions.get(doy);
-        if (!day) {
-            day = new Map();
-            this.userActions.set(doy, day);
-            if (this.userActions.size > 7) {
-                for (let i of this.userActions) {
-                    this.userActions.delete(i[0]);
-                    break;
-                }
-            }
-        }
-        const minute = this.getHourMinuteIndex(d);
-        let m = day.get(minute);
-        if (!m) {
-            m = new Map();
-            day.set(minute, m);
-        }
-        let cnt = m.get(data.action);
-        if (!cnt)
-            cnt = 0;
-        cnt++;
-        m.set(data.action, cnt);
-    }
-    addSystemStat() {
-        const so = this.createSystemStatObj();
-        so.memoryUsage = process.memoryUsage();
-        so.memoryTotal = os_1.default.totalmem();
-    }
-    registrateError(endpoint) {
-        const so = this.createStatObj();
-        this.increaseStat(so.errors, endpoint);
-    }
-    registrateFatalError(endpoint) {
-        const so = this.createStatObj();
-        this.increaseStat(so.fatalErrors, endpoint);
-    }
-    registrateAPIError(endpoint) {
-        const so = this.createStatObj();
-        this.increaseStat(so.apiErrors, endpoint);
-    }
-    registrateResponse(endpoint, responseTime) {
-        const so = this.createStatObj();
-        this.increaseStat(so.requests, endpoint);
-    }
-    increaseStat(statObject, endpoint) {
-        let reqep = statObject.get(endpoint);
-        if (!reqep)
-            reqep = 0;
-        reqep += 1;
-        statObject.set(endpoint, reqep);
-        this.registeredActions++;
-    }
-    createStatObj() {
-        const d = new Date();
-        const dtm = this.getDateIndex(d);
-        let day = this.httpRequests.get(dtm);
-        if (!day) {
-            day = new Map();
-            this.httpRequests.set(dtm, day);
-            if (this.httpRequests.size > 7) {
-                for (let i of this.httpRequests) {
-                    this.httpRequests.delete(i[0]);
-                    break;
-                }
-            }
-        }
-        const hourMinute = this.getHourMinuteIndex(d);
-        let hm = day.get(hourMinute);
-        if (!hm) {
-            hm = {
-                errors: new Map(),
-                requests: new Map(),
-                fatalErrors: new Map(),
-                apiErrors: new Map()
-            };
-            day.set(hourMinute, hm);
-        }
-        return hm;
-    }
-    createSystemStatObj() {
-        const d = new Date();
-        const dtm = this.getDateIndex(d);
-        let day = this.systemStat.get(dtm);
-        if (!day) {
-            day = new Map();
-            this.systemStat.set(dtm, day);
-            if (this.systemStat.size > 7) {
-                for (let i of this.systemStat) {
-                    this.systemStat.delete(i[0]);
-                    break;
-                }
-            }
-        }
-        const hourMinute = this.getHourMinuteIndex(d);
-        let hm = day.get(hourMinute);
-        if (!hm) {
-            hm = {
-                cpuUsage: 0,
-                memoryTotal: 0,
-                memoryUsage: {}
-            };
-            day.set(hourMinute, hm);
-        }
-        return hm;
-    }
-    getDateIndex(d) {
-        const dtm = d;
-        return parseInt(dtm.getFullYear().toString().substring(2) + this.leadZero(dtm.getMonth() + 1) + this.leadZero(dtm.getDate()));
-    }
-    getHourMinuteIndex(d) {
-        const dtm = d;
-        return this.leadZero(dtm.getHours()) + this.leadZero(dtm.getMinutes());
-    }
-    leadZero(i) {
-        if (i > 9)
-            return i + "";
-        return "0" + i;
-    }
-    async precheck(req) {
-        if (!req.headers)
-            return { error: { code: 10001, message: "No authorization", httpStatus: 400 } };
-        if (!req.headers['authorization'])
-            return { error: { code: 10002, message: "No authorization found", httpStatus: 400 } };
-        const auth = req.headers['authorization'];
-        if (!req.precheck || !Array.isArray(req.precheck.data)) {
-            return { error: { code: 10003, message: "No authorization records found", httpStatus: 400 } };
-        }
-        let authorized = false;
-        for (let i of req.precheck.data) {
-            let expectationStr = "";
-            expectationStr += req.endpoint;
-            expectationStr += JSON.stringify(i);
-            expectationStr += JSON.stringify(req.method);
-            expectationStr += JSON.stringify(req.data);
-            expectationStr += JSON.stringify(req.params);
-            const expectation = "sha256 " + crypto_1.default.createHash("sha256").update(expectationStr).digest().toString("hex");
-            if (auth === expectation) {
-                authorized = true;
-                break;
-            }
-        }
-        if (!authorized) {
-            console.error("Wrong token: " + auth);
-            return { error: { code: 10004, message: "Unauthorized access", httpStatus: 401 } };
-        }
-        return null;
     }
     async logs(req) {
-        const log = await LogService_1.REQ_LOG.request(null);
-        return { data: log };
+        this.checkAuthentication(req);
+        const services = await LogService_1.REQ_LOG_UNIQUE_SERVICES.request();
+        const log = await LogService_1.REQ_LOG.request({
+            lastID: req.data.lastID ?? 0
+        });
+        return {
+            data: {
+                services,
+                log
+            }
+        };
     }
     async netlog(req) {
-        const log = await APIService_1.REQ_HTTP_LOG.request();
-        return { data: log };
+        this.checkAuthentication(req);
+        return {};
     }
     async metrics(req) {
-        const date = new Date();
-        const di = this.getDateIndex(date);
-        const stat = this.httpRequests.get(di);
-        let result = [];
-        if (stat) {
-            for (let minutes of stat) {
-                result.push({
-                    m: minutes[0],
-                    ae: this.mapToKeyValue(minutes[1].apiErrors),
-                    e: this.mapToKeyValue(minutes[1].errors),
-                    r: this.mapToKeyValue(minutes[1].requests),
-                    fe: this.mapToKeyValue(minutes[1].fatalErrors),
-                });
-            }
-        }
-        const ua = this.userActions.get(di);
-        let uaResult = [];
-        if (ua) {
-            for (let i of ua) {
-                const minutes = i[1];
-                const mArray = [];
-                for (let j of i[0]) {
-                    mArray.push({
-                        action: j[0],
-                        count: j[1]
-                    });
-                }
-                result.push({
-                    m: i[0],
-                    data: mArray
-                });
-            }
-        }
-        return { data: { stat: result, date: +date, userActions: uaResult } };
+        this.checkAuthentication(req);
+        const result = await MonitorService_1.REQ_EP_STAT.request(req.data);
+        return { data: result };
     }
     async serverStat(req) {
-        const date = new Date();
-        const di = this.getDateIndex(date);
-        const stat = this.systemStat.get(di);
-        if (!stat)
-            return { data: [] };
-        let result = [];
-        for (let minutes of stat) {
-            result.push({
-                m: minutes[0],
-                mt: minutes[1].memoryTotal,
-                mu: minutes[1].memoryUsage,
-                cu: minutes[1].cpuUsage,
-            });
+        this.checkAuthentication(req);
+        let stat = {
+            cpuUsage: os_1.default.cpus(),
+            memoryTotal: os_1.default.totalmem(),
+            memoryUsage: os_1.default.freemem()
+        };
+        return { data: stat };
+    }
+    async checkAuthentication(req) {
+        const users = await APIService_1.REQ_MONITOR_USERS.request();
+        const header = req.headers['authorization'];
+        if (!header)
+            throw { ...DefaultErrors_1.default.UNAUTHORIZED, details: "No authorization header found" };
+        for (let i of users) {
+            let hashStr = "";
+            hashStr += req.endpoint;
+            hashStr += JSON.stringify(i);
+            hashStr += JSON.stringify(req.method.toUpperCase());
+            hashStr += JSON.stringify(req.data ?? {});
+            hashStr += JSON.stringify(req.params ?? {});
+            let token = null;
+            token = "sha256 " + crypto_1.default.createHash('sha256').update(hashStr).digest('hex');
+            if (token == header) {
+                return true;
+            }
         }
-        return { data: {
-                registeredActions: this.registeredActions,
-                uptime: process.uptime(),
-                osUptime: os_1.default.uptime(),
-                stat: result
-            } };
-    }
-    mapToKeyValue(map) {
-        const res = [];
-        for (let i of map)
-            res.push({ name: i[0], value: i[1] });
-        return res;
+        throw { ...DefaultErrors_1.default.UNAUTHORIZED, details: "Invalid token" };
     }
 }
 exports.Monitor = Monitor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "2.8.4",
+  "version": "2.8.6",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",