badmfck-api-server 4.1.25 → 4.1.27

package/dist/apiServer/BaseEndpoint.d.ts

@@ -37,6 +37,7 @@ export interface IEndpointHandler {
     resultModel?: any;
 }
 export declare class BaseEndpoint implements IBaseEndpoint {
+    static allInstances: BaseEndpoint[];
     private inializedEndpointNames;
     description: string;
     endpoints?: IEndpointHandler[];
@@ -44,6 +45,8 @@ export declare class BaseEndpoint implements IBaseEndpoint {
     ignoreInDocumentation: boolean;
     private static entrypoint;
     endpoint: string;
+    createdAt: number;
+    initializedAt: number | null;
     protected streamOptions: Record<string, any>;
     static setEntryPoint: (ep: string) => void;
     static getEntryPoint: () => string;
@@ -51,6 +54,29 @@ export declare class BaseEndpoint implements IBaseEndpoint {
     registerEndpoints(endpoints: IEndpointHandler[]): void;
     init(): Promise<void>;
     getInitalizedEndpointNames(): String[];
+    getInventory(): {
+        className: string;
+        basePath: string;
+        ignoreHttpLogging: boolean;
+        ignoreInDocumentation: boolean;
+        description: string;
+        createdAt: number;
+        initializedAt: number | null;
+        handlerCount: number;
+        handlers: {
+            path: string;
+            methods: string[];
+            ignoreInterceptor: boolean;
+            ignoreInDocumentation: boolean;
+            ignoreHttpLogging: boolean;
+            independed: boolean;
+            asStream: boolean;
+            hasValidationModel: boolean;
+            hasResultModel: boolean;
+            description?: string | undefined;
+            title?: string | undefined;
+        }[];
+    };
     __precheck(req: HTTPRequestVO): Promise<TransferPacketVO<any> | null>;
     __execute(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
     protected validateStructure(structure: any, req: HTTPRequestVO): Promise<void>;

package/dist/apiServer/BaseEndpoint.js

@@ -10,6 +10,7 @@ const DefaultErrors_1 = __importDefault(require("./structures/DefaultErrors"));
 const stream_1 = require("stream");
 const httpMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"];
 class BaseEndpoint {
+    static allInstances = [];
     inializedEndpointNames = [];
     description = "no description";
     endpoints;
@@ -17,6 +18,8 @@ class BaseEndpoint {
     ignoreInDocumentation = false;
     static entrypoint = "/";
     endpoint = "";
+    createdAt = Date.now();
+    initializedAt = null;
     streamOptions = {};
     static setEntryPoint = (ep) => {
         this.entrypoint = ep;
@@ -35,6 +38,7 @@ class BaseEndpoint {
         if (!endpoint.endsWith("/"))
             endpoint = endpoint + "/";
         this.endpoint = endpoint;
+        BaseEndpoint.allInstances.push(this);
     }
     registerEndpoints(endpoints) {
         for (let i of endpoints) {
@@ -63,11 +67,65 @@ class BaseEndpoint {
             (0, LogService_1.logInfo)("${BaseEndpoint.js}", "endpoint: " + i.endpoint + " initalized, ignoreInterceptor: " + (i.ignoreInterceptor ?? "false"));
             this.inializedEndpointNames.push(i.endpoint + " ignore interceptor: " + (i.ignoreInterceptor ?? "false"));
         }
+        this.initializedAt = Date.now();
     }
     ;
     getInitalizedEndpointNames() {
         return this.inializedEndpointNames;
     }
+    getInventory() {
+        const handlers = [];
+        for (const i of this.endpoints ?? []) {
+            let methods = [];
+            let asStream = i.asStream === true;
+            let hasVm = i.validationModel !== undefined;
+            let hasRm = i.resultModel !== undefined;
+            if (typeof i.handler === "function") {
+                methods = ["ANY"];
+            }
+            else if (i.handler && typeof i.handler === "object") {
+                for (const key of Object.keys(i.handler)) {
+                    const h = i.handler[key];
+                    if (typeof h === "function") {
+                        methods.push(key);
+                    }
+                    else if (h && typeof h === "object" && typeof h.controller === "function") {
+                        methods.push(key);
+                        if (h.asStream)
+                            asStream = true;
+                        if (h.validationModel !== undefined)
+                            hasVm = true;
+                        if (h.resultModel !== undefined)
+                            hasRm = true;
+                    }
+                }
+            }
+            handlers.push({
+                path: (BaseEndpoint.entrypoint + i.endpoint).replaceAll("//", "/"),
+                methods,
+                ignoreInterceptor: i.ignoreInterceptor === true,
+                ignoreInDocumentation: i.ignoreInDocumentation === true,
+                ignoreHttpLogging: i.ignoreHttpLogging === true,
+                independed: i.independed === true,
+                asStream,
+                hasValidationModel: hasVm,
+                hasResultModel: hasRm,
+                description: i.description,
+                title: i.title,
+            });
+        }
+        return {
+            className: this.constructor.name,
+            basePath: this.endpoint,
+            ignoreHttpLogging: this.ignoreHttpLogging,
+            ignoreInDocumentation: this.ignoreInDocumentation,
+            description: this.description,
+            createdAt: this.createdAt,
+            initializedAt: this.initializedAt,
+            handlerCount: handlers.length,
+            handlers,
+        };
+    }
     async __precheck(req) { return null; }
     async __execute(req) {
         if (this.endpoints && this.endpoints.length > 0) {

package/dist/apiServer/BaseService.d.ts

@@ -4,7 +4,11 @@ export interface IBaseService {
     getName: () => string;
 }
 export declare class BaseService implements IBaseService {
+    static allInstances: BaseService[];
     protected name: string;
+    createdAt: number;
+    initializedAt: number | null;
+    applicationReadyAt: number | null;
     constructor(name: string);
     init(): Promise<void>;
     finishService(): Promise<void>;

package/dist/apiServer/BaseService.js

@@ -11,14 +11,20 @@ process.on('SIGTERM', async () => {
     process.exit(0);
 });
 class BaseService {
+    static allInstances = [];
     name = "BaseService";
+    createdAt = Date.now();
+    initializedAt = null;
+    applicationReadyAt = null;
     constructor(name) {
         this.name = name;
         this.finishService = this.finishService.bind(this);
+        BaseService.allInstances.push(this);
     }
     async init() {
         console.log("Service: " + this.name + " initialized");
         finalize.push(this.finishService);
+        this.initializedAt = Date.now();
     }
     async finishService() {
         console.log("finishService -> " + (this.name ?? "no-name"));
@@ -26,6 +32,8 @@ class BaseService {
     getName() {
         return this.name;
     }
-    applicationReady() { }
+    applicationReady() {
+        this.applicationReadyAt = Date.now();
+    }
 }
 exports.BaseService = BaseService;

package/dist/apiServer/LogService.d.ts

@@ -62,4 +62,9 @@ export declare class LogService extends BaseService {
     createDate(d?: Date): string;
     leadZero(num: number): string;
     createText(data: any, level: LOG_LEVEL): string;
+    private static readonly SANITIZERS;
+    static sanitize(text: string): string;
+    private static readonly PAN_CANDIDATE_REGEX;
+    private static isLuhnValid;
+    static maskPAN(text: string): string;
 }

package/dist/apiServer/LogService.js

@@ -244,7 +244,54 @@ class LogService extends BaseService_1.BaseService {
         }
         if (res.length > this.options.textLimit && level === LOG_LEVEL.INFO)
             res = res.substring(0, this.options.textLimit) + "... (total: " + res.length + ")";
+        res = LogService.sanitize(res);
         return res;
     }
+    static SANITIZERS = [
+        [/-----BEGIN [A-Z0-9 ]+-----[\s\S]+?-----END [A-Z0-9 ]+-----/g, "<REDACTED PEM>"],
+        [/eyJ[A-Za-z0-9_-]{5,}\.eyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]+/g, "<REDACTED JWT>"],
+        [/(Bearer|Basic|Digest)\s+[A-Za-z0-9\-._~+\/=]+/gi, "$1 <REDACTED>"],
+        [/%B\d{13,19}\^[^?]{2,50}\^\d{4,}[^?]*\?/g, "<REDACTED TRACK1>"],
+        [/;\d{13,19}=\d{4,}[^?]*\?/g, "<REDACTED TRACK2>"],
+        [/("(?:password|passwd|pwd|secret|api[_-]?key|api[_-]?secret|client[_-]?secret|access[_-]?key|private[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|token|authorization|cookie|set[_-]?cookie|session[_-]?id|sess[_-]?id|sid|cvv2?|cvc2?|cvn|cav2?|cid|security[_-]?code|card[_-]?verification[_-]?(?:value|code)?|pin|pin[_-]?block|encrypted[_-]?pin|iso[_-]?9564|exp|expiry|expiration|expiration[_-]?date|exp[_-]?date|exp[_-]?month|exp[_-]?year|cardholder[_-]?name|holder[_-]?name|card[_-]?holder)"\s*:\s*)"[^"]*"/gi, '$1"<REDACTED>"'],
+        [/("(?:cvv2?|cvc2?|pin|exp[_-]?month|exp[_-]?year|service[_-]?code)"\s*:\s*)(-?\d+)/gi, '$1"<REDACTED>"'],
+    ];
+    static sanitize(text) {
+        if (!text || text.length < 3)
+            return text;
+        let out = text;
+        for (const [re, repl] of LogService.SANITIZERS)
+            out = out.replace(re, repl);
+        return LogService.maskPAN(out);
+    }
+    static PAN_CANDIDATE_REGEX = /(?<!\d)(?:\d[ -]?){12,18}\d(?!\d)/g;
+    static isLuhnValid(digits) {
+        if (digits.length < 13 || digits.length > 19)
+            return false;
+        let sum = 0;
+        let alt = false;
+        for (let i = digits.length - 1; i >= 0; i--) {
+            const d = digits.charCodeAt(i) - 48;
+            if (d < 0 || d > 9)
+                return false;
+            let x = d;
+            if (alt) {
+                x *= 2;
+                if (x > 9)
+                    x -= 9;
+            }
+            sum += x;
+            alt = !alt;
+        }
+        return sum % 10 === 0;
+    }
+    static maskPAN(text) {
+        if (!text || text.length < 13)
+            return text;
+        return text.replace(LogService.PAN_CANDIDATE_REGEX, (match) => {
+            const digits = match.replace(/\D/g, "");
+            return LogService.isLuhnValid(digits) ? "xxxx...xxxx" : match;
+        });
+    }
 }
 exports.LogService = LogService;