badmfck-api-server 2.4.2 → 2.4.3

package/dist/apiServer/BaseEndpoint.d.ts

@@ -12,6 +12,7 @@ export interface IEndpointHandler {
     ignoreInterceptor?: boolean;
     independed?: boolean;
     allowInterceptorError?: boolean;
+    httpMethod?: "GET" | "POST" | "PUT" | "DELETE";
 }
 export declare class BaseEndpoint implements IBaseEndpoint {
     private inializedEndpointNames;

package/dist/apiServer/ClusterService.d.ts

@@ -0,0 +1,16 @@
+import { BaseService } from "./BaseService";
+import { HUBConnection } from "./cluster/HUBConnection";
+export interface ClusterServiceOptions {
+    id: string;
+    privateKey: string;
+    hubURL: string;
+    hubPublicKey: string;
+    nodes: string[];
+}
+export declare class ClusterService extends BaseService {
+    options: ClusterServiceOptions;
+    ws: HUBConnection | null;
+    constructor(opt: ClusterServiceOptions);
+    init(): Promise<void>;
+    connectToHUB(): Promise<void>;
+}

package/dist/apiServer/ClusterService.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterService = void 0;
+const ws_1 = __importDefault(require("ws"));
+const BaseService_1 = require("./BaseService");
+const LogService_1 = require("./LogService");
+const HUBConnection_1 = require("./cluster/HUBConnection");
+class ClusterService extends BaseService_1.BaseService {
+    options;
+    ws = null;
+    constructor(opt) {
+        super("ClusterService");
+        this.options = opt;
+        if (!opt.nodes.length)
+            throw new Error("ClusterService: No nodes provided");
+    }
+    async init() {
+        (0, LogService_1.logInfo)("ClusterService: initialized");
+        this.connectToHUB();
+    }
+    async connectToHUB() {
+        (0, LogService_1.logInfo)("ClusterService: connecting to HUB");
+        if (this.ws)
+            this.ws.close();
+        this.ws = new HUBConnection_1.HUBConnection({
+            ws: new ws_1.default(this.options.hubURL),
+            privateKey: this.options.privateKey,
+            hubID: this.options.id,
+            onAuthorized: () => {
+                this.ws?.send({
+                    method: "auth",
+                    data: {
+                        id: this.options.id,
+                        publicKey: this.options.hubPublicKey
+                    },
+                    callbackID: 0
+                });
+            },
+            onClose: () => {
+                console.log("ClusterService: connection to HUB closed");
+                this.connectToHUB();
+            },
+            handlers: []
+        });
+    }
+}
+exports.ClusterService = ClusterService;

package/dist/apiServer/DocumentService.d.ts

@@ -0,0 +1,42 @@
+declare type DocumentGeneratorConfig = {
+    sourcePath: string;
+    apiEndpoint: string;
+    savePath: string;
+    savePathFileName: string;
+};
+declare type DocumentGeneratorDocumentation = {
+    [baseEndpointName: string]: {
+        [endPointName: string]: DocumentGeneratorDocumentationEndpoint;
+    };
+};
+declare type DocumentGeneratorDocumentationEndpoint = {
+    handler: string;
+    fullPath: string;
+    ignoreInterceptor?: string;
+    description?: string;
+    parameters: DocumentGeneratorDocumentationEndpointParameter[];
+    returns?: Omit<DocumentGeneratorDocumentationEndpointParameter, "optional">;
+    example?: string[];
+    throws?: Omit<DocumentGeneratorDocumentationEndpointParameter, "optional">[];
+};
+declare type DocumentGeneratorDocumentationEndpointParameter = {
+    name: string;
+    type: string;
+    description: string;
+    optional?: boolean;
+};
+export declare class DocumentGenerator {
+    private documentation;
+    private config;
+    constructor(config: DocumentGeneratorConfig);
+    private getFiles;
+    private getFileContent;
+    private generateDocumentation;
+    private getCommentsByEndpoint;
+    private parseEndPointComments;
+    private tagToEndpoint;
+    private tagModifications;
+    private saveDocumentation;
+    getDocumentation(): DocumentGeneratorDocumentation;
+}
+export {};

package/dist/apiServer/DocumentService.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const comment_parser_1 = require("comment-parser");
+class DocumentGenerator {
+    documentation = {};
+    config;
+    constructor(config) {
+        this.config = config;
+        this.generateDocumentation();
+    }
+    getFiles() {
+        return fs.readdirSync(this.config.sourcePath);
+    }
+    getFileContent(file) {
+        return fs.readFileSync(path.resolve(this.config.sourcePath, file), "utf-8");
+    }
+    generateDocumentation = () => {
+        for (const file of this.getFiles()) {
+            const fileContent = this.getFileContent(file);
+            const baseEndpoint = fileContent.match(/super\(['"](.*?)['"]\)/);
+            if (!baseEndpoint) {
+                console.error(`No base endpoint found in ${file}`);
+                continue;
+            }
+            const nodeEndpoint = this.config.apiEndpoint + "/" + baseEndpoint[1];
+            const regex = /{\s*endpoint:\s*"(.*?)",\s*handler:\s*this\.(.*?)(?:,\s*ignoreInterceptor:\s*(true|false))?\s*}/g;
+            const endpoints = fileContent.matchAll(regex);
+            for (const match of endpoints) {
+                const endpointName = match[1];
+                const handler = match[2];
+                const ignoreInterceptor = match[3];
+                if (!this.documentation.hasOwnProperty(nodeEndpoint)) {
+                    this.documentation[nodeEndpoint] = {};
+                }
+                const endpoint = {
+                    handler,
+                    ignoreInterceptor,
+                    fullPath: nodeEndpoint + "/" + endpointName,
+                    description: "",
+                    parameters: [],
+                };
+                this.documentation[nodeEndpoint][endpointName] = this.parseEndPointComments(this.getCommentsByEndpoint(fileContent, handler), endpoint);
+            }
+        }
+        this.saveDocumentation();
+        console.log("Documentation generated and saved successfully");
+    };
+    getCommentsByEndpoint(fileContent, handler) {
+        let comments = "";
+        const regex = new RegExp(`(async )*${handler}(\\s*)\\(`, "g");
+        const match = fileContent.match(regex);
+        if (match) {
+            const indexHandler = fileContent.indexOf(`${match[0]}`);
+            if (indexHandler != -1) {
+                const indexCommentStart = fileContent.lastIndexOf("/**", indexHandler);
+                if (indexCommentStart != -1) {
+                    const indexCommentEnd = fileContent.indexOf("*/", indexCommentStart);
+                    if (indexCommentEnd != -1) {
+                        const commentsSubstring = fileContent.substring(indexCommentStart, indexCommentEnd + 2);
+                        if (commentsSubstring) {
+                            const regexToCheckCommentWithMethod = new RegExp(`${commentsSubstring.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([\\s]*?)(async )*${handler}(\\s*)\\(`, "g");
+                            const matchToCheckCommentWithMethod = fileContent.match(regexToCheckCommentWithMethod);
+                            if (matchToCheckCommentWithMethod) {
+                                comments = commentsSubstring;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return comments;
+    }
+    parseEndPointComments(comments, endpoint) {
+        if (comments) {
+            const parsed = (0, comment_parser_1.parse)(comments, { spacing: "preserve" });
+            if (parsed[0]) {
+                const firstParsed = parsed[0];
+                endpoint.description = this.tagModifications(firstParsed.description);
+                firstParsed.tags.forEach((tag) => {
+                    endpoint = this.tagToEndpoint(tag, endpoint);
+                });
+            }
+        }
+        return endpoint;
+    }
+    tagToEndpoint(tag, endpoint) {
+        switch (tag.tag) {
+            case "param":
+                endpoint.parameters.push({
+                    name: this.tagModifications(tag.name, "name"),
+                    type: tag.type,
+                    description: this.tagModifications(tag.description),
+                    optional: tag.optional,
+                });
+                break;
+            case "description":
+                endpoint.description = this.tagModifications(tag.description);
+                break;
+            case "example":
+                if (!endpoint.example) {
+                    endpoint.example = [];
+                }
+                endpoint.example.push(this.tagModifications(tag.description));
+                break;
+            case "returns":
+                endpoint.returns = {
+                    name: this.tagModifications(tag.name, "name"),
+                    type: tag.type,
+                    description: this.tagModifications(tag.description),
+                };
+                break;
+            case "throws":
+                if (!endpoint.throws) {
+                    endpoint.throws = [];
+                }
+                endpoint.throws.push({
+                    name: this.tagModifications(tag.name, "name"),
+                    type: tag.type,
+                    description: this.tagModifications(tag.description),
+                });
+                break;
+        }
+        return endpoint;
+    }
+    tagModifications(text, field = "description") {
+        switch (field) {
+            case "description":
+                text = text
+                    .trim()
+                    .replace(/^(\-.)/, "")
+                    .trim();
+                break;
+            case "name":
+                if (text === "-") {
+                    text = "";
+                }
+                break;
+        }
+        return text;
+    }
+    saveDocumentation() {
+        const formatForSave = this.documentation;
+        const filePath = this.config.savePath + this.config.savePathFileName;
+        fs.writeFileSync(filePath, JSON.stringify(formatForSave, null, 2));
+    }
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.DocumentGenerator = DocumentGenerator;
+new DocumentGenerator({
+    sourcePath: "./src/api",
+    apiEndpoint: "api/v1",
+    savePath: "./bin/",
+    savePathFileName: "doc.json",
+});

package/dist/apiServer/HUBService.d.ts

@@ -0,0 +1,29 @@
+import { BaseService } from "./BaseService";
+import { HUBConnection } from "./cluster/HUBConnection";
+import Signal, { Req } from "badmfck-signal";
+import { IError } from "./structures/Interfaces";
+export interface HUBServiceOptions {
+    url: string;
+    privateKey: string;
+    hubID: string;
+}
+export interface IClusterNode {
+    clusterID: string;
+    url: string;
+    publicKey: string;
+    ws: HUBConnection[];
+}
+export declare const REQ_CLUSTER_NODE: Req<string, IError | {
+    url: string;
+    publicKey: string;
+}>;
+export declare class HUBService extends BaseService {
+    options: HUBServiceOptions;
+    nodes: Map<string, IClusterNode>;
+    handlers: (Signal<any> | Req<any, any>)[];
+    constructor(options: HUBServiceOptions);
+    init(): Promise<void>;
+    applicationReady(): Promise<void>;
+    onConnectionAuthorized(conn: HUBConnection): void;
+    onConnectionClosed(conn: HUBConnection): void;
+}

package/dist/apiServer/HUBService.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUBService = exports.REQ_CLUSTER_NODE = void 0;
+const ws_1 = require("ws");
+const APIService_1 = require("./APIService");
+const BaseService_1 = require("./BaseService");
+const HUBConnection_1 = require("./cluster/HUBConnection");
+const LogService_1 = require("./LogService");
+const badmfck_signal_1 = require("badmfck-signal");
+exports.REQ_CLUSTER_NODE = new badmfck_signal_1.Req(undefined, "REQ_CLUSTER_NODE");
+class HUBService extends BaseService_1.BaseService {
+    options;
+    nodes = new Map();
+    handlers = [];
+    constructor(options) {
+        super("HUBService");
+        this.options = options;
+    }
+    async init() {
+        super.init();
+    }
+    async applicationReady() {
+        const server = await APIService_1.REQ_HTTP_SERVER.request();
+        const wss = new ws_1.WebSocketServer({
+            server: server.http,
+            path: "/hub"
+        });
+        wss.on("connection", (ws) => {
+            const conn = new HUBConnection_1.HUBConnection({
+                ws: ws,
+                privateKey: this.options.privateKey,
+                hubID: this.options.hubID,
+                onAuthorized: () => this.onConnectionAuthorized(conn),
+                onClose: () => this.onConnectionClosed(conn),
+                handlers: this.handlers
+            });
+        });
+        wss.on("error", (err) => {
+            console.error("HUBService: error: ", err);
+        });
+    }
+    onConnectionAuthorized(conn) {
+        (0, LogService_1.logInfo)("HUBService: authorized connection");
+        let clusterNode = this.nodes.get(conn.clientID);
+        if (!clusterNode) {
+            (0, LogService_1.logInfo)("HUBService: new cluster node connected");
+            clusterNode = {
+                clusterID: conn.clientID,
+                url: conn.url,
+                publicKey: conn.publicKey,
+                ws: []
+            };
+            this.nodes.set(conn.clientID, clusterNode);
+        }
+        clusterNode.ws.push(conn);
+    }
+    onConnectionClosed(conn) {
+        (0, LogService_1.logInfo)("HUBService: connection closed");
+        const clusterNode = this.nodes.get(conn.clientID);
+        if (clusterNode) {
+            clusterNode.ws = clusterNode.ws.filter(x => x !== conn);
+            if (!clusterNode.ws.length) {
+                (0, LogService_1.logInfo)("HUBService: cluster node disconnected");
+                this.nodes.delete(conn.clientID);
+            }
+        }
+    }
+}
+exports.HUBService = HUBService;

package/dist/apiServer/cluster/HUBConnection.d.ts

@@ -0,0 +1,39 @@
+import { WebSocket } from "ws";
+import { IError } from "../structures/Interfaces";
+import Signal, { Req } from "badmfck-signal";
+export interface IClusterPacket {
+    method: string;
+    data?: any | null;
+    error?: IError;
+    callbackID: number;
+}
+export declare class HUBConnection {
+    static callbackID: number;
+    callbacks: Map<number, {
+        time: number;
+        callback: (packet: IClusterPacket) => void;
+    }>;
+    authorized: boolean;
+    ws: WebSocket;
+    privateKey: string;
+    publicKey: string | null;
+    hubID: string;
+    clientID: string | null;
+    url: string | null;
+    onAuthorized: () => void;
+    intervalID: number;
+    constructor(options: {
+        ws: WebSocket;
+        privateKey: string;
+        hubID: string;
+        onAuthorized: () => void;
+        onClose: () => void;
+        handlers: (Req<any, any> | Signal<any>)[];
+        authorized?: boolean;
+        maxTimeout?: number;
+    });
+    authorize(data: any): Promise<boolean | IError>;
+    sendCallback(packet: IClusterPacket, data: IError | any): void;
+    send(packet: IClusterPacket): Promise<IClusterPacket | IError | null>;
+    close(): void;
+}

package/dist/apiServer/cluster/HUBConnection.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUBConnection = void 0;
+const ws_1 = require("ws");
+const LogService_1 = require("../LogService");
+const DefaultErrors_1 = __importStar(require("../structures/DefaultErrors"));
+const crypto_1 = require("crypto");
+class HUBConnection {
+    static callbackID = 1;
+    callbacks = new Map();
+    authorized = false;
+    ws;
+    privateKey;
+    publicKey;
+    hubID;
+    clientID = null;
+    url = null;
+    onAuthorized;
+    intervalID = 0;
+    constructor(options) {
+        (0, LogService_1.logInfo)("HUBConnection: new connection");
+        this.privateKey = options.privateKey;
+        this.publicKey = null;
+        this.hubID = options.hubID;
+        this.ws = options.ws;
+        this.onAuthorized = options.onAuthorized;
+        if (options.authorized)
+            this.authorized = true;
+        this.ws.on("close", () => {
+            if (!this.authorized)
+                return;
+            (0, LogService_1.logInfo)("HUBConnection: connection closed");
+            if (options.onClose)
+                options.onClose();
+        });
+        this.ws.on("error", (e) => {
+            (0, LogService_1.logError)("HUBConnection: connection error", e);
+        });
+        this.ws.on("open", () => {
+            (0, LogService_1.logInfo)("HUBConnection: connection opened");
+            if (options.authorized) {
+                if (this.onAuthorized)
+                    this.onAuthorized();
+            }
+        });
+        this.ws.on("message", async (msg, isBinary) => {
+            if (!this.authorized && isBinary)
+                return;
+            let data = null;
+            try {
+                data = JSON.parse(msg.toString());
+            }
+            catch (e) { }
+            if (!data || !data.method || !data.callbackID) {
+                (0, LogService_1.logError)("HUBConnection: invalid packet structure", data);
+                return;
+            }
+            if (typeof data.method !== "string" || typeof data.callbackID !== "number") {
+                (0, LogService_1.logError)("HUBConnection: invalid packet structure", data);
+                return;
+            }
+            if (!this.authorized && data.method === "auth") {
+                const result = await this.authorize(data.data);
+                if (DefaultErrors_1.ErrorUtils.isError(result)) {
+                    (0, LogService_1.logError)("HUBConnection: authorization failed", result);
+                    this.sendCallback(data, result);
+                    return;
+                }
+                this.authorized = true;
+                if (this.onAuthorized)
+                    this.onAuthorized();
+                this.sendCallback(data, result);
+                return;
+            }
+            if (!this.authorized) {
+                (0, LogService_1.logError)("HUBConnection: not authorized");
+                this.sendCallback(data, DefaultErrors_1.default.UNAUTHORIZED);
+                return;
+            }
+            if (typeof data.data !== "string")
+                return this.sendCallback(data, { ...DefaultErrors_1.default.BAD_REQUEST, details: "invalid data, must be a string" });
+            let packetData = null;
+            try {
+                const encryptedPacketData = (0, crypto_1.privateDecrypt)(this.privateKey, data.data).toString("utf8");
+                packetData = JSON.parse(encryptedPacketData);
+            }
+            catch (e) {
+                return this.sendCallback(data, { ...DefaultErrors_1.default.BAD_REQUEST, details: "invalid data type, must be a json" });
+            }
+            if (data.method === "callback") {
+                if (!this.callbacks.has(data.callbackID)) {
+                    (0, LogService_1.logError)("HUBConnection: callback not found", data);
+                    return;
+                }
+                const cb = this.callbacks.get(data.callbackID);
+                if (cb) {
+                    cb.callback({
+                        method: "callback",
+                        data: packetData,
+                        callbackID: data.callbackID,
+                        error: data.error
+                    });
+                    this.callbacks.delete(data.callbackID);
+                }
+                return;
+            }
+            ;
+            for (let i of options.handlers) {
+                if (i.name === data.method) {
+                    if (i.type === "signal") {
+                        i.invoke(packetData);
+                        if (data.callbackID > 0)
+                            this.sendCallback(data, {});
+                        return;
+                    }
+                    else if (i.type === "request") {
+                        const result = await i.request(packetData);
+                        this.sendCallback(data, result);
+                        return;
+                    }
+                }
+            }
+            this.sendCallback(data, { ...DefaultErrors_1.default.NOT_IMPLEMENTED, details: "method not found: " + data.method });
+        });
+        if (!options.authorized) {
+            setTimeout(() => {
+                if (!this.authorized) {
+                    this.close();
+                }
+            }, 2000);
+        }
+        setInterval(() => {
+            const now = +new Date();
+            for (let [key, value] of this.callbacks) {
+                if (now - value.time > (options.maxTimeout ?? 1000 * 60 * 15)) {
+                    value.callback({ method: "callback", data: null, callbackID: key, error: { ...DefaultErrors_1.default.TIMEOUT } });
+                    this.callbacks.delete(key);
+                }
+            }
+        }, options.maxTimeout || 1000 * 60 * 15);
+    }
+    async authorize(data) {
+        if (typeof data !== "object" || !data || !data.signature || !data.publicKey || !data.clientID || !data.url)
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "invalid data, expected {signature:encrypted hub key,publicKey:encrypted public key, clientID:clientID,url: service url}" };
+        let hubKey = null;
+        try {
+            hubKey = (0, crypto_1.privateDecrypt)(this.privateKey, data.signature).toString("utf8");
+        }
+        catch (e) {
+            return { ...DefaultErrors_1.default.UNAUTHORIZED, details: "cant check signature" };
+        }
+        if (hubKey !== this.hubID)
+            return { ...DefaultErrors_1.default.UNAUTHORIZED, details: "signature is invalid" };
+        try {
+            this.publicKey = (0, crypto_1.privateDecrypt)(this.privateKey, data.publicKey).toString("utf8");
+        }
+        catch (e) {
+            return { ...DefaultErrors_1.default.UNAUTHORIZED, details: "cant obtain public key" };
+        }
+        if (!this.publicKey)
+            return { ...DefaultErrors_1.default.UNAUTHORIZED, details: "wrong public key" };
+        return true;
+    }
+    sendCallback(packet, data) {
+        if (packet.callbackID === -1)
+            return;
+        if (this.ws && this.ws.readyState === ws_1.WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({
+                method: "callback",
+                error: DefaultErrors_1.ErrorUtils.isError(data) ? data : null,
+                data: DefaultErrors_1.ErrorUtils.isError(data) ? null : data,
+                callbackID: packet.callbackID
+            }));
+        }
+        else {
+            (0, LogService_1.logError)("HUBConnection: ws not connected, cant send callback", packet);
+        }
+    }
+    async send(packet) {
+        if (!this.ws || this.ws.readyState !== ws_1.WebSocket.OPEN) {
+            (0, LogService_1.logError)("HUBConnection: ws not connected, cant send packet", packet);
+            return { ...DefaultErrors_1.default.SERVICE_NOT_WORKING, details: "ws not connected" };
+        }
+        let cb = null;
+        const promise = new Promise((resolve) => cb = resolve);
+        if (packet.callbackID > 0) {
+            const callbackID = HUBConnection.callbackID++;
+            this.callbacks.set(callbackID, { time: +new Date(), callback: cb });
+            packet.callbackID = callbackID;
+        }
+        this.ws.send(JSON.stringify(packet));
+        if (packet.callbackID === 0)
+            return null;
+        return promise;
+    }
+    close() {
+        this.callbacks.clear();
+        if (this.ws) {
+            try {
+                this.ws.removeAllListeners();
+                this.ws.close();
+            }
+            catch (e) { }
+        }
+    }
+}
+exports.HUBConnection = HUBConnection;

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

@@ -6,6 +6,10 @@ declare class DefaultErrors {
     static FILE_TOO_LARGE: IError;
     static CANT_SEND_FILE: IError;
     static FILE_NOT_EXISTS: IError;
+    static UNAUTHORIZED: IError;
+    static BAD_REQUEST: IError;
+    static SERVICE_NOT_WORKING: IError;
+    static TIMEOUT: IError;
 }
 export declare class ErrorUtils {
     static isError(obj: any): boolean;

package/dist/apiServer/structures/DefaultErrors.js

@@ -9,6 +9,10 @@ class DefaultErrors {
     static FILE_TOO_LARGE = { code: 4, message: "File is too large" };
     static CANT_SEND_FILE = { code: 5, message: "Can't send file" };
     static FILE_NOT_EXISTS = { code: 5, message: "File not exists" };
+    static UNAUTHORIZED = { code: 6, message: "Unauthorized" };
+    static BAD_REQUEST = { code: 7, message: "Bad request", httpStatus: 400 };
+    static SERVICE_NOT_WORKING = { code: 8, message: "Service not working" };
+    static TIMEOUT = { code: 9, message: "Timeout" };
 }
 class ErrorUtils {
     static isError(obj) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "2.4.2",
+  "version": "2.4.3",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,11 +20,12 @@
     "@types/express-fileupload": "^1.5.0",
     "@types/mysql": "^2.15.21",
     "@types/ws": "^8.5.9",
-    "axios": "^1.7.2",
-    "badmfck-signal": "^1.4.5",
+    "axios": "^1.7.7",
+    "badmfck-signal": "^1.4.7",
+    "comment-parser": "^1.4.1",
     "cors": "^2.8.5",
-    "express": "^4.19.2",
-    "express-fileupload": "^1.5.0",
+    "express": "^4.21.1",
+    "express-fileupload": "^1.5.1",
     "mysql2": "^3.11.3",
     "ws": "^8.18.0"
   },