badmfck-api-server 3.9.95 → 3.9.97

package/dist/apiServer/APIService.js

@@ -45,6 +45,7 @@ const MonitorService_1 = require("./MonitorService");
 const MysqlAdapter_1 = require("./db/MysqlAdapter");
 const DocumentService_1 = require("./DocumentService");
 const Documentation_1 = require("./documentation/Documentation");
+const MicroserviceHostController_1 = require("./external/MicroserviceHostController");
 let nextLogID = 0;
 function defaultOptions() {
     return {
@@ -92,7 +93,7 @@ async function Initializer(services) {
 }
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
-    version = "3.9.94";
+    version = "3.9.97";
     options;
     monitor = null;
     started = new Date();
@@ -122,6 +123,7 @@ class APIService extends BaseService_1.BaseService {
         this.options.endpoints.push(new Monitor_1.Monitor(this.options));
         this.options.endpoints.push(new Documentation_1.Documentation(this.options));
         this.options.endpoints.push(new ExternalServiceEndpoint_1.ExternalServiceEndpoint());
+        this.options.endpoints.push(new MicroserviceHostController_1.MicroserviceHostController());
         new DocumentService_1.DocumentGenerator(this.options.endpoints);
         this.monitor = new MonitorService_1.MonitorService();
         this.monitor.init();

package/dist/apiServer/external/ExternalService.js

@@ -99,7 +99,7 @@ class ExternalService extends BaseService_1.BaseService {
         if (!resp.ok) {
             return { ...DefaultErrors_1.default.BAD_REQUEST, details: resp.details, stack: resp.error };
         }
-        const json = await resp.data.json();
+        const json = resp.data;
         if (typeof json === "object" && "error" in json)
             return json.error;
         if (typeof json === "object" && "data" in json)

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

@@ -1,4 +1,25 @@
+import { Req } from "badmfck-signal";
 import { BaseService } from "../BaseService";
+import { IError } from "../structures/Interfaces";
+export interface IMicroserviceClientOptions {
+    id: string;
+    securityKey: string;
+    host: string;
+    password: string;
+}
+export declare const REQ_MICROSERVICE_CALL: Req<{
+    id: string;
+    requestName: string;
+    requestData: any;
+}, any>;
 export declare class MicroserviceClient extends BaseService {
-    constructor();
+    #private;
+    options: IMicroserviceClientOptions;
+    constructor(opt: IMicroserviceClientOptions);
+    init(): Promise<void>;
+    requestMicroserviceCall(req: {
+        id: string;
+        requestName: string;
+        requestData: any;
+    }): Promise<any | IError>;
 }

package/dist/apiServer/external/MicroserviceClient.js

@@ -1,10 +1,63 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MicroserviceClient = void 0;
+exports.MicroserviceClient = exports.REQ_MICROSERVICE_CALL = void 0;
+const badmfck_signal_1 = require("badmfck-signal");
 const BaseService_1 = require("../BaseService");
+const DefaultErrors_1 = __importDefault(require("../structures/DefaultErrors"));
+const Http_1 = require("../http/Http");
+const crypto_1 = __importDefault(require("crypto"));
+exports.REQ_MICROSERVICE_CALL = new badmfck_signal_1.Req(undefined, "REQ_MICROSERVICE_CALL");
 class MicroserviceClient extends BaseService_1.BaseService {
-    constructor() {
+    static #clients = new Map();
+    static #listener = false;
+    options;
+    constructor(opt) {
         super("MicroserviceClient");
+        this.options = opt;
+        MicroserviceClient.#clients.set(opt.id, this);
+        if (!MicroserviceClient.#listener) {
+            exports.REQ_MICROSERVICE_CALL.listener = async ({ id, requestName, requestData }) => {
+                const client = MicroserviceClient.#clients.get(id);
+                if (!client) {
+                    return { ...DefaultErrors_1.default.BAD_REQUEST, details: "no microservice client found: " + id + ", requestName:" + requestName };
+                }
+                return await client.requestMicroserviceCall({ id, requestName, requestData });
+            };
+            MicroserviceClient.#listener = true;
+        }
+    }
+    async init() {
+        super.init();
+    }
+    async requestMicroserviceCall(req) {
+        const url = this.options.host + "/__ms_host_control/receiver";
+        const ts = (+new Date()).toString();
+        const nonce = crypto_1.default.randomBytes(16).toString("hex");
+        const headers = {
+            "Content-Type": "application/json",
+            "x-microservice-id": this.options.id,
+            "x-microservice-ts": ts,
+            "x-microservice-nonce": nonce
+        };
+        const data = Buffer.from(JSON.stringify(req), "utf8");
+        const secret = Buffer.from(this.options.securityKey, "base64");
+        const salt = crypto_1.default.createHash("sha256").update(nonce + ts).digest();
+        const key = crypto_1.default.pbkdf2Sync(secret, salt, 100, 32, "sha256");
+        const iv = crypto_1.default.pbkdf2Sync(secret, salt, 100, 16, "sha256");
+        const aad = Buffer.from(ts + "." + nonce + "." + this.options.id + "." + this.options.password, "utf8");
+        const cipher = crypto_1.default.createCipheriv("aes-256-gcm", key, iv);
+        cipher.setAAD(aad);
+        const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        const resp = await Http_1.Http.post(url, { tag: tag.toString("base64"), enc: encrypted.toString("base64") }, { headers });
+        if (!resp.ok)
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: resp.details, stack: [resp.error] };
+        if (resp.data && typeof resp.data === "object" && "error" in resp.data)
+            return resp.data.error;
+        return resp.data;
     }
 }
 exports.MicroserviceClient = MicroserviceClient;

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

@@ -1,4 +1,17 @@
+import { Req } from "badmfck-signal";
 import { BaseService } from "../BaseService";
+import { HTTPRequestVO, IError } from "../structures/Interfaces";
+export interface IMicroserviceHostOptions {
+    id: string;
+    securityKey: string;
+    password: string;
+    requests: Req<any, any>[];
+}
 export declare class MicroserviceHost extends BaseService {
-    constructor();
+    #private;
+    options: IMicroserviceHostOptions;
+    constructor(opt: IMicroserviceHostOptions);
+    init(): Promise<void>;
+    static getMicroservice(id: string): MicroserviceHost | null;
+    handleIncomingRequest(req: HTTPRequestVO): Promise<any | IError>;
 }

package/dist/apiServer/external/MicroserviceHost.js

@@ -1,10 +1,107 @@
 "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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MicroserviceHost = void 0;
 const BaseService_1 = require("../BaseService");
+const DefaultErrors_1 = __importStar(require("../structures/DefaultErrors"));
+const crypto_1 = __importDefault(require("crypto"));
 class MicroserviceHost extends BaseService_1.BaseService {
-    constructor() {
-        super("MicroserviceHost");
+    static #calls = new Set();
+    static #instances = new Map();
+    options;
+    constructor(opt) {
+        super("Microservice-host-" + opt.id);
+        this.options = opt;
+        MicroserviceHost.#instances.set(opt.id, this);
+    }
+    async init() {
+        super.init();
+    }
+    static getMicroservice(id) {
+        return MicroserviceHost.#instances.get(id) || null;
+    }
+    async handleIncomingRequest(req) {
+        console.log("Handling incoming request for MicroserviceHost:", this.getName());
+        const nonce = req.headers["x-microservice-nonce"];
+        const ts = req.headers["x-microservice-ts"];
+        if (!nonce || !ts)
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "missing headers" };
+        if (ts.length !== 13 || isNaN(+ts))
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "invalid timestamp" };
+        if (+new Date() - (+ts) > 1000 * 60 * 2)
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "timestamp too old" };
+        const checkCall = MicroserviceHost.#calls.has(nonce + "|" + ts);
+        if (checkCall)
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "replay attack detected" };
+        MicroserviceHost.#calls.add(nonce + "|" + ts);
+        if (MicroserviceHost.#calls.size > 1000) {
+            const first = MicroserviceHost.#calls.values().next().value;
+            if (first)
+                MicroserviceHost.#calls.delete(first);
+        }
+        const secret = Buffer.from(this.options.securityKey, "base64");
+        const salt = crypto_1.default.createHash("sha256").update(nonce + ts).digest();
+        const key = crypto_1.default.pbkdf2Sync(secret, salt, 100, 32, "sha256");
+        const iv = crypto_1.default.pbkdf2Sync(secret, salt, 100, 16, "sha256");
+        const aad = Buffer.from(ts + "." + nonce + "." + this.options.id + "." + this.options.password, "utf8");
+        const tag = req.data.tag;
+        const encryptedData = req.data.enc;
+        const decipher = crypto_1.default.createDecipheriv("aes-256-gcm", key, iv);
+        decipher.setAAD(aad);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
+        let request = null;
+        try {
+            request = JSON.parse(decrypted.toString("utf8"));
+        }
+        catch (e) {
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "invalid json request" };
+        }
+        if (!request) {
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "no request found" };
+        }
+        if (typeof request !== "object" || !request.requestName) {
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "invalid request object" };
+        }
+        const reqCall = this.options.requests.find(r => r.name === request.requestName);
+        if (!reqCall) {
+            return { ...DefaultErrors_1.default.BAD_REQUEST, details: "request not found: " + request.requestName };
+        }
+        let response = null;
+        try {
+            response = await reqCall.request(request.requestData);
+        }
+        catch (e) {
+            if (DefaultErrors_1.ErrorUtils.isError(e))
+                return e;
+            return { ...DefaultErrors_1.default.INTERNAL_SERVER_ERROR, details: "request execution error: " + e?.message };
+        }
+        return response;
     }
 }
 exports.MicroserviceHost = MicroserviceHost;

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

