badmfck-api-server 3.9.89 → 3.9.93

package/dist/apiServer/APIService.d.ts

@@ -23,7 +23,7 @@ export interface APIServiceNetworkLogItem {
     error?: string | null;
 }
 export interface IInterceptor<T> {
-    intercept(req: HTTPRequestVO<any>): Promise<T | IError>;
+    intercept(req: HTTPRequestVO<any>, internalCallParams: any): Promise<T | IError>;
 }
 export interface APIServiceOptions<TInterceptor = unknown> {
     port: number;
@@ -58,7 +58,7 @@ export declare const REQ_INTERNAL_CALL: Req<HTTPRequestVO, IError | any>;
 export declare const REQ_MONITOR_USERS: Req<void, IMonitorUser[]>;
 export declare const REQ_DOC_USERS: Req<void, IMonitorUser[]>;
 export declare function Initializer(services: IBaseService[]): Promise<void>;
-export declare class APIService extends BaseService {
+export declare class APIService<TInterceptorResult = any, TInternalCallParams = any> extends BaseService {
     private version;
     private options;
     private monitor;

package/dist/apiServer/APIService.js

@@ -92,7 +92,7 @@ async function Initializer(services) {
 }
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
-    version = "3.9.86";
+    version = "3.9.94";
     options;
     monitor = null;
     started = new Date();
@@ -273,7 +273,7 @@ class APIService extends BaseService_1.BaseService {
                             if (!ignoreInterceptor) {
                                 let interceptorResult;
                                 if (this.options.interceptor) {
-                                    interceptorResult = await this.options.interceptor.intercept(httpRequest);
+                                    interceptorResult = await this.options.interceptor.intercept(httpRequest, j.internalCallParams);
                                     if (DefaultErrors_1.ErrorUtils.isError(interceptorResult) && !allowInterceptorError) {
                                         this.sendResponse(req.get("Referer") ?? "", res, interceptorResult, tme, ep, httpRequest);
                                         return;

package/dist/apiServer/BaseEndpoint.d.ts

@@ -11,6 +11,7 @@ type HTTPMethod = typeof httpMethods[number];
 export type IHandler = Record<HTTPMethod, ((req: HTTPRequestVO) => Promise<TransferPacketVO<any>>) | {
     controller: (req: HTTPRequestVO) => Promise<TransferPacketVO<any>>;
     ignoreInterceptor?: boolean;
+    internalCallParams?: any;
     allowInterceptorError?: boolean;
     validationModel?: any;
     resultModel?: any;
@@ -24,6 +25,7 @@ export interface IEndpointHandler {
     endpoint: string;
     handler?: ((req: HTTPRequestVO) => Promise<TransferPacketVO<any>>) | IHandler;
     ignoreInterceptor?: boolean;
+    internalCallParams?: any;
     ignoreInDocumentation?: boolean;
     ignoreHttpLogging?: boolean;
     independed?: boolean;

package/dist/apiServer/DBService.js

@@ -204,6 +204,8 @@ class DBService extends BaseService_1.BaseService {
             };
         };
         exports.REQ_DB.listener = async (req) => {
+            if (req.fields)
+                req.fields = JSON.parse(JSON.stringify(req.fields));
             const executionStartTime = Date.now();
             if (!req.dbid && DBService.allInstances.length === 1 && DBService.allInstances[0].adapter) {
                 const result = await DBService.allInstances[0].adapter.query(req);

package/dist/apiServer/LocalRequest.js

@@ -1,32 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalRequest = void 0;
-const axios_1 = __importDefault(require("axios"));
 const LocalRequest = async (ep, data, method, headers) => {
-    let m = "get";
-    if (method)
-        m = method.toLowerCase();
-    if (data && !method)
-        m = "post";
-    if (ep.startsWith("/"))
-        ep = ep.substring(1);
-    let url = "http://localhost:8091/" + ep;
-    if (ep.toLowerCase().startsWith("http"))
-        url = ep;
-    let resp = null;
-    console.log("open url: ", url);
-    try {
-        if (m === "get")
-            resp = await axios_1.default.get(url, { headers: headers });
-        if (m === "post")
-            resp = await axios_1.default.post(url, data, { headers: headers });
-    }
-    catch (e) {
-        console.log("ERROR! cant open url", e);
-    }
-    console.log(resp);
 };
 exports.LocalRequest = LocalRequest;

package/dist/apiServer/external/ExternalService.js

@@ -33,7 +33,6 @@ const DefaultErrors_1 = __importStar(require("../structures/DefaultErrors"));
 const Validator_1 = require("../helper/Validator");
 const UID_1 = require("../helper/UID");
 const crypto_1 = __importDefault(require("crypto"));
-const axios_1 = __importDefault(require("axios"));
 exports.REQ_EXTERNAL_CALL = new badmfck_signal_1.Req(undefined, "REQ_EXTERNAL_CALL");
 exports.REQ_XT = new badmfck_signal_1.Req(undefined, "REQ_XT");
 exports.REQ_XT.listener = async ({ id, req }) => {
@@ -90,31 +89,8 @@ class ExternalService extends BaseService_1.BaseService {
         if (this.options.url.endsWith("/"))
             this.options.url = this.options.url.substring(0, this.options.url.length - 1);
         try {
-            const resp = await axios_1.default.post(this.options.url + "/external/call/" + this.options.id, encrypted.data, {
-                headers: {
-                    "authorization": encrypted.authorization,
-                    "Content-Type": "application/json",
-                    "Accept": "application/json"
-                }
-            });
-            const data = resp.data;
-            if (typeof data === "object" && "error" in data)
-                return data.error;
-            if (typeof data === "object" && "data" in data)
-                return data.data;
-            return data;
         }
         catch (e) {
-            const err = e;
-            if (err.response && err.response.data)
-                console.log("ExternalService.requestExternalCall", err.response.data);
-            else
-                console.error("ExternalService.requestExternalCall", err.cause);
-            if (err.response) {
-                if (err.response.data && typeof err.response.data === "object" && "error" in err.response.data)
-                    return err.response.data.error;
-            }
-            return { ...DefaultErrors_1.default.BAD_REQUEST, details: err.cause?.message };
         }
     }
     async onExternalCall(req) {

package/dist/apiServer/helper/Validator.js

@@ -153,6 +153,20 @@ class Validator {
                 else
                     object[i] = num;
             }
+            if (typeof structure[i] === "boolean") {
+                if (typeof object[i] === "number") {
+                    if (object[i] === 1)
+                        object[i] = true;
+                    if (object[i] === 0)
+                        object[i] = false;
+                }
+                if (typeof object[i] === "string") {
+                    if (object[i].trim().toLowerCase() === "true")
+                        object[i] = true;
+                    if (object[i].trim().toLowerCase() === "false")
+                        object[i] = false;
+                }
+            }
             if (typeof object[i] !== typeof structure[i])
                 errors.push("wrong datatype for field '" + i + "' expected " + typeof structure[i] + " got " + typeof object[i]);
             if (typeof structure[i] === "object" || typeof structure[i] === "function") {

package/dist/apiServer/http/HReq.js

@@ -0,0 +1 @@
+"use strict";

package/dist/apiServer/http/HTTP.d.ts

@@ -0,0 +1,97 @@
+import { Dispatcher, Agent } from "undici";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type THttpOk<T> = {
+    ok: true;
+    status: number;
+    data: T;
+    headers: Record<string, string>;
+};
+export type THttpErr<E = any> = {
+    ok: false;
+    status?: number;
+    error: E;
+    details?: any;
+};
+export type THttpResult<T, E = any> = THttpOk<T> | THttpErr<E>;
+export type TRetryPolicy = {
+    enabled?: boolean;
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    retryOnStatuses?: number[];
+    retryOnNetworkErrors?: boolean;
+};
+export type THttpConfig = {
+    baseUrl?: string;
+    dispatcher?: Dispatcher;
+    timeoutMs?: number;
+    headers?: Record<string, string>;
+    retry?: TRetryPolicy;
+    onRequest?: (ctx: {
+        method: HttpMethod;
+        url: string;
+        attempt: number;
+    }) => void;
+    onResponse?: (ctx: {
+        method: HttpMethod;
+        url: string;
+        attempt: number;
+        status: number;
+        ms: number;
+    }) => void;
+    onError?: (ctx: {
+        method: HttpMethod;
+        url: string;
+        attempt: number;
+        ms: number;
+        err: unknown;
+    }) => void;
+};
+export type TRequestOptions = {
+    method: HttpMethod;
+    url: string;
+    query?: Record<string, string | number | boolean | null | undefined>;
+    headers?: Record<string, string>;
+    body?: any;
+    timeoutMs?: number;
+    dispatcher?: Dispatcher;
+    responseType?: "json" | "text" | "raw";
+    throwOnJsonParseError?: boolean;
+    retry?: TRetryPolicy;
+    allowBody?: boolean;
+};
+export declare class Http {
+    private static _inited;
+    private static config;
+    private static _sharedAgent;
+    private static _dcEnabled;
+    private static _dcConnectedChannel;
+    private static _dcListener;
+    private static _activeConnectionsTotal;
+    private static _activeConnectionsByHost;
+    private static _countedSockets;
+    private static _socketHostKey;
+    private static ensureInit;
+    static configure(partial: Partial<THttpConfig>): void;
+    static createAgent(opts?: ConstructorParameters<typeof Agent>[0]): Agent;
+    static closeSharedAgent(): void;
+    static basicAuth(username: string, password: string): string;
+    static bearer(token: string): string;
+    static enableConnectionCounterByHost(): void;
+    static disableConnectionCounterByHost(options?: {
+        reset?: boolean;
+    }): void;
+    private static _makeHostKey;
+    static getActiveConnectionsTotal(): number;
+    static getActiveConnectionsByHost(): Map<string, number>;
+    static getActiveConnectionsSnapshot(): {
+        total: number;
+        byHost: Record<string, number>;
+    };
+    static request<T = any, E = any>(opts: TRequestOptions): Promise<THttpResult<T, E>>;
+    static get<T = any, E = any>(url: string, opts?: Omit<TRequestOptions, "method" | "url">): Promise<THttpResult<T, E>>;
+    static post<T = any, E = any>(url: string, body?: any, opts?: Omit<TRequestOptions, "method" | "url" | "body">): Promise<THttpResult<T, E>>;
+    static put<T = any, E = any>(url: string, body?: any, opts?: Omit<TRequestOptions, "method" | "url" | "body">): Promise<THttpResult<T, E>>;
+    static patch<T = any, E = any>(url: string, body?: any, opts?: Omit<TRequestOptions, "method" | "url" | "body">): Promise<THttpResult<T, E>>;
+    static delete<T = any, E = any>(url: string, opts?: Omit<TRequestOptions, "method" | "url">): Promise<THttpResult<T, E>>;
+}

package/dist/apiServer/http/HTTP.js

@@ -0,0 +1,356 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Http = void 0;
+const undici_1 = require("undici");
+const node_diagnostics_channel_1 = __importDefault(require("node:diagnostics_channel"));
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function clamp(n, min, max) {
+    return Math.max(min, Math.min(max, n));
+}
+function buildQuery(query) {
+    if (!query)
+        return "";
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(query)) {
+        if (v === null || v === undefined)
+            continue;
+        params.set(k, String(v));
+    }
+    const s = params.toString();
+    return s ? `?${s}` : "";
+}
+function mergeHeaders(a, b) {
+    return { ...(a || {}), ...(b || {}) };
+}
+function normalizeHeaders(headers) {
+    const out = {};
+    if (!headers || typeof headers !== "object")
+        return out;
+    for (const [k, v] of Object.entries(headers)) {
+        if (Array.isArray(v))
+            out[k.toLowerCase()] = v.join(", ");
+        else if (v !== undefined && v !== null)
+            out[k.toLowerCase()] = String(v);
+    }
+    return out;
+}
+function isRetryableStatus(status, retryOnStatuses) {
+    return retryOnStatuses.includes(status);
+}
+function isLikelyNetworkError(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    const anyErr = err;
+    if (anyErr?.name === "AbortError")
+        return true;
+    const code = anyErr?.code;
+    const networkCodes = new Set(["ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "EAI_AGAIN", "ENOTFOUND", "EPIPE"]);
+    if (code && networkCodes.has(code))
+        return true;
+    if (err instanceof undici_1.errors.ConnectTimeoutError)
+        return true;
+    if (err instanceof undici_1.errors.HeadersTimeoutError)
+        return true;
+    if (err instanceof undici_1.errors.BodyTimeoutError)
+        return true;
+    if (err instanceof undici_1.errors.SocketError)
+        return true;
+    return false;
+}
+class Http {
+    static _inited = false;
+    static config = {
+        baseUrl: "",
+        timeoutMs: 5000,
+        headers: {
+            accept: "application/json",
+        },
+        retry: {
+            enabled: true,
+            maxAttempts: 2,
+            baseDelayMs: 200,
+            maxDelayMs: 1500,
+            retryOnStatuses: [429, 502, 503, 504],
+            retryOnNetworkErrors: true,
+        },
+    };
+    static _sharedAgent = null;
+    static _dcEnabled = false;
+    static _dcConnectedChannel = null;
+    static _dcListener = null;
+    static _activeConnectionsTotal = 0;
+    static _activeConnectionsByHost = new Map();
+    static _countedSockets = new WeakSet();
+    static _socketHostKey = new WeakMap();
+    static ensureInit() {
+        if (this._inited)
+            return;
+        this._inited = true;
+        this.enableConnectionCounterByHost();
+        if (!this.config.dispatcher) {
+            this._sharedAgent = this.createAgent({
+                connections: 100,
+                keepAliveTimeout: 60_000,
+                keepAliveMaxTimeout: 60_000,
+            });
+            this.config.dispatcher = this._sharedAgent;
+        }
+    }
+    static configure(partial) {
+        this.config = {
+            ...this.config,
+            ...partial,
+            headers: mergeHeaders(this.config.headers, partial.headers),
+            retry: { ...(this.config.retry || {}), ...(partial.retry || {}) },
+        };
+        if (partial.dispatcher && this._sharedAgent) {
+            try {
+                this._sharedAgent.close();
+            }
+            catch { }
+            this._sharedAgent = null;
+        }
+        this.ensureInit();
+    }
+    static createAgent(opts) {
+        return new undici_1.Agent({
+            keepAliveTimeout: 60_000,
+            keepAliveMaxTimeout: 60_000,
+            ...opts,
+        });
+    }
+    static closeSharedAgent() {
+        if (!this._sharedAgent)
+            return;
+        try {
+            this._sharedAgent.close();
+        }
+        catch { }
+        this._sharedAgent = null;
+        if (this.config.dispatcher === this._sharedAgent) {
+            this.config.dispatcher = undefined;
+        }
+    }
+    static basicAuth(username, password) {
+        const token = Buffer.from(`${username}:${password}`).toString("base64");
+        return `Basic ${token}`;
+    }
+    static bearer(token) {
+        return `Bearer ${token}`;
+    }
+    static enableConnectionCounterByHost() {
+        if (this._dcEnabled)
+            return;
+        this._dcEnabled = true;
+        const ch = node_diagnostics_channel_1.default.channel("undici:client:connected");
+        const listener = (message) => {
+            const msg = message;
+            const socket = msg?.socket;
+            if (!socket)
+                return;
+            if (this._countedSockets.has(socket))
+                return;
+            this._countedSockets.add(socket);
+            const key = this._makeHostKey(msg?.connectParams, socket);
+            this._socketHostKey.set(socket, key);
+            this._activeConnectionsTotal += 1;
+            this._activeConnectionsByHost.set(key, (this._activeConnectionsByHost.get(key) ?? 0) + 1);
+            const onClose = () => {
+                this._activeConnectionsTotal = Math.max(0, this._activeConnectionsTotal - 1);
+                const k = this._socketHostKey.get(socket) ?? "unknown://unknown:0";
+                const prev = this._activeConnectionsByHost.get(k) ?? 0;
+                const next = Math.max(0, prev - 1);
+                if (next === 0)
+                    this._activeConnectionsByHost.delete(k);
+                else
+                    this._activeConnectionsByHost.set(k, next);
+                socket.off("close", onClose);
+            };
+            socket.on("close", onClose);
+        };
+        ch.subscribe(listener);
+        this._dcConnectedChannel = ch;
+        this._dcListener = listener;
+    }
+    static disableConnectionCounterByHost(options) {
+        if (!this._dcEnabled)
+            return;
+        const ch = this._dcConnectedChannel;
+        const listener = this._dcListener;
+        if (ch && listener) {
+            ch.unsubscribe(listener);
+        }
+        this._dcConnectedChannel = null;
+        this._dcListener = null;
+        this._dcEnabled = false;
+        if (options?.reset) {
+            this._activeConnectionsTotal = 0;
+            this._activeConnectionsByHost.clear();
+            this._countedSockets = new WeakSet();
+            this._socketHostKey = new WeakMap();
+        }
+    }
+    static _makeHostKey(connectParams, socket) {
+        const protocolRaw = connectParams?.protocol || "unknown:";
+        const protocol = protocolRaw.replace(/\/+$/g, "");
+        const hostname = connectParams?.hostname || connectParams?.host;
+        let port = connectParams?.port !== undefined && connectParams?.port !== null ? String(connectParams.port) : undefined;
+        if (!port) {
+            if (protocol === "https:")
+                port = "443";
+            else if (protocol === "http:")
+                port = "80";
+            else
+                port = "?";
+        }
+        if (hostname)
+            return `${protocol}//${hostname}:${port}`;
+        const addr = socket?.remoteAddress ?? "unknown";
+        const p = socket?.remotePort ?? "?";
+        return `${protocol}//${addr}:${p}`;
+    }
+    static getActiveConnectionsTotal() {
+        return this._activeConnectionsTotal;
+    }
+    static getActiveConnectionsByHost() {
+        return new Map(this._activeConnectionsByHost);
+    }
+    static getActiveConnectionsSnapshot() {
+        return {
+            total: this._activeConnectionsTotal,
+            byHost: Object.fromEntries(this._activeConnectionsByHost.entries()),
+        };
+    }
+    static async request(opts) {
+        this.ensureInit();
+        const cfg = this.config;
+        const retryCfg = {
+            enabled: opts.retry?.enabled ?? cfg.retry?.enabled ?? true,
+            maxAttempts: opts.retry?.maxAttempts ?? cfg.retry?.maxAttempts ?? 2,
+            baseDelayMs: opts.retry?.baseDelayMs ?? cfg.retry?.baseDelayMs ?? 200,
+            maxDelayMs: opts.retry?.maxDelayMs ?? cfg.retry?.maxDelayMs ?? 1500,
+            retryOnStatuses: opts.retry?.retryOnStatuses ?? cfg.retry?.retryOnStatuses ?? [429, 502, 503, 504],
+            retryOnNetworkErrors: opts.retry?.retryOnNetworkErrors ?? cfg.retry?.retryOnNetworkErrors ?? true,
+        };
+        const timeoutMs = opts.timeoutMs ?? cfg.timeoutMs ?? 5000;
+        const dispatcher = opts.dispatcher ?? cfg.dispatcher;
+        const baseUrl = cfg.baseUrl || "";
+        const isAbsolute = /^https?:\/\//i.test(opts.url);
+        const query = buildQuery(opts.query);
+        const url = (isAbsolute ? opts.url : baseUrl + opts.url) + query;
+        const headers = mergeHeaders(cfg.headers, opts.headers);
+        let body = undefined;
+        const hasBody = opts.body !== undefined && opts.body !== null;
+        const allowBody = opts.allowBody ?? (opts.method !== "GET" && opts.method !== "DELETE");
+        if (hasBody && allowBody) {
+            const ct = (headers["content-type"] || headers["Content-Type"] || "").toLowerCase();
+            if (!ct)
+                headers["content-type"] = "application/json";
+            const ct2 = (headers["content-type"] || headers["Content-Type"] || "").toLowerCase();
+            if (ct2.includes("application/json") && typeof opts.body !== "string" && !(opts.body instanceof Buffer)) {
+                body = JSON.stringify(opts.body);
+            }
+            else {
+                body = opts.body;
+            }
+        }
+        const responseType = opts.responseType ?? "json";
+        const throwOnJsonParseError = opts.throwOnJsonParseError ?? false;
+        for (let attempt = 1; attempt <= retryCfg.maxAttempts; attempt++) {
+            const started = Date.now();
+            cfg.onRequest?.({ method: opts.method, url, attempt });
+            const controller = new AbortController();
+            const t = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const res = await (0, undici_1.request)(url, {
+                    method: opts.method,
+                    headers,
+                    body,
+                    signal: controller.signal,
+                    dispatcher,
+                });
+                const ms = Date.now() - started;
+                const status = res.statusCode;
+                cfg.onResponse?.({ method: opts.method, url, attempt, status, ms });
+                const hdrs = normalizeHeaders(res.headers);
+                let parsed = undefined;
+                let rawText;
+                if (responseType === "raw") {
+                    await res.body.dump();
+                    parsed = undefined;
+                }
+                else if (responseType === "text") {
+                    rawText = await res.body.text();
+                    parsed = rawText;
+                }
+                else {
+                    rawText = await res.body.text();
+                    if (rawText.length === 0) {
+                        parsed = null;
+                    }
+                    else {
+                        try {
+                            parsed = JSON.parse(rawText);
+                        }
+                        catch (e) {
+                            if (throwOnJsonParseError)
+                                throw e;
+                            parsed = rawText;
+                        }
+                    }
+                }
+                if (status >= 200 && status < 300) {
+                    return { ok: true, status, data: parsed, headers: hdrs };
+                }
+                const retryable = retryCfg.enabled &&
+                    isRetryableStatus(status, retryCfg.retryOnStatuses) &&
+                    attempt < retryCfg.maxAttempts;
+                if (retryable) {
+                    const backoff = clamp(retryCfg.baseDelayMs * Math.pow(2, attempt - 1), retryCfg.baseDelayMs, retryCfg.maxDelayMs);
+                    await sleep(backoff);
+                    continue;
+                }
+                return { ok: false, status, error: parsed, details: { headers: hdrs } };
+            }
+            catch (err) {
+                const ms = Date.now() - started;
+                cfg.onError?.({ method: opts.method, url, attempt, ms, err });
+                const retryable = retryCfg.enabled &&
+                    retryCfg.retryOnNetworkErrors &&
+                    isLikelyNetworkError(err) &&
+                    attempt < retryCfg.maxAttempts;
+                if (retryable) {
+                    const backoff = clamp(retryCfg.baseDelayMs * Math.pow(2, attempt - 1), retryCfg.baseDelayMs, retryCfg.maxDelayMs);
+                    await sleep(backoff);
+                    continue;
+                }
+                return { ok: false, error: err, details: { network: true } };
+            }
+            finally {
+                clearTimeout(t);
+            }
+        }
+        return { ok: false, error: "UNKNOWN" };
+    }
+    static get(url, opts) {
+        return this.request({ ...(opts || {}), method: "GET", url });
+    }
+    static post(url, body, opts) {
+        return this.request({ ...(opts || {}), method: "POST", url, body });
+    }
+    static put(url, body, opts) {
+        return this.request({ ...(opts || {}), method: "PUT", url, body });
+    }
+    static patch(url, body, opts) {
+        return this.request({ ...(opts || {}), method: "PATCH", url, body });
+    }
+    static delete(url, opts) {
+        return this.request({ ...(opts || {}), method: "DELETE", url });
+    }
+}
+exports.Http = Http;

package/dist/apiServer/monitor/Monitor.js

@@ -13,7 +13,7 @@ const DefaultErrors_1 = __importDefault(require("../structures/DefaultErrors"));
 const MonitorService_1 = require("../MonitorService");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const axios_1 = __importDefault(require("axios"));
+const Http_1 = require("../http/Http");
 exports.S_MONITOR_REGISTRATE_ACTION = new badmfck_signal_1.Signal();
 const logMap = {
     ALL: 10,
@@ -54,43 +54,11 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
             this.lastTimeCacheChecked = +new Date();
             let response = null;
             try {
-                response = await axios_1.default.get("https://igorbloom.com/dist/monitor.html");
+                response = await Http_1.Http.get("https://igorbloom.com/dist/monitor.html");
             }
             catch (e) {
                 (0, LogService_1.logError)("Error loading monitor.html from remote server", e);
             }
-            if (response && response.status === 200 && response.data && response.data.length > 0) {
-                if (typeof response.data !== "string")
-                    (0, LogService_1.logError)("Monitor HTML file is not a string", response.data);
-                else {
-                    const hash = crypto_1.default.createHash("sha256").update(response.data).digest("hex");
-                    const oldHash = crypto_1.default.createHash("sha256").update(this.indexHtmlFile).digest("hex");
-                    if (hash !== oldHash) {
-                        if (response.data.length < 1000) {
-                            (0, LogService_1.logError)("Monitor HTML file is too small, probably not loaded correctly", response.data);
-                        }
-                        else {
-                            if (response.data.substring(0, 24).toLowerCase().indexOf("<!doctype html>") === -1) {
-                                (0, LogService_1.logError)("Monitor HTML file is not a valid HTML file, <!doctype html> tag not found");
-                            }
-                            else {
-                                try {
-                                    fs_1.default.writeFileSync(path_1.default.resolve(__dirname, "index.html"), response.data, "utf-8");
-                                    this.fileParsed = false;
-                                    this.indexHtmlFile = response.data;
-                                    (0, LogService_1.logInfo)("Monitor HTML file updated from remote server");
-                                }
-                                catch (e) {
-                                    (0, LogService_1.logError)("Error writing monitor HTML file to local disk", e);
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        (0, LogService_1.logInfo)("Remote monitor HTML file has the same hash");
-                    }
-                }
-            }
         }
         return this.indexHtmlFile;
     }

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

@@ -36,6 +36,7 @@ export interface HTTPRequestVO<T = any, TInterceport = any> {
     unlocked?: boolean;
     internalCall?: boolean;
     stream?: Readable;
+    internalCallParams?: any;
 }
 export interface IError {
     code: number;

package/dist/index.d.ts

@@ -13,4 +13,5 @@ import { YYYYMMDDHH } from "./apiServer/helper/YYYYMMDDHH";
 import { TimeframeService } from "./apiServer/TimeframeService";
 import { JSONStableStringify } from "./apiServer/helper/JSONStableStringify";
 import { ZipUtils } from "./apiServer/helper/ZipUtils";
-export { ZipUtils, UID, YYYYMMDDHH, JSONStableStringify, APIService, Initializer, LocalRequest, ValidationModel, MysqlService, TimeframeService, Validator, LogService, DataProvider, ErrorUtils, ExternalService, DBService, S_MONITOR_REGISTRATE_ACTION };
+import { Http } from "./apiServer/http/Http";
+export { Http, ZipUtils, UID, YYYYMMDDHH, JSONStableStringify, APIService, Initializer, LocalRequest, ValidationModel, MysqlService, TimeframeService, Validator, LogService, DataProvider, ErrorUtils, ExternalService, DBService, S_MONITOR_REGISTRATE_ACTION };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.S_MONITOR_REGISTRATE_ACTION = exports.DBService = exports.ExternalService = exports.ErrorUtils = exports.DataProvider = exports.LogService = exports.Validator = exports.TimeframeService = exports.MysqlService = exports.LocalRequest = exports.Initializer = exports.APIService = exports.JSONStableStringify = exports.YYYYMMDDHH = exports.UID = exports.ZipUtils = void 0;
+exports.S_MONITOR_REGISTRATE_ACTION = exports.DBService = exports.ExternalService = exports.ErrorUtils = exports.DataProvider = exports.LogService = exports.Validator = exports.TimeframeService = exports.MysqlService = exports.LocalRequest = exports.Initializer = exports.APIService = exports.JSONStableStringify = exports.YYYYMMDDHH = exports.UID = exports.ZipUtils = exports.Http = void 0;
 const APIService_1 = require("./apiServer/APIService");
 Object.defineProperty(exports, "APIService", { enumerable: true, get: function () { return APIService_1.APIService; } });
 Object.defineProperty(exports, "Initializer", { enumerable: true, get: function () { return APIService_1.Initializer; } });
@@ -32,3 +32,5 @@ const JSONStableStringify_1 = require("./apiServer/helper/JSONStableStringify");
 Object.defineProperty(exports, "JSONStableStringify", { enumerable: true, get: function () { return JSONStableStringify_1.JSONStableStringify; } });
 const ZipUtils_1 = require("./apiServer/helper/ZipUtils");
 Object.defineProperty(exports, "ZipUtils", { enumerable: true, get: function () { return ZipUtils_1.ZipUtils; } });
+const Http_1 = require("./apiServer/http/Http");
+Object.defineProperty(exports, "Http", { enumerable: true, get: function () { return Http_1.Http; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "3.9.89",
+  "version": "3.9.93",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,15 +19,16 @@
   "dependencies": {
     "@types/express-fileupload": "^1.5.0",
     "@types/mysql": "^2.15.21",
+    "@types/node": "^25.0.3",
     "@types/pg": "^8.15.5",
     "@types/ws": "^8.5.9",
-    "axios": "^1.10.0",
     "badmfck-signal": "^1.4.9",
     "cors": "^2.8.5",
     "express": "^4.21.2",
     "express-fileupload": "^1.5.2",
     "mysql2": "^3.14.2",
     "pg": "^8.16.3",
+    "undici": "^7.18.0",
     "ws": "^8.18.3"
   },
   "devDependencies": {