@beseif-solutions/prow-core 1.2.0 → 1.2.2

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

@@ -7,12 +7,14 @@ import { Source } from '../entities/source';
 export type LocalizedField = {
     label: string;
     help: string;
+    instructions?: string;
     ui?: Record<string, any>;
 };
 export type LocalizedProperties = {
     name: string;
     description: string;
     help?: Record<string, string>;
+    instructions?: string;
 };
 type TOptions = {
     fallback?: boolean;

package/dist/minified-utils/locales.js

@@ -98,6 +98,7 @@ const localizeField = (t, element, field, recursive = {}) => {
     const root = field.t || recursive.t || `${element}.fields`;
     field.label = t(`${root}.${key}.label`, { fallback: true });
     field.help = t(`${root}.${key}.help`);
+    field.instructions = t(`${root}.${key}.instructions`, { fallback: true, optional: true });
     field.ui = t(`${root}.${key}.ui`, { fallback: true, optional: true }) || {};
     if (field.type === `dict` && field.items) {
         field.items = field.items.map((f) => localizeField(t, element, f, { parent: `${key}.items`, t: field.t }));
@@ -107,6 +108,7 @@ const localizeField = (t, element, field, recursive = {}) => {
             ...fc,
             label: t(`${root}.${key}.choices.${fc.key}.label`, { fallback: true }),
             help: t(`${root}.${key}.choices.${fc.key}.help`),
+            instructions: t(`${root}.${key}.choices.${fc.key}.instructions`, { fallback: true, optional: true }),
             ui: {
                 ...t(`${root}.${key}.choices.${fc.key}.ui`, { fallback: true, optional: true }) || {},
                 ...fc.group && {
@@ -131,10 +133,12 @@ const localizeFields = (t, element) => {
 exports.localizeFields = localizeFields;
 const localizeProperties = (t, element) => {
     const help = t(`${element.id}.help`, { fallback: true, optional: true });
+    const instructions = t(`${element.id}.instructions`, { fallback: true, optional: true });
     return {
         name: t(`${element.id}.name`, { fallback: true }),
         description: t(`${element.id}.description`),
         ...help && { help: help },
+        ...instructions && { instructions: instructions },
     };
 };
 exports.localizeProperties = localizeProperties;

package/dist/minified-utils/validation.js

@@ -410,25 +410,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 +439,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 +453,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 +471,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.0",
+  "version": "1.2.2",
   "description": "Prow core functionalities and classes",
   "main": "dist/index.js",
   "scripts": {

package/src/minified-utils/locales.ts

@@ -11,6 +11,7 @@ import { Source } from '../entities/source';
 export type LocalizedField = {
   label: string,
   help: string,
+  instructions?: string,
   ui?: Record<string, any>,
 };
 
@@ -18,6 +19,7 @@ export type LocalizedProperties = {
   name: string,
   description: string,
   help?: Record<string, string>,
+  instructions?: string,
 };
 
 type TOptions = { fallback?: boolean, optional?: boolean };
@@ -143,6 +145,7 @@ const localizeField = (
 
   field.label = t(`${root}.${key}.label`, { fallback: true });
   field.help = t(`${root}.${key}.help`);
+  field.instructions = t(`${root}.${key}.instructions`, { fallback: true, optional: true });
   field.ui = t(`${root}.${key}.ui`, { fallback: true, optional: true }) || {};
 
   if (field.type === `dict` && field.items) {
@@ -152,6 +155,7 @@ const localizeField = (
       ...fc,
       label: t(`${root}.${key}.choices.${fc.key}.label`, { fallback: true }),
       help: t(`${root}.${key}.choices.${fc.key}.help`),
+      instructions: t(`${root}.${key}.choices.${fc.key}.instructions`, { fallback: true, optional: true }),
       ui: {
         ...t(`${root}.${key}.choices.${fc.key}.ui`, { fallback: true, optional: true }) || {},
         ...fc.group && {
@@ -184,10 +188,12 @@ export const localizeProperties = (
   element: Action | Trigger | Credentials | Provider | Source,
 ): LocalizedProperties => {
   const help = t<Record<string, any>>(`${element.id}.help`, { fallback: true, optional: true });
+  const instructions = t<string>(`${element.id}.instructions`, { fallback: true, optional: true });
   return {
     name: t(`${element.id}.name`, { fallback: true }),
     description: t(`${element.id}.description`),
     ...help && { help: help },
+    ...instructions && { instructions: instructions },
   };
 };
 

package/src/minified-utils/validation.ts

@@ -459,30 +459,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 +495,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 +511,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 +528,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; }
 };