@beseif-solutions/prow-core 1.0.2 → 1.0.4

package/dist/minified-utils/context.js

@@ -71,7 +71,7 @@ class Context {
                     }
                 }
                 else {
-                    resolved = ``;
+                    return undefined;
                 }
             }
             else {

package/dist/minified-utils/validation.js

@@ -457,9 +457,12 @@ const recursive_schema = async (field, data, options) => {
             : newField.key;
         const value = lodash_1.default.get(data, relativeKey, newField.default);
         const resolved = context_1.default.resolve(newField, value, options.context);
-        if (typeof resolved !== `undefined`) {
+        if (!options.no_undefined || typeof resolved !== `undefined`) {
             lodash_1.default.set(data, relativeKey, resolved);
         }
+        if (typeof resolved === `undefined` && options.array) {
+            return { schema: null, field: null };
+        }
         let calculatedSchema;
         if (newField.as_array) {
             const noArrayField = lodash_1.default.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]);
@@ -472,6 +475,8 @@ const recursive_schema = async (field, data, options) => {
                             itemSchemas.push(itemSchema);
                         }
                     }
+                    const withoutUndefined = resolved.filter((r) => typeof r !== `undefined`);
+                    lodash_1.default.set(data, relativeKey, withoutUndefined);
                 }
                 calculatedSchema = getOrderedArrayFieldSchema(newField, itemSchemas);
             }
@@ -480,7 +485,7 @@ const recursive_schema = async (field, data, options) => {
                 if (noArrayField.type === `dict` && noArrayField.items) {
                     const items = [];
                     for (const item of noArrayField.items) {
-                        const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context });
+                        const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context, no_undefined: true });
                         if (recursive) {
                             items.push({ key: item.key, schema: recursive.schema, field: recursive.field });
                         }
@@ -495,15 +500,21 @@ const recursive_schema = async (field, data, options) => {
             }
         }
         else if (newField.type === `dict` && newField.items) {
-            const items = [];
-            for (const item of newField.items) {
-                const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: relativeKey, context: options.context });
-                if (recursive) {
-                    items.push({ key: item.key, schema: recursive.schema, field: recursive.field });
+            if (resolved || newField.required) {
+                const items = [];
+                for (const item of newField.items) {
+                    const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: relativeKey, context: options.context });
+                    if (recursive) {
+                        items.push({ key: item.key, schema: recursive.schema, field: recursive.field });
+                    }
                 }
+                calculatedSchema = getObjectFieldSchema(newField, items);
+                newField.items = items.map((i) => i.field);
+            }
+            else {
+                delete newField.items;
+                calculatedSchema = getSimpleFieldSchema(newField);
             }
-            calculatedSchema = getObjectFieldSchema(newField, items);
-            newField.items = items.map((i) => i.field);
         }
         else {
             calculatedSchema = getSimpleFieldSchema(newField);
@@ -600,7 +611,7 @@ const extract_recursive = async (validation, options, path = ``) => {
             const key = lodash_1.default.compact([path, field.key]).join(`.`);
             lodash_1.default.set(response, key, options.original ? field.original : field.value);
         }
-        return response;
+        return JSON.parse(JSON.stringify(response));
     }
     catch (e) {
         throw e;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beseif-solutions/prow-core",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Prow core functionalities and classes",
   "main": "dist/index.js",
   "scripts": {

package/src/minified-utils/context.ts

@@ -82,7 +82,11 @@ class Context {
         } else {
           resolved = _.toString(get);
         }
-      } else { resolved = ``; }
+      } else {
+        // empty value
+        // resolved = ``;
+        return undefined;
+      }
     } else {
       // partial expression
       const parts = split(unresolved);

package/src/minified-utils/validation.ts

@@ -478,7 +478,7 @@ export const alter = (field: Field, relative: string, data: Record<string, any>)
   return cloned;
 };
 
-const recursive_schema = async (field: Field, data: Record<string, any>, options: { alter: boolean, relative?: string, array?: boolean, context: Record<string, any> }): Promise<{ schema: Joi.Schema, field: Field }> => {
+const recursive_schema = async (field: Field, data: Record<string, any>, options: { alter: boolean, context: Record<string, any>, relative?: string, array?: boolean, no_undefined?: boolean }): Promise<{ schema: Joi.Schema, field: Field }> => {
   try {
     let newField: Field = _.cloneDeep(field);
 
@@ -505,9 +505,12 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
 
     const value = _.get(data, relativeKey, newField.default);
 
-    // resolve value with context (even if it's not valid - omit undefined)
+    // resolve value with context (even if it's not valid)
     const resolved = context.resolve(newField, value, options.context);
-    if (typeof resolved !== `undefined`) { _.set(data, relativeKey, resolved); }
+    if (!options.no_undefined || typeof resolved !== `undefined`) { _.set(data, relativeKey, resolved); }
+
+    // omit undefined for array mappings
+    if (typeof resolved === `undefined` && options.array) { return { schema: null, field: null }; }
 
     // get schema for field with data
     let calculatedSchema: Joi.Schema;
@@ -521,6 +524,10 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
             const { schema: itemSchema } = await recursive_schema(noArrayField, data, { alter: false, relative: `${relativeKey}[${i}]`, array: true, context: options.context });
             if (itemSchema) { itemSchemas.push(itemSchema); }
           }
+
+          // override array value - omit undefined items
+          const withoutUndefined = resolved.filter((r) => typeof r !== `undefined`);
+          _.set(data, relativeKey, withoutUndefined);
         }
 
         calculatedSchema = getOrderedArrayFieldSchema(newField, itemSchemas);
@@ -530,7 +537,7 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
           const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
 
           for (const item of noArrayField.items) {
-            const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context });
+            const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context, no_undefined: true });
             if (recursive) { items.push({ key: item.key, schema: recursive.schema, field: recursive.field }); }
           }
 
@@ -543,15 +550,20 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
         calculatedSchema = getItemsArrayFieldSchema(newField, [genericItemSchema]);
       }
     } else if (newField.type === `dict` && newField.items) {
-      const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
+      if (resolved || newField.required) {
+        const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
 
-      for (const item of newField.items) {
-        const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: relativeKey, context: options.context });
-        if (recursive) { items.push({ key: item.key, schema: recursive.schema, field: recursive.field }); }
-      }
+        for (const item of newField.items) {
+          const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: relativeKey, context: options.context });
+          if (recursive) { items.push({ key: item.key, schema: recursive.schema, field: recursive.field }); }
+        }
 
-      calculatedSchema = getObjectFieldSchema(newField, items);
-      newField.items = items.map((i) => i.field);
+        calculatedSchema = getObjectFieldSchema(newField, items);
+        newField.items = items.map((i) => i.field);
+      } else {
+        delete newField.items;
+        calculatedSchema = getSimpleFieldSchema(newField);
+      }
     } else {
       calculatedSchema = getSimpleFieldSchema(newField);
     }
@@ -642,7 +654,8 @@ const extract_recursive = async (validation: Field<ValidationExtended>[], option
       const key = _.compact([path, field.key]).join(`.`);
       _.set(response, key, options.original ? field.original : field.value);
     }
-    return response;
+    // remove undefined values
+    return JSON.parse(JSON.stringify(response));
   } catch (e) { throw e; }
 };