badmfck-api-server 3.8.9 → 3.9.0

package/dist/apiServer/APIService.js

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

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

@@ -1,4 +1,14 @@
 export type TValidatorType = "string" | "number" | "boolean" | "date" | "array" | "object" | "email" | "phone";
+export interface IStructureOptions {
+    optional?: boolean;
+    skip_validation?: boolean;
+    default?: any;
+    values?: any;
+    regex?: string;
+    min?: number;
+    max?: number;
+    details?: string;
+}
 export interface IValidatorOptions {
     min?: number;
     max?: number;
@@ -47,6 +57,7 @@ export type ValidationModel<T> = DeepMutable<{
 export declare class Validator {
     static validateObject(fields: string[], object: any): boolean;
     static documentStructure(structure: any): Record<string, any> | undefined;
+    static parseStructureOptions(key: string, structure: Record<string, any>): IStructureOptions;
     static validateStructure(structure: any, object: any, level?: number, parentPath?: string): Promise<string[] | undefined>;
     static filterStructure(structure: any, object: any): void;
     static syncStructure(structure: any, object: any): any;

package/dist/apiServer/helper/Validator.js

@@ -60,6 +60,33 @@ class Validator {
         }
         return params;
     }
+    static parseStructureOptions(key, structure) {
+        let k = '$__' + key;
+        let s_options = structure[k];
+        if (s_options === null)
+            s_options = {};
+        if (typeof s_options === "string")
+            s_options = { details: s_options };
+        k = k + "_";
+        if (s_options.min == undefined || isNaN(s_options.min)) {
+            if (structure[key + "min"] && !isNaN(structure[key + "min"]))
+                s_options.min = parseInt(structure[key + "min"]);
+        }
+        if (s_options.min && isNaN(s_options.min))
+            s_options.min = undefined;
+        if (s_options.max == undefined || isNaN(s_options.max)) {
+            if (structure[key + "max"] && !isNaN(structure[key + "max"]))
+                s_options.min = parseInt(structure[key + "max"]);
+        }
+        if (s_options.max && isNaN(s_options.max))
+            s_options.max = undefined;
+        return {
+            ...s_options,
+            optional: s_options.optional === undefined ? structure[k + 'optional'] ?? false : s_options.optional,
+            default: s_options.default === undefined ? structure[k + 'default'] ?? undefined : s_options.default,
+            regex: s_options.regex === undefined ? structure[k + 'regex'] ?? undefined : s_options.regex,
+        };
+    }
     static async validateStructure(structure, object, level = 0, parentPath = "") {
         if (!structure)
             return;
@@ -91,13 +118,21 @@ class Validator {
                 foundKeys.push(i);
                 continue;
             }
-            let optional = structure['$__' + i + "_optional"] || false;
-            if (!(i in object)) {
-                if (structure["$__" + i + "_default"]) {
-                    object[i] = structure["$__" + i + "_default"];
+            let structureOptions = Validator.parseStructureOptions(i, structure);
+            if (structureOptions.skip_validation) {
+                foundKeys.push(i);
+                continue;
+            }
+            if ((object[i] === null || object[i] === undefined || !(i in object)) && structure[i] !== null && structure[i] !== undefined) {
+                if (structureOptions.default) {
+                    object[i] = structureOptions.default;
                 }
                 else {
-                    if (!optional) {
+                    if (structureOptions.optional) {
+                        foundKeys.push(i);
+                        continue;
+                    }
+                    else {
                         if (Array.isArray(object) && !isNaN(parseInt(`${i}`))) {
                             const p = parentPath.length > 0 ? parentPath.slice(0, -1) : parentPath;
                             errors.push("no item for '" + p + "[" + i + "]'");
@@ -107,19 +142,17 @@ class Validator {
                         }
                         continue;
                     }
-                    else {
-                        foundKeys.push(i);
-                        continue;
-                    }
                 }
             }
-            if (object[i] === null || object[i] === undefined) {
-                if (!optional)
-                    errors.push("no value for field '" + parentPath + i + "'");
-                else {
+            if ((object[i] === null || object[i] === undefined)) {
+                if (structure[i] === null || structure[i] === undefined) {
                     foundKeys.push(i);
                     continue;
                 }
+                else {
+                    errors.push("no field '" + parentPath + i + "'");
+                    continue;
+                }
             }
             if (typeof structure[i] === "number" && typeof object[i] === "string") {
                 let num = parseInt(object[i]);
@@ -159,25 +192,23 @@ class Validator {
                         errors.push("wrong value for field '" + parentPath + i + "', expected " + expected.join(", ") + " got: " + value);
                 }
             }
-            if (structure['$__' + i + "_values"]) {
-                const values = structure['$__' + i + "_values"];
-                if (Array.isArray(values) && values.length) {
-                    if (!values.includes(object[i])) {
-                        let caseValue = null;
-                        for (let i of values) {
-                            const v = i.toLowerCase();
-                            if (v === (object[i] + "").toLowerCase()) {
-                                caseValue = object[i];
-                                break;
-                            }
+            if (structure['$__' + i + "_values"])
+                structureOptions.values = structure['$__' + i + "_values"];
+            if (Array.isArray(structureOptions.values) && structureOptions.values.length) {
+                if (!structureOptions.values.includes(object[i])) {
+                    let caseValue = null;
+                    for (let i of structureOptions.values) {
+                        const v = i.toLowerCase();
+                        if (v === (object[i] + "").toLowerCase()) {
+                            caseValue = object[i];
+                            break;
                         }
-                        errors.push("wrong value for field '" + parentPath + i + "'" + (caseValue ? ", check case for: " + caseValue : ""));
                     }
+                    errors.push("wrong value for field '" + parentPath + i + "'" + (caseValue ? ", check case for: " + caseValue : ""));
                 }
             }
-            if (typeof structure[i] === "string" && structure["$__" + i + "_regex"]) {
-                const regex = structure["$__" + i + "_regex"];
-                const reg = new RegExp(regex);
+            if (typeof structure[i] === "string" && structureOptions.regex) {
+                const reg = new RegExp(structureOptions.regex);
                 if (reg.test(object[i]) === false)
                     errors.push("wrong value for field '" + parentPath + i + "', false mask for: >" + object[i] + "<");
             }
@@ -215,25 +246,21 @@ class Validator {
                     }
                 }
             }
-            if (typeof structure[i] === "number" && structure["$__" + i + "_min"]) {
-                const min = structure["$__" + i + "_min"];
-                if (object[i] < min)
-                    errors.push("value for field '" + parentPath + i + "' is too small, expected more than " + min + " got: " + object[i]);
+            if (typeof structure[i] === "number" && structureOptions.min && !isNaN(structureOptions.min)) {
+                if (object[i] < structureOptions.min)
+                    errors.push("value for field '" + parentPath + i + "' is too small, expected more than " + structureOptions.min + " got: " + object[i]);
             }
-            if (typeof structure[i] === "number" && structure["$__" + i + "_max"]) {
-                const max = structure["$__" + i + "_max"];
-                if (object[i] > max)
-                    errors.push("value for field '" + parentPath + i + "' is too big, expected less than " + max + " got: " + object[i]);
+            if (typeof structure[i] === "number" && structureOptions.max && !isNaN(structureOptions.max)) {
+                if (object[i] > structureOptions.max)
+                    errors.push("value for field '" + parentPath + i + "' is too big, expected less than " + structureOptions.max + " got: " + object[i]);
             }
-            if (typeof object[i] === "string" && structure["$__" + i + "_min"]) {
-                const min = structure["$__" + i + "_min"];
-                if (object[i].length < min)
-                    errors.push("value length for field '" + parentPath + i + "' is too small, expected more than " + min + " got: " + object[i].length);
+            if (typeof object[i] === "string" && structureOptions.min && !isNaN(structureOptions.min)) {
+                if (object[i].length < structureOptions.min)
+                    errors.push("value length for field '" + parentPath + i + "' is too small, expected more than " + structureOptions.min + " got: " + object[i].length);
             }
-            if (typeof object[i] === "string" && structure["$__" + i + "_max"]) {
-                const max = structure["$__" + i + "_max"];
-                if (object[i].length > max)
-                    errors.push("value length for field '" + parentPath + i + "' is too big, expected less than " + max + " got: " + object[i].length);
+            if (typeof object[i] === "string" && structureOptions.max && !isNaN(structureOptions.max)) {
+                if (object[i].length > structureOptions.max)
+                    errors.push("value length for field '" + parentPath + i + "' is too big, expected less than " + structureOptions.max + " got: " + object[i].length);
             }
             foundKeys.push(i);
         }
@@ -281,10 +308,16 @@ class Validator {
                 object[key] = structureValue;
                 continue;
             }
+            const options = Validator.parseStructureOptions(key, structure);
             if (objectValue === null && structureValue !== null) {
-                if (!structure["$__" + key + "_optional"])
+                if (!options.optional) {
                     object[key] = structureValue;
-                continue;
+                    continue;
+                }
+                if (!options.skip_validation) {
+                    object[key] = structureValue;
+                    continue;
+                }
             }
             if (key.startsWith("$__")) {
                 object[key] = structure[key];

package/package.json

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