badmfck-api-server 3.9.6 → 3.9.8

package/dist/apiServer/APIService.js

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

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

@@ -1,9 +1,3 @@
-type SyncOptions = {
-    fillOnlyWhenNull?: boolean;
-    resetOnTypeMismatch?: boolean;
-    repairArrayItems?: "coerce";
-    coerceArrayFromObject?: "values" | "numericKeys" | "wrap" | "off";
-};
 export type TValidatorType = "string" | "number" | "boolean" | "date" | "array" | "object" | "email" | "phone";
 export interface IStructureOptions {
     optional?: boolean;
@@ -76,7 +70,7 @@ export declare class Validator {
     static filterStructure(structure: any, object: any): void;
     static isPlainObject(v: any): boolean;
     static clone<T>(v: T): T;
-    static syncStructure(structure: any, object: any, opts?: SyncOptions): any;
+    static syncStructure(structure: any, node: any): any;
     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

@@ -301,114 +301,84 @@ class Validator {
             return structuredClone(v);
         return JSON.parse(JSON.stringify(v));
     }
-    static syncStructure(structure, object, opts = {
-        fillOnlyWhenNull: true,
-        resetOnTypeMismatch: true,
-        repairArrayItems: "coerce",
-        coerceArrayFromObject: "values"
-    }) {
+    static syncStructure(structure, node) {
         if (structure === null || typeof structure !== "object")
-            return object;
+            return node;
         if (Array.isArray(structure)) {
             const tmpl = structure[0];
-            if (!Array.isArray(object) && this.isPlainObject(object)) {
-                const mode = opts.coerceArrayFromObject ?? "values";
-                if (mode === "numericKeys") {
-                    const numeric = Object.keys(object).filter(k => String(+k) === k).map(k => +k).sort((a, b) => a - b);
-                    object = numeric.map(i => object[String(i)]);
+            if (!Array.isArray(node) && this.isPlainObject(node)) {
+                const numericKeys = Object.keys(node)
+                    .filter((k) => String(+k) === k)
+                    .map((k) => +k)
+                    .sort((a, b) => a - b);
+                const items = numericKeys.length > 0
+                    ? numericKeys.map((i) => node[String(i)])
+                    : Object.values(node);
+                return items.map((it) => this.syncStructure(tmpl, it));
+            }
+            if (!Array.isArray(node))
+                return node;
+            if (tmpl === undefined)
+                return node;
+            const out = new Array(node.length);
+            for (let i = 0; i < node.length; i++) {
+                const item = node[i];
+                if (item === null || item === undefined) {
+                    out[i] = this.syncStructure(tmpl, this.clone(tmpl));
                 }
-                else if (mode === "wrap" && this.isPlainObject(tmpl)) {
-                    object = [object];
+                else if (this.isPlainObject(tmpl) && this.isPlainObject(item)) {
+                    out[i] = this.syncStructure(tmpl, item);
                 }
-                else if (mode === "values") {
-                    object = Object.values(object);
+                else if (Array.isArray(tmpl) && Array.isArray(item)) {
+                    out[i] = this.syncStructure(tmpl, item);
                 }
                 else {
-                    return object;
-                }
-            }
-            if (!Array.isArray(object))
-                return object;
-            if (tmpl !== undefined) {
-                for (let i = 0; i < object.length; i++) {
-                    let item = object[i];
-                    if (item === null || item === undefined) {
-                        object[i] = this.clone(tmpl);
-                        this.syncStructure(tmpl, object[i], opts);
-                        continue;
-                    }
-                    if (this.isPlainObject(tmpl) && this.isPlainObject(item)) {
-                        this.syncStructure(tmpl, item, opts);
-                        continue;
-                    }
-                    if (Array.isArray(tmpl) && Array.isArray(item)) {
-                        this.syncStructure(tmpl, item, opts);
-                        continue;
-                    }
-                    if (opts.repairArrayItems === "coerce") {
-                        object[i] = this.clone(tmpl);
-                        this.syncStructure(tmpl, object[i], opts);
-                    }
+                    out[i] = this.syncStructure(tmpl, this.clone(tmpl));
                 }
             }
-            return object;
-        }
-        if (!this.isPlainObject(object))
-            return object;
-        for (const key in object) {
-            if (!(key in structure))
-                delete object[key];
+            return out;
         }
-        for (const key in structure) {
-            const structureValue = structure[key];
-            const hasKey = Object.prototype.hasOwnProperty.call(object, key);
-            const { optional = false, skip_validation = false } = (Validator.parseStructureOptions(key, structure) || {});
-            const objectValue = object[key];
-            if (!hasKey) {
-                object[key] = this.clone(structureValue);
-                continue;
-            }
-            if (key.startsWith("$__")) {
-                object[key] = this.clone(structureValue);
+        const out = {};
+        const src = this.isPlainObject(node) ? node : {};
+        for (const k of Object.keys(structure)) {
+            const sv = structure[k];
+            if (k.startsWith("$__")) {
+                out[k] = this.clone(sv);
                 continue;
             }
-            if ((objectValue === null || objectValue === undefined) && structureValue !== null) {
-                if (!optional || skip_validation) {
-                    object[key] = this.clone(structureValue);
+            const has = Object.prototype.hasOwnProperty.call(src, k);
+            const ov = has ? src[k] : undefined;
+            const { optional, skip_validation, default: def } = this.parseStructureOptions(k, structure);
+            if (!has) {
+                if (sv && typeof sv === "object") {
+                    out[k] = this.syncStructure(sv, this.clone(sv));
+                }
+                else {
+                    out[k] = this.clone(sv);
                 }
                 continue;
             }
-            const svIsObj = this.isPlainObject(structureValue);
-            const ovIsObj = this.isPlainObject(objectValue);
-            const svIsArr = Array.isArray(structureValue);
-            const ovIsArr = Array.isArray(objectValue);
-            if (svIsObj || svIsArr) {
-                if ((svIsObj && !ovIsObj) || (svIsArr && !ovIsArr)) {
-                    if (opts.resetOnTypeMismatch && svIsObj) {
-                        const base = this.clone(structureValue);
-                        if (this.isPlainObject(objectValue)) {
-                            for (const k in objectValue)
-                                base[k] = objectValue[k];
-                            this.syncStructure(structureValue, base, opts);
-                            object[key] = base;
-                        }
-                        else {
-                            object[key] = base;
-                        }
-                    }
+            if (ov === null || ov === undefined) {
+                if (def !== undefined && !optional) {
+                    out[k] = this.clone(def);
+                }
+                else if (!optional || skip_validation) {
+                    out[k] = sv && typeof sv === "object"
+                        ? this.syncStructure(sv, this.clone(sv))
+                        : this.clone(sv);
                 }
                 else {
-                    this.syncStructure(structureValue, objectValue, opts);
+                    out[k] = ov;
                 }
                 continue;
             }
-            if (typeof objectValue !== typeof structureValue) {
-                if (opts.resetOnTypeMismatch) {
-                    object[key] = this.clone(structureValue);
-                }
+            if (sv && typeof sv === "object") {
+                out[k] = this.syncStructure(sv, ov);
+                continue;
             }
+            out[k] = ov;
         }
-        return object;
+        return out;
     }
     static convertToType(value, type) {
         if (value === null || value === undefined)

package/package.json

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