badmfck-api-server 3.9.4 → 3.9.6

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.4";
+    version = "3.9.6";
     options;
     monitor = null;
     started = new Date();

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

@@ -1,3 +1,9 @@
+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;
@@ -31,24 +37,32 @@ export declare enum ValidationReport {
 }
 type WidenLiteral<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
 type WidenLiterals<T> = {
-    [K in keyof T]: T[K] extends (infer R)[] ? WidenLiteral<R>[] : T[K] extends object ? WidenLiterals<T[K]> : WidenLiteral<T[K]>;
-};
-type DeepMutable<T> = {
-    -readonly [K in keyof T]: T[K] extends object ? T[K] extends (...args: any[]) => any ? T[K] : DeepMutable<T[K]> : T[K];
+    [K in keyof T]: T[K] extends readonly (infer R)[] ? readonly WidenLiteral<R>[] : T[K] extends (infer R)[] ? WidenLiteral<R>[] : T[K] extends object ? WidenLiterals<T[K]> : WidenLiteral<T[K]>;
 };
+type DeepMutable<T> = T extends ReadonlyArray<infer U> ? DeepMutable<U>[] : T extends Array<infer U> ? DeepMutable<U>[] : T extends (...args: any[]) => any ? T : T extends object ? {
+    -readonly [K in keyof T]: DeepMutable<T[K]>;
+} : T;
+type IsNever<T> = [T] extends [never] ? true : false;
+type Or<A, B> = A extends true ? true : (B extends true ? true : false);
+type CleanFields<T> = WidenLiterals<{
+    [K in keyof T as K extends `$__${string}` ? never : K]: T[K];
+}>;
+type HasOptional<T, K extends string> = Or<`$__${K}_optional` extends keyof T ? T[`$__${K}_optional`] extends true ? true : false : false, `$__${K}` extends keyof T ? T[`$__${K}`] extends {
+    optional: true;
+} ? true : false : false>;
 type ExtractOptionalFieldNames<T> = {
-    [K in keyof T as K extends `$__${infer Base}_optional` ? Base extends keyof T ? T[K] extends true ? Base : never : never : never]: true;
+    [K in (keyof T & string) as HasOptional<T, K> extends true ? K : never]: true;
 };
 type OptionalFields<T> = keyof ExtractOptionalFieldNames<T> & string;
+type ValuesArr<T, K extends string> = `$__${K}_values` extends keyof T ? T[`$__${K}_values`] extends readonly (infer V)[] ? readonly V[] : never : `$__${K}` extends keyof T ? T[`$__${K}`] extends {
+    values: readonly (infer V)[];
+} ? readonly V[] : never : never;
 type ExtractEnumValues<T> = {
-    [K in keyof T as K extends `$__${infer Base}_values` ? Base extends keyof T ? T[K] extends readonly (infer V)[] ? Base : never : never : never]: T[K] extends readonly (infer V)[] ? V : never;
+    [K in (keyof T & string) as IsNever<ValuesArr<T, K>> extends true ? never : K]: ValuesArr<T, K> extends ReadonlyArray<infer V> ? V : never;
 };
 type EnumFieldNames<T> = keyof ExtractEnumValues<T> & string;
 type EnumFieldValues<T> = ExtractEnumValues<T>;
-type CleanFields<T> = WidenLiterals<{
-    [K in keyof T as K extends `$__${string}` ? never : K]: T[K];
-}>;
-type ProcessField<F, Meta> = F extends readonly (infer Item)[] ? Item extends object ? ValidationModel<Item>[] : F : F extends object ? ValidationModel<F> : F;
+type ProcessField<F, Meta> = F extends ReadonlyArray<infer Item> ? Item extends object ? ValidationModel<Item>[] : WidenLiteral<Item>[] : F extends Array<infer Item> ? Item extends object ? ValidationModel<Item>[] : WidenLiteral<Item>[] : F extends object ? ValidationModel<F> : WidenLiteral<F>;
 export type ValidationModel<T> = DeepMutable<{
     [K in keyof CleanFields<T> as K extends OptionalFields<T> ? K : never]?: K extends EnumFieldNames<T> ? EnumFieldValues<T>[K] : ProcessField<CleanFields<T>[K], T>;
 } & {
@@ -60,7 +74,9 @@ export declare class Validator {
     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;
+    static isPlainObject(v: any): boolean;
+    static clone<T>(v: T): T;
+    static syncStructure(structure: any, object: any, opts?: SyncOptions): 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

@@ -293,48 +293,120 @@ class Validator {
                 this.filterStructure(structure[key], object[key]);
         }
     }
-    static syncStructure(structure, object) {
-        if (typeof structure !== "object")
-            return;
+    static isPlainObject(v) {
+        return v !== null && typeof v === "object" && !Array.isArray(v);
+    }
+    static clone(v) {
+        if (typeof structuredClone === "function")
+            return structuredClone(v);
+        return JSON.parse(JSON.stringify(v));
+    }
+    static syncStructure(structure, object, opts = {
+        fillOnlyWhenNull: true,
+        resetOnTypeMismatch: true,
+        repairArrayItems: "coerce",
+        coerceArrayFromObject: "values"
+    }) {
+        if (structure === null || typeof structure !== "object")
+            return object;
+        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)]);
+                }
+                else if (mode === "wrap" && this.isPlainObject(tmpl)) {
+                    object = [object];
+                }
+                else if (mode === "values") {
+                    object = Object.values(object);
+                }
+                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);
+                    }
+                }
+            }
+            return object;
+        }
+        if (!this.isPlainObject(object))
+            return object;
         for (const key in object) {
-            if (!(key in structure)) {
+            if (!(key in structure))
                 delete object[key];
-            }
         }
         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 (!(key in object)) {
-                object[key] = structureValue;
+            if (!hasKey) {
+                object[key] = this.clone(structureValue);
                 continue;
             }
-            const options = Validator.parseStructureOptions(key, structure);
-            if (objectValue === null && structureValue !== null) {
-                if (!options.optional) {
-                    object[key] = structureValue;
-                    continue;
-                }
-                if (options.skip_validation) {
-                    object[key] = structureValue;
-                    continue;
-                }
-            }
             if (key.startsWith("$__")) {
-                object[key] = structure[key];
+                object[key] = this.clone(structureValue);
                 continue;
             }
-            if (objectValue && typeof objectValue === "object") {
-                if (Array.isArray(objectValue) && Array.isArray(structureValue) && structureValue.length > 0) {
-                    for (let i of objectValue) {
-                        if (typeof i === "object")
-                            this.syncStructure(structureValue[0], i);
+            if ((objectValue === null || objectValue === undefined) && structureValue !== null) {
+                if (!optional || skip_validation) {
+                    object[key] = this.clone(structureValue);
+                }
+                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;
+                        }
                     }
                 }
                 else {
-                    this.syncStructure(structureValue, objectValue);
+                    this.syncStructure(structureValue, objectValue, opts);
                 }
                 continue;
             }
+            if (typeof objectValue !== typeof structureValue) {
+                if (opts.resetOnTypeMismatch) {
+                    object[key] = this.clone(structureValue);
+                }
+            }
         }
         return object;
     }

package/package.json

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