badmfck-api-server 1.5.1 → 1.5.3

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,7 @@ export declare class APIService extends BaseService {
     private static nextLogID;
     private version;
     private options;
+    private monitor?;
     netLog: APIServiceNetworkLogItem[];
     constructor(options?: APIServiceOptions | null);
     init(): Promise<void>;

package/dist/apiServer/APIService.js

@@ -11,6 +11,7 @@ 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");
 function getDefaultOptions() {
     return {
         port: 8091,
@@ -43,8 +44,9 @@ async function Initializer(services) {
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
     static nextLogID = 0;
-    version = "1.5.0";
+    version = "1.5.3";
     options;
+    monitor;
     netLog = [];
     constructor(options) {
         super('HTTP Service');
@@ -54,6 +56,11 @@ 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");
+        }
     }
     async init() {
         exports.REQ_HTTP_LOG.listener = async (ignore) => this.netLog;
@@ -141,19 +148,29 @@ class APIService extends BaseService_1.BaseService {
                                 let interceptorResult;
                                 if (this.options.interceptor) {
                                     interceptorResult = await this.options.interceptor.execute(httpRequest);
-                                    if (interceptorResult.error) {
+                                    if (interceptorResult.error && !j.allowInterceptorError) {
                                         this.sendResponse(res, interceptorResult, tme, ep, log);
                                         return;
                                     }
                                     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: {
@@ -186,6 +203,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 +212,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 +240,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 +250,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;
 }
@@ -10,6 +11,7 @@ export interface IEndpointHandler {
     handler?: (req: HTTPRequestVO) => Promise<TransferPacketVO<any>>;
     ignoreInterceptor?: boolean;
     independed?: boolean;
+    allowInterceptorError?: boolean;
 }
 export declare class BaseEndpoint implements IBaseEndpoint {
     endpoints?: IEndpointHandler[];
@@ -21,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,32 @@
+import { BaseEndpoint } from "../BaseEndpoint";
+import { HTTPRequestVO, TransferPacketVO } from "../structures/Interfaces";
+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,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Monitor = void 0;
+const APIService_1 = require("../APIService");
+const BaseEndpoint_1 = require("../BaseEndpoint");
+const LogService_1 = require("../LogService");
+const crypto_1 = __importDefault(require("crypto"));
+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.1",
+  "version": "1.5.3",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",