badmfck-api-server 2.9.8 → 2.9.9

package/dist/apiServer/APIService.js

@@ -89,7 +89,7 @@ async function Initializer(services) {
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
     static nextLogID = 0;
-    version = "2.9.8";
+    version = "2.9.9";
     options;
     monitor = null;
     monitorIndexFile;

package/dist/apiServer/BaseEndpoint.d.ts

@@ -12,6 +12,7 @@ type IHandler = Record<HTTPMethod, ((req: HTTPRequestVO) => Promise<TransferPack
     controller: (req: HTTPRequestVO) => Promise<TransferPacketVO<any>>;
     ignoreInterceptor?: boolean;
     allowInterceptorError?: boolean;
+    validationModel?: any;
     asStream?: boolean;
 }>;
 export interface IEndpointHandler {
@@ -21,6 +22,7 @@ export interface IEndpointHandler {
     independed?: boolean;
     allowInterceptorError?: boolean;
     asStream?: boolean;
+    validationModel?: any;
 }
 export declare class BaseEndpoint implements IBaseEndpoint {
     private inializedEndpointNames;
@@ -36,6 +38,7 @@ export declare class BaseEndpoint implements IBaseEndpoint {
     getInitalizedEndpointNames(): String[];
     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;
 }
 export {};

package/dist/apiServer/BaseEndpoint.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEndpoint = void 0;
+const Validator_1 = require("./helper/Validator");
 const LogService_1 = require("./LogService");
 const DefaultErrors_1 = __importDefault(require("./structures/DefaultErrors"));
 const stream_1 = require("stream");
@@ -71,10 +72,15 @@ class BaseEndpoint {
                 let targetEP = BaseEndpoint.entrypoint + i.endpoint;
                 targetEP = targetEP.replaceAll("//", "/");
                 if (targetEP === req.endpoint) {
-                    if (i.handler && typeof i.handler === "function")
+                    if (i.handler && typeof i.handler === "function") {
+                        if (i.validationModel)
+                            await this.validateStructure(i.validationModel, req);
                         return i.handler.call(this, req);
+                    }
                     const httpMethod = req.method.toUpperCase();
                     if (i.handler && i.handler[httpMethod] && typeof i.handler[httpMethod] === "function") {
+                        if (i.validationModel)
+                            await this.validateStructure(i.validationModel, req);
                         if (i.asStream)
                             req = this.createStream(req);
                         return i.handler[httpMethod].call(this, req);
@@ -84,6 +90,9 @@ class BaseEndpoint {
                         && typeof i.handler[httpMethod] === "object"
                         && "controller" in i.handler[httpMethod]
                         && typeof i.handler[httpMethod].controller === "function") {
+                        const vmodel = i.handler[httpMethod].validationModel;
+                        if (vmodel)
+                            await this.validateStructure(vmodel, req);
                         if (i.asStream)
                             req = this.createStream(req);
                         return i.handler[httpMethod].controller.call(this, req);
@@ -101,6 +110,15 @@ class BaseEndpoint {
             data: null
         };
     }
+    async validateStructure(structure, req) {
+        if (!structure)
+            return;
+        if (typeof structure === "object" && (!req.data || typeof req.data !== "object"))
+            throw { ...DefaultErrors_1.default.BAD_REQUEST, details: "empty or invalid request" };
+        const report = await Validator_1.Validator.validateStructure(structure, req.data);
+        if (report)
+            throw { ...DefaultErrors_1.default.BAD_REQUEST, details: report };
+    }
     createStream(req) {
         const res = req.response;
         res.setHeader('Content-Type', 'text/plain');

package/dist/apiServer/helper/Validator.d.ts

@@ -21,6 +21,7 @@ export declare enum ValidationReport {
 }
 export declare class Validator {
     static validateObject(fields: string[], object: any): boolean;
+    static validateStructure(structure: any, object: any): Promise<string[] | undefined>;
     static convertToType<T>(value: any, type: "string" | "number" | "boolean" | "date"): T | null;
     static validateValue(value: string | number | boolean, opt?: IValidatorOptions): ValidationReport;
 }

package/dist/apiServer/helper/Validator.js

@@ -20,6 +20,70 @@ class Validator {
         }
         return true;
     }
+    static async validateStructure(structure, object) {
+        if (!structure)
+            return;
+        if (!object)
+            return ["no data"];
+        if (typeof structure !== "object") {
+            if (typeof object === "object")
+                return ["wrong datatype"];
+            if (typeof object !== typeof structure)
+                return ["datatype missmatch"];
+            return;
+        }
+        if (typeof structure === "function") {
+            let result = ['can`t validate data'];
+            try {
+                result = await structure(object);
+            }
+            catch (e) { }
+            return result;
+        }
+        let errors = [];
+        for (let i in structure) {
+            if (!(i in object))
+                errors.push("no field '" + i + "'");
+            if (typeof object[i] !== typeof structure[i])
+                errors.push("wrong datatype for field '" + i + "' expected " + typeof structure[i] + " got " + typeof object[i]);
+            if (typeof structure[i] === "object" || typeof structure[i] === "function") {
+                const result = await this.validateStructure(structure[i], object[i]);
+                if (result) {
+                    for (let j of result)
+                        errors.push(j);
+                }
+            }
+            if (typeof structure[i] === "string" && structure[i].includes(",")) {
+                const expected = structure[i].split(",").map((v) => v.trim().toLowerCase());
+                if (expected.length) {
+                    const value = object[i].toString().toLowerCase().trim();
+                    if (value.length === 0)
+                        errors.push("empty value for field '" + i + "'");
+                    else if (expected.indexOf(value) === -1)
+                        errors.push("wrong value for field '" + i + "', expected " + expected.join(", ") + " got: " + value);
+                }
+            }
+            if (typeof structure[i] === "number") {
+                if (isNaN(object[i]))
+                    errors.push("wrong value for field '" + i + "', expected number got " + object[i]);
+                if (structure[i] != 0) {
+                    if (structure[i] > 0) {
+                        const max = structure[i];
+                        if (object[i] > max)
+                            errors.push("value for field '" + i + "' is too big, expected less than " + max + " got: " + object[i]);
+                    }
+                    else {
+                        const min = structure[i] * -1;
+                        if (object[i] < min)
+                            errors.push("value for field '" + i + "' is too small, expected more than " + min + " got: " + object[i]);
+                    }
+                }
+            }
+        }
+        if (errors.length > 0)
+            return errors;
+        return;
+    }
     static convertToType(value, type) {
         if (value === null || value === undefined)
             return null;

package/package.json

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