@beseif-solutions/prow-core 1.2.1 → 1.2.3

package/dist/minified-utils/fields.d.ts

@@ -106,7 +106,7 @@ export type SelectFieldChoice<Values = string | number | boolean | File, Extend
     key: string;
     value: Values;
     group?: string;
-} & Extend;
+} & Record<`experimental_${string}`, any> & Extend;
 export type CustomDisplayTextField = {
     format: `textarea` | `rich-text` | `markdown`;
 };

package/dist/minified-utils/validation.js

@@ -50,7 +50,8 @@ const choiceSchema = (type) => joi_1.default.object({
     key: joi_1.default.string().required(),
     value: type.required(),
     group: joi_1.default.string(),
-}).unknown();
+}).concat(joi_1.default.object()
+    .pattern(joi_1.default.string().regex(/^experimental_/), joi_1.default.any())).unknown();
 const choicesSchema = (type) => joi_1.default.alternatives(joi_1.default.string(), joi_1.default.array().min(1)
     .items(choiceSchema(type)));
 const defaultSchema = (type) => joi_1.default.when(`as_array`, {
@@ -410,25 +411,25 @@ const alter = (field, relative, data) => {
 exports.alter = alter;
 const recursive_schema = async (field, data, options) => {
     try {
-        let newField = lodash_1.default.cloneDeep(field);
-        if (newField.altered_by?.length > 0) {
-            newField = (0, exports.alter)(newField, options.relative, data);
+        let alteredField = lodash_1.default.cloneDeep(field);
+        if (alteredField.altered_by?.length > 0) {
+            alteredField = (0, exports.alter)(alteredField, options.relative, data);
             if (options.alter) {
-                delete newField.altered_by;
+                delete alteredField.altered_by;
             }
-            if (typeof newField.show === `boolean` && !newField.show) {
+            if (typeof alteredField.show === `boolean` && !alteredField.show) {
                 return;
             }
         }
         const relativeKey = options.relative ?
             options.relative.endsWith(`]`) ?
-                options.array ? options.relative : `${options.relative}.${newField.key}`
-                : `${options.relative}.${newField.key}`
-            : newField.key;
-        const value = lodash_1.default.get(data, relativeKey, newField.default);
-        const resolved = context_1.default.resolve(newField, value, options.context);
+                options.array ? options.relative : `${options.relative}.${alteredField.key}`
+                : `${options.relative}.${alteredField.key}`
+            : alteredField.key;
+        const value = lodash_1.default.get(data, relativeKey, alteredField.default);
+        const resolved = context_1.default.resolve(alteredField, value, options.context);
         if (!options.no_undefined || typeof resolved !== `undefined`) {
-            if (newField.type === `any` && typeof resolved === `undefined`) {
+            if (alteredField.type === `any` && typeof resolved === `undefined`) {
                 lodash_1.default.set(data, relativeKey, null);
             }
             else {
@@ -439,8 +440,8 @@ const recursive_schema = async (field, data, options) => {
             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`]);
+        if (alteredField.as_array) {
+            const noArrayField = lodash_1.default.omit(alteredField, [`as_array`, `array_min`, `array_max`, `array_length`]);
             if (resolved) {
                 const itemSchemas = [];
                 if (lodash_1.default.isArray(resolved)) {
@@ -453,7 +454,7 @@ const recursive_schema = async (field, data, options) => {
                     const withoutUndefined = resolved.filter((r) => typeof r !== `undefined`);
                     lodash_1.default.set(data, relativeKey, withoutUndefined);
                 }
-                calculatedSchema = getOrderedArrayFieldSchema(newField, itemSchemas);
+                calculatedSchema = getOrderedArrayFieldSchema(alteredField, itemSchemas);
             }
             else {
                 let genericItemSchema;
@@ -471,36 +472,35 @@ const recursive_schema = async (field, data, options) => {
                 else {
                     genericItemSchema = getSimpleFieldSchema(noArrayField);
                 }
-                calculatedSchema = getItemsArrayFieldSchema(newField, [genericItemSchema]);
+                calculatedSchema = getItemsArrayFieldSchema(alteredField, [genericItemSchema]);
             }
         }
-        else if (newField.type === `dict` && newField.items) {
-            if (resolved || newField.required) {
+        else if (alteredField.type === `dict` && alteredField.items) {
+            if (resolved || alteredField.required) {
                 const items = [];
-                for (const item of newField.items) {
+                for (const item of alteredField.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(alteredField, items);
+                alteredField.items = items.map((i) => i.field);
             }
             else {
-                delete newField.items;
-                calculatedSchema = getSimpleFieldSchema(newField);
+                calculatedSchema = getSimpleFieldSchema(lodash_1.default.omit(alteredField, [`items`]));
             }
         }
         else {
-            calculatedSchema = getSimpleFieldSchema(newField);
+            calculatedSchema = getSimpleFieldSchema(alteredField);
         }
         if (!calculatedSchema) {
-            throw new Error(`Could not resolve schema for field ${newField.key}`);
+            throw new Error(`Could not resolve schema for field ${alteredField.key}`);
         }
-        if (newField.disabled) {
+        if (alteredField.disabled) {
             lodash_1.default.unset(data, relativeKey);
         }
-        return { schema: calculatedSchema, field: newField };
+        return { schema: calculatedSchema, field: alteredField };
     }
     catch (e) {
         throw e;

package/package.json

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

package/src/minified-utils/fields.ts

@@ -160,7 +160,9 @@ export type SelectFieldChoice<Values = string | number | boolean | File, Extend
   key: string,
   value: Values,
   group?: string,
-} & Extend;
+}
+  & Record<`experimental_${string}`, any>
+  & Extend;
 
 /* custom display configuration */
 export type CustomDisplayTextField = {

package/src/minified-utils/validation.ts

@@ -50,8 +50,11 @@ const commonFieldSchema = () =>
       then: Joi.number(),
       otherwise: Joi.forbidden(),
     }),
-  }).concat(Joi.object() // experimental properties for custom front features
-    .pattern(Joi.string().regex(/^experimental_/), Joi.any()));
+  }).concat(
+    // experimental properties for custom front features
+    Joi.object()
+      .pattern(Joi.string().regex(/^experimental_/), Joi.any())
+  );
 
 const types = [`any`, `string`, `number`, `boolean`, `date`, `datetime`, `time`, `dict`, `file`];
 
@@ -69,7 +72,11 @@ const choiceSchema = (type: Joi.Schema) =>
     key: Joi.string().required(),
     value: type.required(),
     group: Joi.string(),
-  }).unknown();
+  }).concat(
+    // experimental properties for custom front features
+    Joi.object()
+      .pattern(Joi.string().regex(/^experimental_/), Joi.any())
+  ).unknown();
 
 const choicesSchema = (type: Joi.Schema) =>
   Joi.alternatives(
@@ -459,30 +466,30 @@ export const alter = (field: Field, relative: string, data: Record<string, any>)
 
 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);
+    let alteredField: Field = _.cloneDeep(field);
 
     // alterations over already resolved data (previous fields)
-    if (newField.altered_by?.length > 0) {
-      newField = alter(newField, options.relative, data);
+    if (alteredField.altered_by?.length > 0) {
+      alteredField = alter(alteredField, options.relative, data);
 
       // remove altered_by only if it's not an array -> array alterations must be kept for front-end rendering
-      if (options.alter) { delete newField.altered_by; }
+      if (options.alter) { delete alteredField.altered_by; }
 
-      if (typeof newField.show === `boolean` && !newField.show) { return; }
+      if (typeof alteredField.show === `boolean` && !alteredField.show) { return; }
     }
 
     const relativeKey = options.relative ?
       options.relative.endsWith(`]`) ?
-        options.array ? options.relative : `${options.relative}.${newField.key}`
-        : `${options.relative}.${newField.key}`
-      : newField.key;
+        options.array ? options.relative : `${options.relative}.${alteredField.key}`
+        : `${options.relative}.${alteredField.key}`
+      : alteredField.key;
 
-    const value = _.get(data, relativeKey, newField.default);
+    const value = _.get(data, relativeKey, alteredField.default);
 
     // resolve value with context (even if it's not valid)
-    const resolved = context.resolve(newField, value, options.context);
+    const resolved = context.resolve(alteredField, value, options.context);
     if (!options.no_undefined || typeof resolved !== `undefined`) {
-      if (newField.type === `any` && typeof resolved === `undefined`) {
+      if (alteredField.type === `any` && typeof resolved === `undefined`) {
         // any field - allow_nullish
         _.set(data, relativeKey, null);
       } else {
@@ -495,8 +502,8 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
 
     // get schema for field with data
     let calculatedSchema: Joi.Schema;
-    if (newField.as_array) {
-      const noArrayField = _.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]) as Field;
+    if (alteredField.as_array) {
+      const noArrayField = _.omit(alteredField, [`as_array`, `array_min`, `array_max`, `array_length`]) as Field;
 
       if (resolved) {
         const itemSchemas: Joi.Schema[] = [];
@@ -511,7 +518,7 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
           _.set(data, relativeKey, withoutUndefined);
         }
 
-        calculatedSchema = getOrderedArrayFieldSchema(newField, itemSchemas);
+        calculatedSchema = getOrderedArrayFieldSchema(alteredField, itemSchemas);
       } else {
         let genericItemSchema: Joi.Schema;
         if (noArrayField.type === `dict` && noArrayField.items) {
@@ -528,33 +535,33 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
           genericItemSchema = getSimpleFieldSchema(noArrayField);
         }
 
-        calculatedSchema = getItemsArrayFieldSchema(newField, [genericItemSchema]);
+        calculatedSchema = getItemsArrayFieldSchema(alteredField, [genericItemSchema]);
       }
-    } else if (newField.type === `dict` && newField.items) {
-      if (resolved || newField.required) {
+    } else if (alteredField.type === `dict` && alteredField.items) {
+      if (resolved || alteredField.required) {
         const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
 
-        for (const item of newField.items) {
+        for (const item of alteredField.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(alteredField, items);
+        alteredField.items = items.map((i) => i.field);
       } else {
-        delete newField.items;
-        calculatedSchema = getSimpleFieldSchema(newField);
+        // omit items to avoid simple field error
+        calculatedSchema = getSimpleFieldSchema(_.omit(alteredField, [`items`]) as Field);
       }
     } else {
-      calculatedSchema = getSimpleFieldSchema(newField);
+      calculatedSchema = getSimpleFieldSchema(alteredField);
     }
 
-    if (!calculatedSchema) { throw new Error(`Could not resolve schema for field ${newField.key}`); }
+    if (!calculatedSchema) { throw new Error(`Could not resolve schema for field ${alteredField.key}`); }
 
     // if disabled schema validation is done but the value is not set
-    if (newField.disabled) { _.unset(data, relativeKey); }
+    if (alteredField.disabled) { _.unset(data, relativeKey); }
 
-    return { schema: calculatedSchema, field: newField };
+    return { schema: calculatedSchema, field: alteredField };
   } catch (e) { throw e; }
 };