badmfck-api-server 4.0.78 → 4.0.79

package/dist/apiServer/APIService.js

@@ -97,7 +97,7 @@ async function Initializer(services) {
 }
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
-    version = "4.0.78";
+    version = "4.0.79";
     options;
     monitor = null;
     started = new Date();

package/dist/apiServer/external/MicroserviceClient.js

@@ -9,6 +9,7 @@ const BaseService_1 = require("../BaseService");
 const DefaultErrors_1 = __importDefault(require("../structures/DefaultErrors"));
 const Http_1 = require("../http/Http");
 const crypto_1 = __importDefault(require("crypto"));
+const TimeframeService_1 = require("../TimeframeService");
 exports.REQ_MICROSERVICE_CALL = new badmfck_signal_1.Req(undefined, "REQ_MICROSERVICE_CALL");
 class MicroserviceClient extends BaseService_1.BaseService {
     static #clients = new Map();
@@ -37,30 +38,49 @@ class MicroserviceClient extends BaseService_1.BaseService {
         const url = this.options.host + "/__ms_host_control/receiver";
         const ts = Date.now().toString();
         const nonce = crypto_1.default.randomBytes(12).toString("hex");
-        const headers = {
-            "Content-Type": "application/json",
-            "x-microservice-id": this.options.id,
-            "x-microservice-ts": ts,
-            "x-microservice-nonce": nonce
-        };
-        const rawSecret = Buffer.from(this.options.securityKey, "base64");
-        const key = crypto_1.default.createHash("sha256").update(rawSecret).digest();
-        const hash = crypto_1.default.createHash("sha256").update(nonce + ts + this.options.securityKey).digest();
-        const iv = hash.subarray(0, 12);
-        const aad = Buffer.from(`${ts}.${nonce}.${this.options.id}`, "utf8");
-        const data = Buffer.from(JSON.stringify(req), "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 };
-        const body = resp.data;
-        return (body && typeof body === "object" && "error" in body) ? body.error : (body.data ?? null);
+        const maxAttempts = 5;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            const rawSecret = Buffer.from(this.options.securityKey, "base64");
+            const key = crypto_1.default.createHash("sha256").update(rawSecret).digest();
+            const hash = crypto_1.default.createHash("sha256").update(nonce + ts + this.options.securityKey).digest();
+            const iv = hash.subarray(0, 12);
+            const aad = Buffer.from(`${ts}.${nonce}.${this.options.id}`, "utf8");
+            const data = Buffer.from(JSON.stringify(req), "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 headers = {
+                "Content-Type": "application/json",
+                "x-microservice-id": this.options.id,
+                "x-microservice-ts": ts,
+                "x-microservice-nonce": nonce
+            };
+            const resp = await Http_1.Http.post(url, {
+                tag: tag.toString("base64"),
+                enc: encrypted.toString("base64")
+            }, { headers });
+            if (!resp.ok && resp.details?.network) {
+                if (attempt < maxAttempts) {
+                    TimeframeService_1.TimeframeService.wait(500);
+                    continue;
+                }
+                return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, details: "Network connection lost after multiple retries" };
+            }
+            if (!resp.ok)
+                return { ...DefaultErrors_1.default.BAD_REQUEST, details: resp.details };
+            const body = resp.data;
+            const isAccepted = body?.error?.code === DefaultErrors_1.default.ACCEPTED.code || body?.code === DefaultErrors_1.default.ACCEPTED.code;
+            if (isAccepted) {
+                if (attempt < maxAttempts) {
+                    TimeframeService_1.TimeframeService.wait(500);
+                    continue;
+                }
+                return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, details: "Microservice processing timeout" };
+            }
+            return (body && typeof body === "object" && "error" in body) ? body.error : (body.data ?? null);
+        }
+        return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, details: "Unknown polling error" };
     }
 }
 exports.MicroserviceClient = MicroserviceClient;

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

@@ -7,11 +7,19 @@ export interface IMicroserviceHostOptions {
     password: string;
     requests: Req<any, any>[];
 }
+type TJobStatus = "processing" | "completed";
+type TJob = {
+    status: TJobStatus;
+    result?: any | IError;
+    expires: number;
+};
 export declare class MicroserviceHost extends BaseService {
     #private;
     options: IMicroserviceHostOptions;
+    jobs: Map<string, TJob>;
     constructor(opt: IMicroserviceHostOptions);
     init(): Promise<void>;
     static getMicroservice(id: string): MicroserviceHost | null;
     handleIncomingRequest(req: HTTPRequestVO): Promise<any | IError>;
 }