@@ -0,0 +1,6 @@
+import { BaseEndpoint } from "../BaseEndpoint";
+import { HTTPRequestVO, TransferPacketVO } from "../structures/Interfaces";
+export declare class MicroserviceHostController extends BaseEndpoint {
+    constructor();
+    receiver(req: HTTPRequestVO): Promise<TransferPacketVO>;
+}

package/dist/apiServer/external/MicroserviceHostController.js

@@ -0,0 +1,55 @@
+"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.MicroserviceHostController = void 0;
+const BaseEndpoint_1 = require("../BaseEndpoint");
+const DefaultErrors_1 = __importStar(require("../structures/DefaultErrors"));
+const MicroserviceHost_1 = require("./MicroserviceHost");
+class MicroserviceHostController extends BaseEndpoint_1.BaseEndpoint {
+    constructor() {
+        super("__ms_host_control");
+        this.ignoreInDocumentation = true;
+        this.ignoreHttpLogging = true;
+        this.registerEndpoints([{
+                ignoreInDocumentation: true,
+                endpoint: "receiver",
+                handler: this.receiver,
+                ignoreInterceptor: true,
+            },
+        ]);
+    }
+    async receiver(req) {
+        if (req.method.toUpperCase() !== "POST")
+            throw DefaultErrors_1.default.METHOD_NOT_ALLOWED;
+        const microserviceHost = MicroserviceHost_1.MicroserviceHost.getMicroservice(req.headers["x-microservice-id"]);
+        if (!microserviceHost)
+            throw { ...DefaultErrors_1.default.NOT_FOUND, message: "Microservice host not found" };
+        const result = await microserviceHost.handleIncomingRequest(req);
+        if (DefaultErrors_1.ErrorUtils.isError(result))
+            throw result;
+        return { data: result };
+    }
+}
+exports.MicroserviceHostController = MicroserviceHostController;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "3.9.95",
+  "version": "3.9.97",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",