badmfck-api-server 3.9.91 → 3.9.94

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

@@ -29,7 +29,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.APIService = exports.Initializer = exports.REQ_DOC_USERS = exports.REQ_MONITOR_USERS = exports.REQ_INTERNAL_CALL = exports.REQ_HTTP_SERVER = exports.REQ_HTTP_REQUESTS_COUNT = exports.REQ_HTTP_LOG = exports.getDefaultOptions = void 0;
 const express_1 = __importDefault(require("express"));
 const BaseService_1 = require("./BaseService");
-const cors_1 = __importDefault(require("cors"));
 const BaseEndpoint_1 = require("./BaseEndpoint");
 const DefaultErrors_1 = __importStar(require("./structures/DefaultErrors"));
 const badmfck_signal_1 = require("badmfck-signal");
@@ -50,7 +49,7 @@ function defaultOptions() {
     return {
         port: 8080,
         baseEndPoint: "/api/",
-        corsHostWhiteList: ["localhost:3000"],
+        corsHostWhiteList: ["http://localhost:3000"],
         endpoints: [],
         jsonLimit: "10mb",
         projectName: "Application project",
@@ -77,7 +76,7 @@ exports.REQ_HTTP_REQUESTS_COUNT = new badmfck_signal_1.Req(undefined, "REQ_HTTP_
 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");
-exports.REQ_DOC_USERS = new badmfck_signal_1.Req(undefined, "REQ_MONITOR_USERS");
+exports.REQ_DOC_USERS = new badmfck_signal_1.Req(undefined, "REQ_DOC_USERS");
 const activeServices = [];
 async function Initializer(services) {
     services.push(new StatService_1.StatService());
@@ -92,7 +91,7 @@ async function Initializer(services) {
 }
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
-    version = "3.9.9";
+    version = "3.9.94";
     options;
     monitor = null;
     started = new Date();
@@ -105,7 +104,18 @@ class APIService extends BaseService_1.BaseService {
             this.options.corsHostWhiteList = [];
         const self = "http://localhost:" + this.options.port;
         if (!this.options.corsHostWhiteList.find(val => val === self))
-            this.options.corsHostWhiteList.push();
+            this.options.corsHostWhiteList.push(self);
+        const list = [];
+        for (let h of this.options.corsHostWhiteList) {
+            h = h.replace(/\/$/, "");
+            if (!/^https?:\/\//i.test(h)) {
+                list.push(`http://${h}`, `https://${h}`);
+            }
+            else {
+                list.push(h);
+            }
+        }
+        this.options.corsHostWhiteList = Array.from(new Set(list));
         exports.REQ_MONITOR_USERS.listener = async () => this.options.access.monitor ?? [];
         exports.REQ_DOC_USERS.listener = async () => this.options.access.documentation ?? [];
         this.options.endpoints.push(new Monitor_1.Monitor(this.options));
@@ -142,8 +152,8 @@ class APIService extends BaseService_1.BaseService {
         exports.REQ_HTTP_SERVER.listener = async (_) => { return { express: app, http: server }; };
         if (this.options.isProductionEnvironment)
             app.set("env", 'production');
-        app.use(express_1.default.json({ limit: '10mb' }));
-        app.use(express_1.default.urlencoded({ limit: '10mb', extended: true }));
+        app.use(express_1.default.json({ limit: this.options.jsonLimit ?? '10mb' }));
+        app.use(express_1.default.urlencoded({ limit: this.options.jsonLimit ?? '10mb', extended: true }));
         app.use((0, express_fileupload_1.default)({
             limitHandler: (req, res, next) => {
                 this.sendResponse(req.get("Referer") ?? "", res, {
@@ -161,6 +171,7 @@ class APIService extends BaseService_1.BaseService {
                     response: undefined,
                     files: undefined
                 });
+                return;
             },
             limits: { fileSize: this.options.fileLimit },
             useTempFiles: true,
@@ -168,7 +179,7 @@ class APIService extends BaseService_1.BaseService {
             tempFileDir: this.options.fileTempDir,
             abortOnLimit: true
         }));
-        app.use(async (err, req, resp, next) => {
+        app.use((err, req, resp, next) => {
             if (!err) {
                 next();
                 return;
@@ -193,15 +204,35 @@ class APIService extends BaseService_1.BaseService {
                 response: undefined,
                 files: undefined
             });
+            return;
+        });
+        const corsSet = new Set(this.options.corsHostWhiteList.map(x => String(x).replace(/\/$/, "")));
+        app.use((req, res, next) => {
+            const originHeader = req.headers.origin;
+            if (!originHeader)
+                return next();
+            let originNorm;
+            try {
+                originNorm = new URL(String(originHeader)).origin;
+            }
+            catch {
+                res.status(403).send({
+                    error: { ...DefaultErrors_1.default.FORBIDDEN, details: "Invalid Origin header" },
+                    data: null,
+                    httpStatus: 403,
+                });
+                return;
+            }
+            if (!corsSet.has(originNorm)) {
+                res.status(403).send({
+                    error: { ...DefaultErrors_1.default.FORBIDDEN, details: `Origin not allowed: ${originNorm}` },
+                    data: null,
+                    httpStatus: 403,
+                });
+                return;
+            }
+            return next();
         });
-        const corsOptions = {
-            origin: (origin, callback) => {
-                const originIsWhitelisted = this.options.corsHostWhiteList.includes(origin);
-                callback(null, originIsWhitelisted);
-            },
-            credentials: true
-        };
-        app.use((0, cors_1.default)(corsOptions));
         BaseEndpoint_1.BaseEndpoint.setEntryPoint(this.options.baseEndPoint);
         for (let i of this.options.endpoints) {
             await i.init();
@@ -214,17 +245,17 @@ class APIService extends BaseService_1.BaseService {
                     this.requestsCount++;
                     const tme = +new Date();
                     const execute = async () => {
-                        const body = req.body;
+                        const body = { ...(req.body ?? {}) };
                         if (req.query && typeof req.query === "object") {
-                            for (let i in req.query) {
-                                body[i] = req.query[i];
-                            }
+                            const keys = Object.keys(req.query);
+                            for (let k of keys)
+                                body[k] = req.query[k];
                         }
                         let httpRequest = {
                             raw: req,
                             response: res,
                             method: req.method,
-                            data: req.body,
+                            data: body,
                             params: req.params,
                             headers: req.headers,
                             endpoint: ep,
@@ -273,7 +304,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;
@@ -324,7 +355,7 @@ class APIService extends BaseService_1.BaseService {
                         }
                         this.sendResponse(req.get("Referer") ?? "", res, result, tme, ep, httpRequest);
                     };
-                    execute();
+                    return execute();
                 });
             }
         }
@@ -359,15 +390,17 @@ class APIService extends BaseService_1.BaseService {
                 endpoint: req?.endpoint,
                 headers: req?.headers,
                 method: req?.method,
-                data: req?.data,
+                data: this.checkDataLength(req?.data),
                 params: req?.params,
                 interceptorResult: req?.interceptorResult
             },
-            response: data
+            response: this.checkDataLength(data),
         };
         this.netLog.push(logItem);
         if (this.netLog.length > 100)
             this.netLog.shift();
+        if (nextLogID > Number.MAX_SAFE_INTEGER - 1000)
+            nextLogID = 0;
     }
     async sendResponse(ref, res, data, requestTime, endpoint, req) {
         if (data.blockResponse) {
@@ -392,7 +425,7 @@ class APIService extends BaseService_1.BaseService {
         if (this.options.appVersion)
             data.version = this.options.appVersion;
         MonitorService_1.S_STAT_REGISTRATE_REQUEST.invoke(data);
-        if (res.destroyed || res.closed) {
+        if (res.socket?.destroyed || res.writableEnded || res.headersSent || (res.destroyed !== undefined && res.destroyed)) {
             (0, LogService_1.logAPI)("Connection already closed, can't send response for: " + data.endpoint);
         }
         else {
@@ -401,11 +434,17 @@ class APIService extends BaseService_1.BaseService {
                     res.sendFile(data.file, err => {
                         if (err) {
                             (0, LogService_1.logError)("Can't send file: " + data.file);
-                            this.sendResponse(ref, res, {
-                                error: DefaultErrors_1.default.CANT_SEND_FILE,
-                                data: null,
-                                httpStatus: 500
-                            }, requestTime, data.endpoint, req);
+                            if (!res.headersSent && !res.writableEnded) {
+                                res.status(500).send({ error: DefaultErrors_1.default.CANT_SEND_FILE, data: null });
+                                return;
+                            }
+                            else {
+                                try {
+                                    res.destroy?.(err);
+                                }
+                                catch { }
+                                return;
+                            }
                         }
                         else {
                             if (req)
@@ -447,27 +486,18 @@ class APIService extends BaseService_1.BaseService {
             this.addNetlog(data, req, requestTime, 0);
     }
     checkDataLength(data, result, lvl) {
-        if (!lvl)
-            lvl = 0;
-        if (typeof data !== "object") {
-            if (typeof data === "string" && data.length > 1024)
-                return data.substring(0, 1000) + "... (total:" + data.length + ")";
-            return data;
+        let json = "";
+        try {
+            json = JSON.stringify(data, (k, v) => {
+                if (typeof v === 'string' && v.length > 255)
+                    return v.slice(0, 255) + `...(${v.length})`;
+                return v;
+            });
         }
-        if (typeof data === "object") {
-            if (!result)
-                result = {};
-            let arrcnt = 100;
-            for (let i in data) {
-                result[i] = this.checkDataLength(data[i], result[i], lvl + 1);
-                arrcnt--;
-                if (arrcnt <= 0) {
-                    result["..."] = "... total: " + Array.isArray(data) ? data.length : Object.keys(data).length;
-                    break;
-                }
-            }
+        catch (e) {
+            json = "[unserializable data]";
         }
-        return result ?? null;
+        return json.length > 500 ? json.slice(0, 500) + `...(total ${json.length})` : json;
     }
 }
 exports.APIService = APIService;

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;
@@ -42,6 +44,7 @@ export declare class BaseEndpoint implements IBaseEndpoint {
     ignoreInDocumentation: boolean;
     private static entrypoint;
     endpoint: string;
+    protected streamOptions: Record<string, any>;
     static setEntryPoint: (ep: string) => void;
     static getEntryPoint: () => string;
     constructor(endpoint: string);
@@ -51,6 +54,11 @@ export declare class BaseEndpoint implements IBaseEndpoint {
     __precheck(req: HTTPRequestVO): Promise<TransferPacketVO<any> | null>;
     __execute(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
     protected validateStructure(structure: any, req: HTTPRequestVO): Promise<void>;
-    protected createStream(req: HTTPRequestVO): HTTPRequestVO;
+    protected createStream(req: HTTPRequestVO, opts: {
+        contentType?: string;
+        headers?: {
+            [key: string]: string;
+        };
+    }): HTTPRequestVO;
 }
 export {};

package/dist/apiServer/BaseEndpoint.js

@@ -17,6 +17,7 @@ class BaseEndpoint {
     ignoreInDocumentation = false;
     static entrypoint = "/";
     endpoint = "";
+    streamOptions = {};
     static setEntryPoint = (ep) => {
         this.entrypoint = ep;
         if (!this.entrypoint.endsWith("/")) {
@@ -73,43 +74,65 @@ class BaseEndpoint {
             for (let i of this.endpoints) {
                 let targetEP = BaseEndpoint.entrypoint + i.endpoint;
                 targetEP = targetEP.replaceAll("//", "/");
-                if (targetEP === req.endpoint) {
-                    if (i.handler && typeof i.handler === "function") {
-                        if (req.params && req.params.validationModel && req.params.validationModel === "1")
-                            return { data: i.validationModel };
-                        if (i.validationModel)
-                            await this.validateStructure(i.validationModel, req);
-                        return i.handler.call(this, req);
+                if (targetEP !== req.endpoint)
+                    continue;
+                const httpMethod = req.method.toUpperCase();
+                const resolveAsStream = () => {
+                    if (i.asStream)
+                        return true;
+                    if (i.handler && typeof i.handler === "object") {
+                        const h = i.handler[httpMethod];
+                        if (h && typeof h === "object" && "asStream" in h && h.asStream)
+                            return true;
                     }
-                    const httpMethod = req.method.toUpperCase();
-                    if (i.handler && i.handler[httpMethod] && typeof i.handler[httpMethod] === "function") {
-                        if (req.params && req.params.validationModel && req.params.validationModel === "1")
-                            return { data: i.validationModel };
-                        if (i.validationModel)
-                            await this.validateStructure(i.validationModel, req);
-                        if (i.asStream)
-                            req = this.createStream(req);
-                        return i.handler[httpMethod].call(this, req);
-                    }
-                    if (i.handler
-                        && i.handler[httpMethod]
-                        && typeof i.handler[httpMethod] === "object"
-                        && "controller" in i.handler[httpMethod]
-                        && typeof i.handler[httpMethod].controller === "function") {
-                        const vmodel = i.handler[httpMethod].validationModel;
-                        if (req.params && req.params.validationModel && req.params.validationModel === "1")
-                            return { data: vmodel };
-                        if (vmodel)
-                            await this.validateStructure(vmodel, req);
-                        if (i.asStream)
-                            req = this.createStream(req);
-                        return i.handler[httpMethod].controller.call(this, req);
-                    }
-                    return {
-                        error: { ...DefaultErrors_1.default.METHOD_NOT_ALLOWED, details: "No handler for " + httpMethod },
-                        data: null
-                    };
+                    return false;
+                };
+                const asStream = resolveAsStream();
+                if (i.handler && typeof i.handler === "function") {
+                    if (req.data && req.data.validationModel && req.data.validationModel === "1")
+                        return { data: i.validationModel };
+                    if (i.validationModel)
+                        await this.validateStructure(i.validationModel, req);
+                    if (asStream)
+                        req = this.createStream(req, this.streamOptions[i.endpoint] ?? {});
+                    const result = await i.handler.call(this, req);
+                    if (asStream)
+                        return { blockResponse: true, data: null };
+                    return result;
+                }
+                if (i.handler && i.handler[httpMethod] && typeof i.handler[httpMethod] === "function") {
+                    if (req.data && req.data.validationModel && req.data.validationModel === "1")
+                        return { data: i.validationModel };
+                    if (i.validationModel)
+                        await this.validateStructure(i.validationModel, req);
+                    if (asStream)
+                        req = this.createStream(req, this.streamOptions[i.endpoint] ?? {});
+                    const result = await i.handler[httpMethod].call(this, req);
+                    if (asStream)
+                        return { blockResponse: true, data: null };
+                    return result;
+                }
+                if (i.handler
+                    && i.handler[httpMethod]
+                    && typeof i.handler[httpMethod] === "object"
+                    && "controller" in i.handler[httpMethod]
+                    && typeof i.handler[httpMethod].controller === "function") {
+                    const vmodel = i.handler[httpMethod].validationModel;
+                    if (req.data && req.data.validationModel && req.data.validationModel === "1")
+                        return { data: vmodel };
+                    if (vmodel)
+                        await this.validateStructure(vmodel, req);
+                    if (asStream)
+                        req = this.createStream(req, this.streamOptions[i.endpoint] ?? {});
+                    const result = await i.handler[httpMethod].controller.call(this, req);
+                    if (asStream)
+                        return { blockResponse: true, data: null };
+                    return result;
                 }
+                return {
+                    error: { ...DefaultErrors_1.default.METHOD_NOT_ALLOWED, details: "No handler for " + httpMethod },
+                    data: null
+                };
             }
         }
         (0, LogService_1.logWarn)("${BaseEndpoint.js}", "Unhandled entrypoint: " + this.endpoint);
@@ -128,17 +151,101 @@ class BaseEndpoint {
             throw { ...DefaultErrors_1.default.WRONG_PARAMS, details: report };
         Validator_1.Validator.filterStructure(structure, req.data);
     }
-    createStream(req) {
+    createStream(req, opts) {
         const res = req.response;
-        res.setHeader('Content-Type', 'text/plain');
-        res.setHeader('Transfer-Encoding', 'chunked');
-        const stream = new stream_1.Readable();
-        stream.pipe(res);
+        if (res.headersSent)
+            throw { ...DefaultErrors_1.default.INTERNAL_SERVER_ERROR, details: "Headers already sent, can't create stream" };
+        res.statusCode = 200;
+        res.setHeader("Content-Type", opts?.contentType ?? "application/octet-stream");
+        res.setHeader("Transfer-Encoding", "chunked");
+        res.setHeader("Cache-Control", "no-cache");
+        if (opts?.headers) {
+            for (let h in opts.headers) {
+                res.setHeader(h, opts.headers[h]);
+            }
+        }
+        const stream = new stream_1.Readable({
+            read() {
+            }
+        });
+        let finished = false;
+        let timer;
+        const cleanup = () => {
+            if (finished)
+                return;
+            finished = true;
+            if (timer)
+                clearTimeout(timer);
+            try {
+                if (!stream.destroyed) {
+                    stream.destroy();
+                }
+            }
+            catch (e) {
+                console.error("Error during stream cleanup:", e);
+            }
+            try {
+                if (!res.writableEnded)
+                    res.end();
+            }
+            catch { }
+        };
+        const endOk = () => {
+            if (finished)
+                return;
+            finished = true;
+            if (timer)
+                clearTimeout(timer);
+            try {
+                if (!stream.destroyed)
+                    stream.push(null);
+            }
+            catch (e) {
+                cleanup();
+            }
+        };
+        res.on('close', () => {
+            cleanup();
+        });
+        const setupTimer = () => {
+            if (finished)
+                return;
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => cleanup(), 60_000);
+        };
+        setupTimer();
+        const origPush = stream.push.bind(stream);
+        stream.push = (chunk, encoding) => {
+            if (chunk === null)
+                return origPush(null);
+            if (finished)
+                return false;
+            setupTimer();
+            return origPush(chunk, encoding);
+        };
+        req.raw?.on?.("aborted", () => {
+            cleanup();
+            try {
+                res.destroy?.();
+            }
+            catch { }
+        });
+        req.raw?.on?.("close", cleanup);
         stream.on('error', (err) => {
-            console.error('Stream error:', err);
-            res.status(500).send('Stream error');
+            console.error("Stream error:", err);
+            cleanup();
+            try {
+                res.destroy?.(err);
+            }
+            catch {
+                res.end();
+            }
         });
+        res.on("finish", cleanup);
+        stream.pipe(res);
         req.stream = stream;
+        req.endStream = (force) => force ? cleanup() : endOk();
         return 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,7 @@ 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"));
+const __1 = require("../..");
 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 }) => {
@@ -89,33 +89,21 @@ class ExternalService extends BaseService_1.BaseService {
         const encrypted = this.encrypt({ requestName, requestData });
         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;
+        const resp = await __1.Http.post(this.options.url + "/external/call/" + this.options.id, encrypted.data, {
+            headers: {
+                "authorization": encrypted.authorization,
+                "Content-Type": "application/json",
+                "Accept": "application/json"
             }
-            return { ...DefaultErrors_1.default.BAD_REQUEST, details: err.cause?.message };
+        });
+        if (!resp.ok) {
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: resp.details, stack: resp.error };
         }
+        const json = await resp.data.json();
+        if (typeof json === "object" && "error" in json)
+            return json.error;
+        if (typeof json === "object" && "data" in json)
+            return json.data;
     }
     async onExternalCall(req) {
         const data = this.decrypt(req);

package/dist/apiServer/external/MicroserviceClient.d.ts

@@ -0,0 +1,4 @@
+import { BaseService } from "../BaseService";
+export declare class MicroserviceClient extends BaseService {
+    constructor();
+}

package/dist/apiServer/external/MicroserviceClient.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicroserviceClient = void 0;
+const BaseService_1 = require("../BaseService");
+class MicroserviceClient extends BaseService_1.BaseService {
+    constructor() {
+        super("MicroserviceClient");
+    }
+}
+exports.MicroserviceClient = MicroserviceClient;

package/dist/apiServer/external/MicroserviceHost.d.ts

@@ -0,0 +1,4 @@
+import { BaseService } from "../BaseService";
+export declare class MicroserviceHost extends BaseService {
+    constructor();
+}

package/dist/apiServer/external/MicroserviceHost.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicroserviceHost = void 0;
+const BaseService_1 = require("../BaseService");
+class MicroserviceHost extends BaseService_1.BaseService {
+    constructor() {
+        super("MicroserviceHost");
+    }
+}
+exports.MicroserviceHost = MicroserviceHost;

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,8 @@ export interface HTTPRequestVO<T = any, TInterceport = any> {
     unlocked?: boolean;
     internalCall?: boolean;
     stream?: Readable;
+    endStream?: (force?: boolean) => void;
+    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.91",
+  "version": "3.9.94",
   "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": {