+export {};

package/dist/apiServer/external/MicroserviceHost.js

@@ -1,16 +1,40 @@
 "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 = __importDefault(require("../structures/DefaultErrors"));
+const DefaultErrors_1 = __importStar(require("../structures/DefaultErrors"));
 const crypto_1 = __importDefault(require("crypto"));
 class MicroserviceHost extends BaseService_1.BaseService {
     static #calls = new Set();
     static #instances = new Map();
     options;
+    jobs = new Map();
     constructor(opt) {
         super("Microservice-host-" + opt.id);
         this.options = opt;
@@ -18,6 +42,13 @@ class MicroserviceHost extends BaseService_1.BaseService {
     }
     async init() {
         super.init();
+        setInterval(() => {
+            const now = Date.now();
+            for (const [key, job] of this.jobs) {
+                if (job.expires < now)
+                    this.jobs.delete(key);
+            }
+        }, 1000 * 60 * 5);
     }
     static getMicroservice(id) {
         return MicroserviceHost.#instances.get(id) || null;
@@ -27,6 +58,18 @@ class MicroserviceHost extends BaseService_1.BaseService {
         const ts = req.headers["x-microservice-ts"];
         if (!nonce || !ts)
             return { ...DefaultErrors_1.default.BAD_REQUEST, details: "missing headers" };
+        const jobKey = `${nonce}|${ts}`;
+        const job = this.jobs.get(jobKey);
+        if (job) {
+            if (job.expires < Date.now()) {
+                this.jobs.delete(jobKey);
+            }
+            else {
+                if (job.status === "processing")
+                    return { ...DefaultErrors_1.default.ACCEPTED, details: "request is being processed" };
+                return job.result;
+            }
+        }
         const requestTime = parseInt(ts);
         const now = Date.now();
         if (isNaN(requestTime) || Math.abs(now - requestTime) > 1000 * 60 * 2) {
@@ -61,7 +104,23 @@ class MicroserviceHost extends BaseService_1.BaseService {
             const reqCall = this.options.requests.find(r => r.name === request?.requestName);
             if (!reqCall)
                 return { ...DefaultErrors_1.default.BAD_REQUEST, details: "method not found" };
-            return await reqCall.request(request.requestData);
+            const job = {
+                status: "processing",
+                expires: Date.now() + 1000 * 60 * 5
+            };
+            this.jobs.set(jobKey, job);
+            try {
+                const result = await reqCall.request(request.requestData);
+                job.status = "completed";
+                job.result = result;
+                return result;
+            }
+            catch (e) {
+                const err = DefaultErrors_1.ErrorUtils.isError(e) ? e : { ...DefaultErrors_1.default.INTERNAL_ERROR, details: "unknown error" };
+                job.status = "completed";
+                job.result = err;
+                return job.result;
+            }
         }
         catch (e) {
             return { ...DefaultErrors_1.default.BAD_REQUEST, details: "decryption error" };

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

@@ -25,6 +25,8 @@ declare class DefaultErrors {
     static WRONG_DATA_TYPE: IError;
     static UPROCESSIABLE_CONTENT: IError;
     static WRONG_PARAMS: IError;
+    static ACCEPTED: IError;
+    static INTERNAL_ERROR: IError;
 }
 export declare class ErrorUtils {
     static isError(obj: any): obj is IError;

package/dist/apiServer/structures/DefaultErrors.js

@@ -28,6 +28,8 @@ class DefaultErrors {
     static WRONG_DATA_TYPE = { code: 23, message: "Wrong data type", httpStatus: 422 };
     static UPROCESSIABLE_CONTENT = { code: 24, message: "Unprocessable content", httpStatus: 422 };
     static WRONG_PARAMS = { code: 25, message: "Wrong params", httpStatus: 400 };
+    static ACCEPTED = { code: 26, message: "Accepted", httpStatus: 202 };
+    static INTERNAL_ERROR = { code: 27, message: "Internal error", httpStatus: 500 };
 }
 class ErrorUtils {
     static isError(obj) {

package/package.json

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