badmfck-api-server 1.5.2 → 1.5.4

package/dist/apiServer/APIService.d.ts

@@ -25,6 +25,10 @@ export interface APIServiceOptions {
     onError?: ((...rest: any[]) => void) | null;
     isProductionEnvironment: boolean;
     interceptor?: IBaseEndpoint;
+    monitor?: {
+        login: string;
+        password: string;
+    }[];
 }
 export declare function getDefaultOptions(): APIServiceOptions;
 export declare const REQ_CREATE_NET_LOG: Req<void, APIServiceNetworkLogItem>;
@@ -34,6 +38,8 @@ export declare class APIService extends BaseService {
     private static nextLogID;
     private version;
     private options;
+    private monitor?;
+    private monitorIndexFile?;
     netLog: APIServiceNetworkLogItem[];
     constructor(options?: APIServiceOptions | null);
     init(): Promise<void>;

package/dist/apiServer/APIService.js

@@ -11,6 +11,10 @@ const BaseEndpoint_1 = require("./BaseEndpoint");
 const DefaultErrors_1 = __importDefault(require("./structures/DefaultErrors"));
 const badmfck_signal_1 = require("badmfck-signal");
 const LogService_1 = require("./LogService");
+const Monitor_1 = require("./monitor/Monitor");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
 function getDefaultOptions() {
     return {
         port: 8091,
@@ -43,8 +47,10 @@ async function Initializer(services) {
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
     static nextLogID = 0;
-    version = "1.5.2";
+    version = "1.5.4";
     options;
+    monitor;
+    monitorIndexFile;
     netLog = [];
     constructor(options) {
         super('HTTP Service');
@@ -54,6 +60,16 @@ class APIService extends BaseService_1.BaseService {
         const self = "http://localhost:" + this.options.port;
         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.log("Service Monitor initialized");
+            console.log("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.log("/sm-" + hash);
+            }
+        }
     }
     async init() {
         exports.REQ_HTTP_LOG.listener = async (ignore) => this.netLog;
@@ -148,12 +164,22 @@ 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(res, precheck, tme, ep, log);
+                                return;
+                            }
+                            httpRequest.precheck = precheck;
                             result = await i.execute(httpRequest);
                         }
                         catch (e) {
                             console.error(e);
                             if (this.options.onError)
                                 this.options.onError(e);
+                            if (this.monitor)
+                                this.monitor.registrateFatalError(ep);
                             this.sendResponse(res, {
                                 httpStatus: 500,
                                 error: {
@@ -172,6 +198,40 @@ class APIService extends BaseService_1.BaseService {
         }
         app.use((req, res, next) => {
             const tme = +new Date();
+            if (this.monitor && this.options && this.options.monitor) {
+                if (req.method === "GET") {
+                    let monitorRequest = false;
+                    for (let i of this.options.monitor) {
+                        const hash = crypto_1.default.createHash("sha256").update(i.login + i.password).digest().toString("hex");
+                        if (req.originalUrl.endsWith("/sm-" + hash)) {
+                            monitorRequest = true;
+                            break;
+                        }
+                    }
+                    if (monitorRequest) {
+                        const date = new Date();
+                        try {
+                            if (!this.monitorIndexFile)
+                                this.monitorIndexFile = fs_1.default.readFileSync(path_1.default.resolve(__dirname, "monitor", "index.html"));
+                            res.setHeader("Content-Type", "text/html");
+                            res.setHeader("Content-Length", this.monitorIndexFile.byteLength);
+                            res.status(200).send(this.monitorIndexFile);
+                        }
+                        catch (e) {
+                            this.sendResponse(res, {
+                                error: {
+                                    code: 10002,
+                                    message: "Internal server error",
+                                    details: `${e}`
+                                },
+                                data: null,
+                                httpStatus: 500
+                            }, tme, req.path);
+                        }
+                        return;
+                    }
+                }
+            }
             this.sendResponse(res, {
                 error: DefaultErrors_1.default.UNKNOWN_REQUEST,
                 data: null,
@@ -186,6 +246,8 @@ class APIService extends BaseService_1.BaseService {
         data.responseTime = (+new Date()) - requestTime;
         data.version = this.version;
         data.endpoint = endpoint ?? "no_endpoint";
+        if (this.monitor)
+            this.monitor.registrateResponse(data.endpoint, data.responseTime);
         if (log)
             log.time = data.responseTime;
         if (res.destroyed || res.closed) {
@@ -193,6 +255,8 @@ class APIService extends BaseService_1.BaseService {
                 log.error = "Connection already closed, can't send response";
             if (this.options.onError)
                 this.options.onError("Connection already closed, can't send response", data);
+            if (this.monitor)
+                this.monitor.registrateError(data.endpoint);
         }
         else {
             try {
@@ -219,6 +283,8 @@ class APIService extends BaseService_1.BaseService {
                         res.send(data);
                         if (log)
                             log.response = data;
+                        if (data.error && this.monitor)
+                            this.monitor.registrateAPIError(data.endpoint);
                     }
                 }
             }
@@ -227,6 +293,8 @@ 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 (this.options.onNetworkLog && log)

package/dist/apiServer/BaseEndpoint.d.ts

@@ -2,6 +2,7 @@ import { HTTPRequestVO, TransferPacketVO } from "./structures/Interfaces";
 export interface IBaseEndpoint {
     endpoints?: IEndpointHandler[];
     execute: (req: HTTPRequestVO) => Promise<TransferPacketVO<any>>;
+    precheck: (req: HTTPRequestVO) => Promise<TransferPacketVO<any> | null>;
     init: () => Promise<void>;
     ignoreHttpLogging: boolean;
 }
@@ -22,5 +23,6 @@ export declare class BaseEndpoint implements IBaseEndpoint {
     constructor(endpoint: string);
     registerEndpoints(endpoints: IEndpointHandler[]): void;
     init(): Promise<void>;
+    precheck(req: HTTPRequestVO): Promise<TransferPacketVO<any> | null>;
     execute(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
 }

package/dist/apiServer/BaseEndpoint.js

@@ -56,6 +56,7 @@ class BaseEndpoint {
             (0, LogService_1.logInfo)("${BaseEndpoint.js}", "endpoint: " + i.endpoint + " initalized, ignoreInterceptor: " + (i.ignoreInterceptor ?? "false"));
     }
     ;
+    async precheck(req) { return null; }
     async execute(req) {
         if (this.endpoints && this.endpoints.length > 0) {
             for (let i of this.endpoints) {

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

@@ -0,0 +1,33 @@
+import { BaseEndpoint } from "../BaseEndpoint";
+import { HTTPRequestVO, TransferPacketVO } from "../structures/Interfaces";
+export declare const indexFilePath: string;
+interface IStatObject {
+    requests: Map<string, number>;
+    errors: Map<string, number>;
+    fatalErrors: Map<string, number>;
+    apiErrors: Map<string, number>;
+}
+export declare class Monitor extends BaseEndpoint {
+    ignoreHttpLogging: boolean;
+    private startedAt;
+    private httpRequests;
+    constructor();
+    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;
+    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>>;
+    mapToKeyValue(map: Map<string, number>): {
+        name: string;
+        value: number;
+    }[];
+}
+export {};

package/dist/apiServer/monitor/Monitor.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Monitor = exports.indexFilePath = void 0;
+const APIService_1 = require("../APIService");
+const BaseEndpoint_1 = require("../BaseEndpoint");
+const LogService_1 = require("../LogService");
+const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
+exports.indexFilePath = path_1.default.resolve(__dirname, "index.html");
+class Monitor extends BaseEndpoint_1.BaseEndpoint {
+    ignoreHttpLogging = true;
+    startedAt = new Date();
+    httpRequests = new Map();
+    constructor() {
+        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 }
+        ]);
+    }
+    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);
+    }
+    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 > 14) {
+                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()
+            };
+        }
+        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 (!Array.isArray(req.precheck)) {
+            return { error: { code: 10003, message: "No authorization records found", httpStatus: 400 } };
+        }
+        let authorized = false;
+        for (let i of req.precheck) {
+            let expectationStr = "";
+            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 };
+    }
+    async netlog(req) {
+        const log = await APIService_1.REQ_HTTP_LOG.request();
+        return { data: log };
+    }
+    async metrics(req) {
+        const date = new Date();
+        const di = this.getDateIndex(date);
+        const stat = this.httpRequests.get(di);
+        if (!stat)
+            return { data: [] };
+        let result = [];
+        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),
+            });
+        }
+        return { data: { stat: result, date: +date } };
+    }
+    mapToKeyValue(map) {
+        const res = [];
+        for (let i of map)
+            res.push({ name: i[0], value: i[1] });
+        return res;
+    }
+}
+exports.Monitor = Monitor;

package/dist/apiServer/structures/Interfaces.d.ts

@@ -21,6 +21,7 @@ export interface HTTPRequestVO {
     headers: any;
     endpoint: string;
     interceptorResult?: TransferPacketVO<any>;
+    precheck?: TransferPacketVO<any> | null;
 }
 export interface IError {
     code: number;

package/package.json

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