badmfck-api-server 3.9.93 → 3.9.95

package/dist/apiServer/APIService.js

@@ -50,7 +50,7 @@ function defaultOptions() {
     return {
         port: 8080,
         baseEndPoint: "/api/",
-        corsHostWhiteList: ["localhost:3000"],
+        corsHostWhiteList: ["http://localhost:3000"],
         endpoints: [],
         jsonLimit: "10mb",
         projectName: "Application project",
@@ -77,7 +77,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());
@@ -105,7 +105,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 +153,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 +172,7 @@ class APIService extends BaseService_1.BaseService {
                     response: undefined,
                     files: undefined
                 });
+                return;
             },
             limits: { fileSize: this.options.fileLimit },
             useTempFiles: true,
@@ -168,7 +180,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 +205,53 @@ class APIService extends BaseService_1.BaseService {
                 response: undefined,
                 files: undefined
             });
+            return;
         });
+        const corsSet = new Set(this.options.corsHostWhiteList.map(x => String(x).replace(/\/$/, "")));
         const corsOptions = {
             origin: (origin, callback) => {
-                const originIsWhitelisted = this.options.corsHostWhiteList.includes(origin);
-                callback(null, originIsWhitelisted);
+                if (!origin)
+                    return callback(null, true);
+                try {
+                    const o = new URL(String(origin));
+                    const originNorm = o.origin.replace(/\/$/, "");
+                    const hostNorm = o.host.replace(/\/$/, "");
+                    const ok = corsSet.has(originNorm);
+                    return callback(null, ok);
+                }
+                catch {
+                    return callback(null, false);
+                }
             },
             credentials: true
         };
         app.use((0, cors_1.default)(corsOptions));
+        app.use((req, res, next) => {
+            const originHeader = req.headers.origin;
+            if (!originHeader)
+                return next();
+            let originNorm;
+            try {
+                originNorm = new URL(String(originHeader)).origin.replace(/\/$/, "");
+            }
+            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();
+        });
         BaseEndpoint_1.BaseEndpoint.setEntryPoint(this.options.baseEndPoint);
         for (let i of this.options.endpoints) {
             await i.init();
@@ -214,17 +264,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,
@@ -324,7 +374,7 @@ class APIService extends BaseService_1.BaseService {
                         }
                         this.sendResponse(req.get("Referer") ?? "", res, result, tme, ep, httpRequest);
                     };
-                    execute();
+                    return execute();
                 });
             }
         }
@@ -359,15 +409,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 +444,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 +453,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 +505,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

@@ -44,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);
@@ -53,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/external/ExternalService.js

@@ -33,6 +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 __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 }) => {
@@ -88,10 +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 {
-        }
-        catch (e) {
+        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"
+            }
+        });
+        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/structures/Interfaces.d.ts

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

package/package.json

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