@beseif-solutions/prow-core 0.0.38 → 0.0.39

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

@@ -1,6 +1,6 @@
+import { Field } from "./fields";
 declare class Context {
-    constructor();
-    readonly resolve: (source: any, data: Record<string, any>) => any;
+    readonly resolve: (field: Field, source: any, data: Record<string, any>) => any;
 }
 declare const context: Context;
 export default context;

package/dist/minified-utils/context.js

@@ -7,14 +7,14 @@ const handlebars_1 = __importDefault(require("handlebars"));
 const lodash_1 = __importDefault(require("lodash"));
 class Context {
     constructor() {
-        this.resolve = (source, data) => {
-            let isObject = false;
-            let unresolved;
+        this.resolve = (field, source, data) => {
             if (lodash_1.default.isNull(source) || lodash_1.default.isUndefined(source)) {
                 return source;
             }
-            if (lodash_1.default.isObject(source) || lodash_1.default.isArray(source)) {
-                isObject = true;
+            let serialized = false;
+            let unresolved;
+            if ((lodash_1.default.isObject(source) || lodash_1.default.isArray(source)) && field.type === `dict` && !field.items) {
+                serialized = true;
                 unresolved = JSON.stringify(source);
             }
             else if (typeof source === `string`) {
@@ -26,50 +26,43 @@ class Context {
             if (!unresolved || !unresolved.includes(`{{`)) {
                 return source;
             }
-            const template = handlebars_1.default.compile(unresolved);
-            const resolved = template(data);
-            if (resolved.includes(`[object Object]`)) {
-                const clonedData = lodash_1.default.cloneDeep(data);
-                const parsed = handlebars_1.default.parseWithoutProcessing(unresolved);
-                for (const x of parsed.body) {
-                    if (x.type === `MustacheStatement`) {
-                        const get = lodash_1.default.get(clonedData, x[`path`].original);
-                        if (lodash_1.default.isObject(get) || lodash_1.default.isArray(get)) {
-                            if (isObject) {
-                                unresolved = unresolved.replace(`"{{${x[`path`].original}}}"`, JSON.stringify(get));
-                            }
-                            else {
-                                lodash_1.default.set(clonedData, `${x[`path`].original}.toString`, () => JSON.stringify(get));
-                                if (x[`escaped`]) {
-                                    unresolved = unresolved.replace(`{{${x[`path`].original}}}`, `{{{${x[`path`].original}}}}`);
-                                }
+            const clonedData = lodash_1.default.cloneDeep(data);
+            let resolved = unresolved;
+            const process = handlebars_1.default.parseWithoutProcessing(unresolved);
+            for (const x of process.body) {
+                if (x.type === `MustacheStatement`) {
+                    const path = x[`path`].original;
+                    const expression = x[`escaped`] ? `{{${path}}}` : `{{{${path}}}}`;
+                    const get = lodash_1.default.get(clonedData, path);
+                    if (get) {
+                        const shouldInfer = field.as_array && lodash_1.default.isArray(get)
+                            || field.type === `dict` && lodash_1.default.isObject(get)
+                            || field.type === `file` && lodash_1.default.isObject(get)
+                            || field.type === `number` && typeof get === `number`
+                            || field.type === `string` && typeof get === `string`
+                            || field.type === `boolean` && typeof get === `boolean`
+                            || field.type === `any`;
+                        if (unresolved === expression && shouldInfer) {
+                            resolved = get;
+                            break;
+                        }
+                        else {
+                            if (serialized) {
+                                resolved = resolved.replace(`"${expression}"`, lodash_1.default.isObject(get) ? JSON.stringify(get) : `"${get}"`);
                             }
+                            resolved = resolved.replace(expression, get);
                         }
                     }
+                    else {
+                        resolved = resolved.replace(expression, ``);
+                    }
                 }
-                return this.resolve(isObject ? JSON.parse(unresolved) : unresolved, clonedData);
             }
-            return isObject ? JSON.parse(resolved) : resolved;
+            const parsed = serialized ? JSON.parse(resolved) : resolved;
+            return (typeof resolved === `string` ? resolved : JSON.stringify(resolved)).includes(`{{`) ?
+                this.resolve(field, parsed, clonedData)
+                : parsed;
         };
-        handlebars_1.default.registerHelper({
-            eq: (v1, v2) => v1 === v2,
-            ne: (v1, v2) => v1 !== v2,
-            lt: (v1, v2) => v1 < v2,
-            gt: (v1, v2) => v1 > v2,
-            lte: (v1, v2) => v1 <= v2,
-            gte: (v1, v2) => v1 >= v2,
-            and: (v1, v2) => v1 && v2,
-            or: (v1, v2) => v1 || v2,
-            "+": (v1, v2) => v1 + v2,
-            "-": (v1, v2) => v1 - v2,
-            "*": (v1, v2) => v1 * v2,
-            "/": (v1, v2) => v1 / v2,
-            "sum": (v1, v2) => v1 + v2,
-            "subtract": (v1, v2) => v1 - v2,
-            "multiply": (v1, v2) => v1 * v2,
-            "divide": (v1, v2) => v1 / v2,
-            "abs": (v1) => Math.abs(v1),
-        });
     }
 }
 const context = new Context();

package/dist/minified-utils/fields.js

@@ -152,6 +152,29 @@ const fileSchema = () => joi_1.default.object({
     type: joi_1.default.string().required(),
     content: joi_1.default.string().required(),
 });
+const fileReplacer = (field) => ({
+    key: field.key,
+    type: `dict`,
+    items: [
+        {
+            key: `name`,
+            type: `string`,
+            required: true,
+        },
+        {
+            key: `type`,
+            type: `string`,
+            required: true,
+        },
+        {
+            key: `content`,
+            type: `string`,
+            required: true,
+        },
+    ],
+    default: field.default,
+    ...lodash_1.default.pick(field, [`altered_by`, `disabled`, `required`, `as_password`, `show_label`, `as_array`, `array_min`, `array_max`, `array_length`]),
+});
 const fileInputFieldSchema = () => joi_1.default.object({
     default: defaultSchema(fileSchema()),
     accept: joi_1.default.alternatives(joi_1.default.string(), joi_1.default.array().items(joi_1.default.string())).optional(),
@@ -204,7 +227,10 @@ const fieldSchema = () => inputFieldBaseSchema()
 exports.fieldSchema = fieldSchema;
 const fieldsSchema = () => joi_1.default.array().items((0, exports.fieldSchema)());
 exports.fieldsSchema = fieldsSchema;
-const getFieldSchema = (field) => {
+const getSimpleFieldSchema = (field) => {
+    if (field.as_array) {
+        throw new Error(`Cannot use as_array with simple field schema generator`);
+    }
     let typeSchema;
     switch (field.type) {
         case `any`:
@@ -285,37 +311,13 @@ const getFieldSchema = (field) => {
             }
             break;
         case `dict`:
-            let objSchema;
             if (field.items) {
-                objSchema = getFieldsSchema(field.items).unknown(field.unknown || false);
-            }
-            else {
-                objSchema = joi_1.default.object().unknown(true);
+                throw new Error(`No simple field`);
             }
-            typeSchema = joi_1.default.alternatives(objSchema, joi_1.default.string().external(async (value, helpers) => {
-                if (!helpers.original && !field.required) {
-                    return helpers.original;
-                }
-                const parsed = JSON.parse(value);
-                const { value: objValue, error } = objSchema.validate(parsed, { abortEarly: false });
-                if (error) {
-                    throw error;
-                }
-                return objValue;
-            }));
+            typeSchema = joi_1.default.object().unknown(true);
             break;
         case `file`:
-            typeSchema = joi_1.default.alternatives(fileSchema(), joi_1.default.string().external(async (value, helpers) => {
-                if (!helpers.original && !field.required) {
-                    return helpers.original;
-                }
-                const parsed = JSON.parse(value);
-                const { value: fileValue, error } = fileSchema().validate(parsed, { abortEarly: false });
-                if (error) {
-                    throw error;
-                }
-                return fileValue;
-            }));
+            typeSchema = fileSchema();
             break;
     }
     if (`format` in field && field.format === `select`) {
@@ -327,73 +329,142 @@ const getFieldSchema = (field) => {
             }
         }
     }
-    if (field.as_array) {
-        let arraySchema = joi_1.default.array().items(typeSchema);
-        if (field.array_length) {
-            arraySchema = arraySchema.length(field.array_length);
-        }
-        if (field.array_min) {
-            arraySchema = arraySchema.min(field.array_min);
-        }
-        if (field.array_max) {
-            arraySchema = arraySchema.max(field.array_max);
-        }
-        typeSchema = joi_1.default.alternatives(arraySchema, joi_1.default.string().external(async (value, helpers) => {
-            if (!helpers.original && !field.required) {
-                return helpers.original;
-            }
-            const parsed = JSON.parse(value);
-            const { value: arrValue, error } = arraySchema.validate(parsed, { abortEarly: false });
-            if (error) {
-                throw error;
-            }
-            return arrValue;
-        }));
+    return getGeneralSchema(field, typeSchema);
+};
+const getArrayFieldSchema = (field, items) => {
+    if (!field.as_array) {
+        throw new Error(`as_array required for array schema generator`);
     }
-    if (field.disabled) {
-        typeSchema = typeSchema.forbidden();
+    let schema = joi_1.default.array().ordered(...items);
+    if (field.array_length) {
+        schema = schema.length(field.array_length);
+    }
+    if (field.array_min) {
+        schema = schema.min(field.array_min);
     }
-    return field.required ? typeSchema.required() : typeSchema;
+    if (field.array_max) {
+        schema = schema.max(field.array_max);
+    }
+    return getGeneralSchema(field, schema);
 };
-const getFieldsSchema = (fields) => {
+const getObjectFieldSchema = (field, items) => {
+    if (field.type !== `dict`) {
+        throw new Error(`type must be dict for object schema generator`);
+    }
+    if (!field.items) {
+        throw new Error(`items required for object schema generator`);
+    }
     let schema = joi_1.default.object();
-    for (const field of fields) {
-        const fSchema = getFieldSchema(field);
-        schema = schema.concat(joi_1.default.object({ [field.key]: fSchema }));
+    for (const item of items) {
+        schema = schema.concat(joi_1.default.object({
+            [item.key]: item.schema,
+        }));
     }
-    return schema;
+    if (field.unknown) {
+        schema = schema.unknown(field.unknown);
+    }
+    return getGeneralSchema(field, schema);
+};
+const getGeneralSchema = (field, schema) => {
+    if (field.disabled) {
+        schema = schema.forbidden();
+    }
+    return field.required ? schema.required() : schema;
 };
 const convertPath = (parts) => parts.map((p, i) => typeof p === `string` ? (i === 0 ? p : `.${p}`) : `[${p}]`).join(``);
 const secure = async (field, validation) => field.as_password ? lodash_1.default.omit(validation, [`value`, `original`]) : validation;
-const validate_internal = async (fields, data, options) => {
+const relative_condition = (condition, relative) => {
     try {
-        const response = { valid: true, fields: [] };
-        const clonedData = lodash_1.default.cloneDeep(data);
-        for (const field of lodash_1.default.compact(fields)) {
-            if (options.break && !response.valid) {
-                break;
+        const newCondition = lodash_1.default.cloneDeep(condition);
+        for (const key of Object.keys(newCondition)) {
+            if (key.startsWith(`@relative`)) {
+                const newKey = key.replace(`@relative`, relative ? relative : ``);
+                newCondition[newKey] = newCondition[key];
+                delete newCondition[key];
             }
-            if (field.altered_by?.length > 0) {
-                let hide = false;
-                for (const alteration of field.altered_by) {
-                    const matches = (0, where_1.where)(clonedData, [alteration.condition]);
-                    if (matches) {
-                        if (`overrides` in alteration) {
-                            lodash_1.default.assign(field, alteration.overrides);
-                        }
-                        else if (`show` in alteration) {
-                            hide = !alteration.show;
-                        }
+        }
+        return newCondition;
+    }
+    catch (e) {
+        throw e;
+    }
+};
+const recursive_schema = async (field, data, options) => {
+    try {
+        const newField = field.type === `file` ? fileReplacer(field) : lodash_1.default.cloneDeep(field);
+        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);
+        lodash_1.default.set(data, relativeKey, resolved);
+        let calculatedSchema;
+        if (newField.as_array && resolved) {
+            const itemSchemas = [];
+            if (lodash_1.default.isArray(resolved)) {
+                for (let i = 0; i < (resolved || []).length; i++) {
+                    const itemSchema = await recursive_schema(lodash_1.default.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]), data, { relative: `${relativeKey}[${i}]`, array: true, context: options.context });
+                    if (itemSchema) {
+                        itemSchemas.push(itemSchema);
                     }
                 }
-                delete field.altered_by;
-                if (hide) {
-                    continue;
+            }
+            calculatedSchema = getArrayFieldSchema(newField, itemSchemas);
+        }
+        else if (newField.type === `dict` && newField.items) {
+            const itemSchemas = [];
+            if (lodash_1.default.isObject(resolved)) {
+                for (const item of newField.items) {
+                    const itemSchema = await recursive_schema(item, data, { relative: relativeKey, context: options.context });
+                    if (itemSchema) {
+                        itemSchemas.push({ key: item.key, schema: itemSchema });
+                    }
+                }
+            }
+            calculatedSchema = getObjectFieldSchema(newField, itemSchemas);
+        }
+        else {
+            calculatedSchema = getSimpleFieldSchema(newField);
+        }
+        if (!calculatedSchema) {
+            throw new Error(`Could not resolve schema for field ${newField.key}`);
+        }
+        if (newField.altered_by?.length > 0) {
+            let hide = false;
+            for (const alteration of newField.altered_by) {
+                const condition = relative_condition(alteration.condition, options.relative);
+                const matches = (0, where_1.where)(data, [condition]);
+                if (matches) {
+                    if (`overrides` in alteration) {
+                        lodash_1.default.assign(newField, alteration.overrides);
+                    }
+                    else if (`show` in alteration) {
+                        hide = !alteration.show;
+                    }
                 }
             }
-            const value = lodash_1.default.get(clonedData, field.key, field.default);
-            const resolved = context_1.default.resolve(value, options.context);
-            const schema = getFieldSchema(field);
+            delete newField.altered_by;
+            if (hide) {
+                lodash_1.default.unset(data, relativeKey);
+                return;
+            }
+        }
+        return calculatedSchema;
+    }
+    catch (e) {
+        throw e;
+    }
+};
+const validate_internal = async (fields, data, options) => {
+    try {
+        const response = { valid: true, fields: [] };
+        for (const field of fields) {
+            const value = lodash_1.default.get(data, field.key, field.default);
+            const cloned = lodash_1.default.cloneDeep(data);
+            const schema = await recursive_schema(field, cloned, { context: options.context });
+            const resolved = lodash_1.default.get(cloned, field.key, field.default);
             let validation;
             let error;
             try {
@@ -422,7 +493,6 @@ const validate_internal = async (fields, data, options) => {
                     value: validation,
                 };
             }
-            lodash_1.default.set(clonedData, field.key, validation);
             response.valid && (response.valid = error ? false : true);
             response.fields.push({
                 ...field,

package/dist/minified-utils/where.js

@@ -248,7 +248,7 @@ const processWhere = (json, conditions, flags) => {
                 matchesWhere && (matchesWhere = processWhere(value, [cond], flags));
             }
             else {
-                continue;
+                matchesWhere && (matchesWhere = false);
             }
             if (!matchesWhere) {
                 break;

package/package.json

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

package/src/minified-utils/context.ts

@@ -1,43 +1,16 @@
 import Handlebars from "handlebars";
 import _ from "lodash";
+import { Field } from "./fields";
 
 class Context {
 
-  constructor() {
-
-    // logic and math helpers
-    Handlebars.registerHelper({
-      eq: (v1: any, v2: any) => v1 === v2,
-      ne: (v1: any, v2: any) => v1 !== v2,
-      lt: (v1: any, v2: any) => v1 < v2,
-      gt: (v1: any, v2: any) => v1 > v2,
-      lte: (v1: any, v2: any) => v1 <= v2,
-      gte: (v1: any, v2: any) => v1 >= v2,
-      and: (v1: any, v2: any) => v1 && v2,
-      or: (v1: any, v2: any) => v1 || v2,
-      "+": (v1: number, v2: number) => v1 + v2,
-      "-": (v1: number, v2: number) => v1 - v2,
-      "*": (v1: number, v2: number) => v1 * v2,
-      "/": (v1: number, v2: number) => v1 / v2,
-      "sum": (v1: number, v2: number) => v1 + v2,
-      "subtract": (v1: number, v2: number) => v1 - v2,
-      "multiply": (v1: number, v2: number) => v1 * v2,
-      "divide": (v1: number, v2: number) => v1 / v2,
-      "abs": (v1: number) => Math.abs(v1),
-    });
-
-    // TODO: register helpers
-
-  }
-
-  public readonly resolve = (source: any, data: Record<string, any>) => {
-    let isObject = false;
-    let unresolved: string;
-
+  public readonly resolve = (field: Field, source: any, data: Record<string, any>) => {
     if (_.isNull(source) || _.isUndefined(source)) { return source; }
 
-    if (_.isObject(source) || _.isArray(source)) {
-      isObject = true;
+    let serialized = false;
+    let unresolved: string;
+    if ((_.isObject(source) || _.isArray(source)) && field.type === `dict` && !field.items) {
+      serialized = true;
       unresolved = JSON.stringify(source);
     } else if (typeof source === `string`) {
       unresolved = source;
@@ -45,32 +18,44 @@ class Context {
 
     if (!unresolved || !unresolved.includes(`{{`)) { return source; }
 
-    const template = Handlebars.compile(unresolved);
-    const resolved = template(data);
-
-    if (resolved.includes(`[object Object]`)) {
-      const clonedData = _.cloneDeep(data);
-      // overwrite toString method
-      const parsed = Handlebars.parseWithoutProcessing(unresolved);
-      for (const x of parsed.body) {
-        if (x.type === `MustacheStatement`) {
-          const get = _.get(clonedData, x[`path`].original);
-          if (_.isObject(get) || _.isArray(get)) {
-            if (isObject) {
-              unresolved = unresolved.replace(`"{{${x[`path`].original}}}"`, JSON.stringify(get));
-            } else {
-              _.set(clonedData, `${x[`path`].original}.toString`, () => JSON.stringify(get));
-              if (x[`escaped`]) { unresolved = unresolved.replace(`{{${x[`path`].original}}}`, `{{{${x[`path`].original}}}}`); }
-            }
+    const clonedData = _.cloneDeep(data);
+
+    let resolved: any = unresolved;
+    const process = Handlebars.parseWithoutProcessing(unresolved);
+    for (const x of process.body) {
+      if (x.type === `MustacheStatement`) {
+        const path = x[`path`].original;
+        const expression = x[`escaped`] ? `{{${path}}}` : `{{{${path}}}}`;
+        const get = _.get(clonedData, path);
+
+        if (get) {
+          const shouldInfer =
+            field.as_array && _.isArray(get)
+            || field.type === `dict` && _.isObject(get)
+            || field.type === `file` && _.isObject(get)
+            || field.type === `number` && typeof get === `number`
+            || field.type === `string` && typeof get === `string`
+            || field.type === `boolean` && typeof get === `boolean`
+            || field.type === `any`;
+
+          if (unresolved === expression && shouldInfer) {
+            resolved = get;
+            break;
+          } else {
+            if (serialized) { resolved = resolved.replace(`"${expression}"`, _.isObject(get) ? JSON.stringify(get) : `"${get}"`); }
+            resolved = resolved.replace(expression, get);
 
           }
-        }
+        } else { resolved = resolved.replace(expression, ``); }
       }
-
-      return this.resolve(isObject ? JSON.parse(unresolved) : unresolved, clonedData);
     }
 
-    return isObject ? JSON.parse(resolved) : resolved;
+    const parsed = serialized ? JSON.parse(resolved) : resolved;
+
+    // recursive resolution
+    return (typeof resolved === `string` ? resolved : JSON.stringify(resolved)).includes(`{{`) ?
+      this.resolve(field, parsed, clonedData)
+      : parsed;
   };
 
 }

package/src/minified-utils/fields.ts

@@ -363,6 +363,31 @@ const fileSchema = () => Joi.object({
   content: Joi.string().required(), // base64 encoded content
 });
 
+// ÑAPA: translate file to structured dict
+const fileReplacer = (field: Common & FileInputField): Field => ({
+  key: field.key,
+  type: `dict`,
+  items: [
+    {
+      key: `name`,
+      type: `string`,
+      required: true,
+    },
+    {
+      key: `type`,
+      type: `string`,
+      required: true,
+    },
+    {
+      key: `content`,
+      type: `string`,
+      required: true,
+    },
+  ],
+  default: field.default,
+  ..._.pick(field, [`altered_by`, `disabled`, `required`, `as_password`, `show_label`, `as_array`, `array_min`, `array_max`, `array_length`]),
+}) as Field;
+
 const fileInputFieldSchema = () =>
   Joi.object({
     default: defaultSchema(fileSchema()),
@@ -425,7 +450,9 @@ export const fieldSchema = () =>
 export const fieldsSchema = () =>
   Joi.array().items(fieldSchema());
 
-const getFieldSchema = (field: Field) => {
+const getSimpleFieldSchema = (field: Field) => {
+  if (field.as_array) { throw new Error(`Cannot use as_array with simple field schema generator`); }
+
   let typeSchema: Joi.Schema;
   switch (field.type) {
     case `any`:
@@ -486,43 +513,11 @@ const getFieldSchema = (field: Field) => {
       }
       break;
     case `dict`:
-      let objSchema: Joi.ObjectSchema;
-      if (field.items) {
-        objSchema = getFieldsSchema(field.items).unknown(field.unknown || false);
-      } else {
-        objSchema = Joi.object().unknown(true);
-      }
-
-      typeSchema = Joi.alternatives(
-        objSchema,
-        // support for stringified objects
-        Joi.string().external(async (value, helpers) => {
-          if (!helpers.original && !field.required) { return helpers.original; }
-
-          const parsed = JSON.parse(value);
-          const { value: objValue, error } = objSchema.validate(parsed, { abortEarly: false });
-          if (error) { throw error; }
-
-          return objValue;
-        })
-      );
-
+      if (field.items) { throw new Error(`No simple field`); }
+      typeSchema = Joi.object().unknown(true);
       break;
     case `file`:
-      typeSchema = Joi.alternatives(
-        fileSchema(),
-        // support for stringified objects
-        Joi.string().external(async (value, helpers) => {
-          if (!helpers.original && !field.required) { return helpers.original; }
-
-          const parsed = JSON.parse(value);
-          const { value: fileValue, error } = fileSchema().validate(parsed, { abortEarly: false });
-          if (error) { throw error; }
-
-          return fileValue;
-        })
-      );
-
+      typeSchema = fileSchema();
       break;
   }
 
@@ -536,42 +531,40 @@ const getFieldSchema = (field: Field) => {
     }
   }
 
-  if (field.as_array) {
-    let arraySchema = Joi.array().items(typeSchema);
-
-    if (field.array_length) { arraySchema = arraySchema.length(field.array_length); }
-    if (field.array_min) { arraySchema = arraySchema.min(field.array_min); }
-    if (field.array_max) { arraySchema = arraySchema.max(field.array_max); }
-
-    typeSchema = Joi.alternatives(
-      arraySchema,
-      // support for stringified arrays
-      Joi.string().external(async (value, helpers) => {
-        if (!helpers.original && !field.required) { return helpers.original; }
+  return getGeneralSchema(field, typeSchema);
+};
 
-        const parsed = JSON.parse(value);
-        const { value: arrValue, error } = arraySchema.validate(parsed, { abortEarly: false });
-        if (error) { throw error; }
+const getArrayFieldSchema = (field: Field, items: Joi.Schema[]) => {
+  if (!field.as_array) { throw new Error(`as_array required for array schema generator`); }
 
-        return arrValue;
-      })
-    );
-  }
+  let schema = Joi.array().ordered(...items);
 
-  if (field.disabled) { typeSchema = typeSchema.forbidden(); }
+  if (field.array_length) { schema = schema.length(field.array_length); }
+  if (field.array_min) { schema = schema.min(field.array_min); }
+  if (field.array_max) { schema = schema.max(field.array_max); }
 
-  return field.required ? typeSchema.required() : typeSchema;
+  return getGeneralSchema(field, schema);
 };
 
-const getFieldsSchema = (fields: Field[]) => {
-  let schema = Joi.object();
+const getObjectFieldSchema = (field: Field, items: { key: string, schema: Joi.Schema }[]) => {
+  if (field.type !== `dict`) { throw new Error(`type must be dict for object schema generator`); }
+  if (!field.items) { throw new Error(`items required for object schema generator`); }
 
-  for (const field of fields) {
-    const fSchema = getFieldSchema(field);
-    schema = schema.concat(Joi.object({ [field.key]: fSchema }));
+  let schema = Joi.object();
+  for (const item of items) {
+    schema = schema.concat(Joi.object({
+      [item.key]: item.schema,
+    }));
   }
 
-  return schema;
+  if (field.unknown) { schema = schema.unknown(field.unknown); }
+
+  return getGeneralSchema(field, schema);
+};
+
+const getGeneralSchema = (field: Field, schema: Joi.Schema): Joi.Schema => {
+  if (field.disabled) { schema = schema.forbidden(); }
+  return field.required ? schema.required() : schema;
 };
 
 const convertPath = (parts: (string | number)[]): string =>
@@ -585,41 +578,113 @@ export type ValidationResult<Extended = Record<string, never>> = {
   fields: Field<Extended & ValidationExtended>[],
 };
 
-const validate_internal = async (fields: Field[], data: Record<string, any>, options: { secure: boolean, break: boolean, context: Record<string, any> }): Promise<ValidationResult> => {
+const relative_condition = (condition: Where, relative: string): typeof condition => {
   try {
-    const response: ValidationResult<{}> = { valid: true, fields: [] };
+    const newCondition = _.cloneDeep(condition);
+    for (const key of Object.keys(newCondition)) {
+      if (key.startsWith(`@relative`)) {
+        const newKey = key.replace(`@relative`, relative ? relative : ``);
+        newCondition[newKey] = newCondition[key];
+        delete newCondition[key];
+      }
+    }
+
+    return newCondition;
+  } catch (e) { throw e; }
+};
+
+const recursive_schema = async (field: Field, data: Record<string, any>, options: { relative?: string, array?: boolean, context: Record<string, any> }): Promise<Joi.Schema> => {
+  try {
+    // ÑAPA: if the field is a file, replace it
+    const newField = field.type === `file` ? fileReplacer(field) : _.cloneDeep(field);
+
+    const relativeKey = options.relative ?
+      options.relative.endsWith(`]`) ?
+        options.array ? options.relative : `${options.relative}.${newField.key}`
+        : `${options.relative}.${newField.key}`
+      : newField.key;
+
+    const value = _.get(data, relativeKey, newField.default);
+
+    // resolve value with context (even if it's not valid)
+    const resolved = context.resolve(newField, value, options.context);
+    _.set(data, relativeKey, resolved);
+
+    // get schema for field with data
+    let calculatedSchema: Joi.Schema;
+    if (newField.as_array && resolved) {
+
+      const itemSchemas: Joi.Schema[] = [];
+      if (_.isArray(resolved)) {
+        for (let i = 0; i < (resolved || []).length; i++) {
+          const itemSchema = await recursive_schema(
+            _.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]) as Field,
+            data, { relative: `${relativeKey}[${i}]`, array: true, context: options.context });
+          if (itemSchema) { itemSchemas.push(itemSchema); }
+        }
+      }
+
+      calculatedSchema = getArrayFieldSchema(newField, itemSchemas);
+    } else if (newField.type === `dict` && newField.items) {
+      const itemSchemas: { key: string, schema: Joi.Schema }[] = [];
+
+      if (_.isObject(resolved)) {
+        for (const item of newField.items) {
+          const itemSchema = await recursive_schema(item, data, { relative: relativeKey, context: options.context });
+          if (itemSchema) { itemSchemas.push({ key: item.key, schema: itemSchema }); }
+        }
+      }
+
+      calculatedSchema = getObjectFieldSchema(newField, itemSchemas);
+    } else {
+      calculatedSchema = getSimpleFieldSchema(newField);
+    }
 
-    const clonedData = _.cloneDeep(data);
-
-    for (const field of _.compact(fields)) {
-      if (options.break && !response.valid) { break; }
-
-      // alterations over data
-      if (field.altered_by?.length > 0) {
-        let hide = false;
-        for (const alteration of field.altered_by) {
-          const matches = where(clonedData, [alteration.condition]);
-          if (matches) {
-            if (`overrides` in alteration) {
-              _.assign(field, alteration.overrides);
-            } else if (`show` in alteration) {
-              hide = !alteration.show;
-            }
+    if (!calculatedSchema) { throw new Error(`Could not resolve schema for field ${newField.key}`); }
+
+    // alterations over data
+    if (newField.altered_by?.length > 0) {
+      let hide = false;
+      for (const alteration of newField.altered_by) {
+        const condition = relative_condition(alteration.condition, options.relative);
+
+        const matches = where(data, [condition]);
+        if (matches) {
+          if (`overrides` in alteration) {
+            _.assign(newField, alteration.overrides);
+          } else if (`show` in alteration) {
+            hide = !alteration.show;
           }
         }
+      }
 
-        delete field.altered_by;
+      delete newField.altered_by;
 
-        if (hide) { continue; }
+      if (hide) {
+        // if the field is hidden, we don't need to validate it
+        _.unset(data, relativeKey);
+        return;
       }
+    }
+
+    return calculatedSchema;
+  } catch (e) { throw e; }
+};
+
+const validate_internal = async (fields: Field[], data: Record<string, any>, options: { secure: boolean, break: boolean, context: Record<string, any> }): Promise<ValidationResult> => {
+  try {
+    const response: ValidationResult<{}> = { valid: true, fields: [] };
+
+    for (const field of fields) {
+
+      const value = _.get(data, field.key, field.default);
+
+      const cloned = _.cloneDeep(data);
 
-      const value = _.get(clonedData, field.key, field.default);
+      const schema = await recursive_schema(field, cloned, { context: options.context });
 
-      // resolve value with context
-      const resolved = context.resolve(value, options.context);
+      const resolved = _.get(cloned, field.key, field.default);
 
-      // validate resolved value
-      const schema = getFieldSchema(field);
       let validation: any;
       let error: any;
       try {
@@ -646,7 +711,6 @@ const validate_internal = async (fields: Field[], data: Record<string, any>, opt
         };
       }
 
-      _.set(clonedData, field.key, validation);
       response.valid &&= error ? false : true;
       response.fields.push({
         ...field as any,

package/src/minified-utils/where.ts

@@ -313,8 +313,8 @@ const processWhere = (json: Record<string, any>, conditions: Where[], flags?: Fl
       } else if (isWhere(cond)) {
         matchesWhere &&= processWhere(value, [cond], flags);
       } else {
-        // TODO
-        continue;
+        // TODO: what is this case?
+        matchesWhere &&= false;
       }
 
       if (!matchesWhere) { break; }