@beseif-solutions/prow-core 0.0.38 → 0.1.0

package/dist/entities/events.d.ts

@@ -26,8 +26,11 @@ type EventConfig = Pick<CoreConfig, `credentials` | `outputs`> & {
         outputs: string[];
     };
     sources?: string[];
+    fields?: Record<string, any>;
 };
-type CommonEvents<Config extends EventConfig = {}> = Common<Config> & {
+type CommonEvents<Config extends EventConfig = {
+    fields: Record<string, any>;
+}> = Common<Config> & {
     model: `event`;
     categorization: {
         department: string;
@@ -49,7 +52,9 @@ export type Request = {
     query: Record<string, string>;
     body: any;
 };
-export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+export type ImmediateTrigger<Config extends EventConfig = {
+    fields: Record<string, any>;
+}> = CommonEvents<Config> & {
     type: `trigger`;
     immediate: true;
     outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>];
@@ -57,7 +62,7 @@ export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         mount?: CoreFunction<{
             credentials: Config[`credentials`];
             inputs: {
-                fields: Record<string, any>;
+                fields: Config[`fields`];
                 link: string;
             };
             outputs: {
@@ -68,7 +73,7 @@ export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         unmount?: CoreFunction<{
             credentials: Config[`credentials`];
             inputs: {
-                fields: Record<string, any>;
+                fields: Config[`fields`];
                 link: string;
                 setup?: any;
             };
@@ -79,7 +84,7 @@ export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         challenge?: CoreFunction<{
             credentials: Config[`credentials`];
             inputs: {
-                fields: Record<string, any>;
+                fields: Config[`fields`];
                 link: string;
                 request: Request;
                 setup?: any;
@@ -92,7 +97,7 @@ export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         handle: CoreFunction<{
             credentials: Config[`credentials`];
             inputs: {
-                fields: Record<string, any>;
+                fields: Config[`fields`];
                 request: Request;
                 setup?: any;
             };
@@ -104,7 +109,7 @@ export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         fire?: CoreFunction<{
             credentials: Config[`credentials`];
             inputs: {
-                fields: Record<string, any>;
+                fields: Config[`fields`];
                 link: string;
                 setup?: any;
             };
@@ -115,7 +120,7 @@ export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         poll?: CoreFunction<{
             credentials: Config[`credentials`];
             inputs: {
-                fields: Record<string, any>;
+                fields: Config[`fields`];
                 last_schedule?: string;
                 limit?: number;
             };
@@ -126,7 +131,9 @@ export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         }>;
     };
 };
-export type ScheduledTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+export type ScheduledTrigger<Config extends EventConfig = {
+    fields: Record<string, any>;
+}> = CommonEvents<Config> & {
     type: `trigger`;
     immediate: false;
     outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>];
@@ -134,7 +141,7 @@ export type ScheduledTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         poll: CoreFunction<{
             credentials: Config[`credentials`];
             inputs: {
-                fields: Record<string, any>;
+                fields: Config[`fields`];
                 last_schedule?: string;
                 limit?: number;
             };
@@ -145,8 +152,12 @@ export type ScheduledTrigger<Config extends EventConfig = {}> = CommonEvents<Con
         }>;
     };
 };
-export type Trigger<Config extends EventConfig = {}> = ImmediateTrigger<Config> | ScheduledTrigger<Config>;
-export type Action<Config extends EventConfig = {}> = CommonEvents<Config> & {
+export type Trigger<Config extends EventConfig = {
+    fields: Record<string, any>;
+}> = ImmediateTrigger<Config> | ScheduledTrigger<Config>;
+export type Action<Config extends EventConfig = {
+    fields: Record<string, any>;
+}> = CommonEvents<Config> & {
     type: `action`;
     inputs: [DefaultConnectableEvent<Config[`flags`][`inputs`][number]>, ...AdditionalConnectableEvent<Config[`flags`][`inputs`][number]>[]];
     outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>, ...(AdditionalConnectableEvent<Config[`flags`][`outputs`][number]> | ErrorConnectableEvent<Config[`flags`][`outputs`][number]>)[]];
@@ -154,7 +165,7 @@ export type Action<Config extends EventConfig = {}> = CommonEvents<Config> & {
         execute: CoreFunction<{
             credentials: Config[`credentials`];
             inputs: {
-                fields: Record<string, any>;
+                fields: Config[`fields`];
                 flags: Partial<Record<Config[`flags`][`inputs`][number], true>>;
             };
             outputs: {
@@ -164,7 +175,9 @@ export type Action<Config extends EventConfig = {}> = CommonEvents<Config> & {
         }>;
     };
 };
-export type Event<Config extends EventConfig = {}> = Action<Config> | Trigger<Config>;
+export type Event<Config extends EventConfig = {
+    fields: Record<string, any>;
+}> = Action<Config> | Trigger<Config>;
 export declare const scheduledTriggerSchema: () => Joi.ObjectSchema<any>;
 export declare const immediateTriggerSchema: () => Joi.ObjectSchema<any>;
 export declare const triggerSchema: () => Joi.AlternativesSchema<any>;

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { Credentials, credentialsSchema, OAuthCredentials, oauthCredentialsSchem
 export { Action, actionOutputSchema, actionSchema, Event, eventSchema, ImmediateTrigger, immediateTriggerSchema, Request, ScheduledTrigger, scheduledTriggerSchema, Trigger, triggerOutputSchema, triggerSchema } from './entities/events';
 export { Provider, providerSchema } from './entities/provider';
 export { Source } from './entities/source';
-export { extract, Field, fieldSchema, fieldsSchema, File, SelectFieldChoice, validate, ValidationResult } from './minified-utils/fields';
+export { alter, extract, Field, fieldSchema, fieldsSchema, File, SelectFieldChoice, validate, ValidationResult } from './minified-utils/fields';
 export { i18n, LocalizedField, LocalizedProperties, localizeFields, localizeGroup, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';
 export { Properties } from './minified-utils/properties';
 export { Protocol } from './minified-utils/protocol';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Protocol = exports.Properties = exports.localizeProperties = exports.localizeOutputs = exports.localizeInputs = exports.localizeGroup = exports.localizeFields = exports.i18n = exports.validate = exports.fieldsSchema = exports.fieldSchema = exports.extract = exports.providerSchema = exports.triggerSchema = exports.triggerOutputSchema = exports.scheduledTriggerSchema = exports.immediateTriggerSchema = exports.eventSchema = exports.actionSchema = exports.actionOutputSchema = exports.staticCredentialsSchema = exports.sessionCredentialsSchema = exports.oauthCredentialsSchema = exports.credentialsSchema = exports.idSchema = exports.core = void 0;
+exports.Protocol = exports.Properties = exports.localizeProperties = exports.localizeOutputs = exports.localizeInputs = exports.localizeGroup = exports.localizeFields = exports.i18n = exports.validate = exports.fieldsSchema = exports.fieldSchema = exports.extract = exports.alter = exports.providerSchema = exports.triggerSchema = exports.triggerOutputSchema = exports.scheduledTriggerSchema = exports.immediateTriggerSchema = exports.eventSchema = exports.actionSchema = exports.actionOutputSchema = exports.staticCredentialsSchema = exports.sessionCredentialsSchema = exports.oauthCredentialsSchema = exports.credentialsSchema = exports.idSchema = exports.core = void 0;
 var core_1 = require("./core");
 Object.defineProperty(exports, "core", { enumerable: true, get: function () { return core_1.core; } });
 var commons_1 = require("./entities/commons");
@@ -21,6 +21,7 @@ Object.defineProperty(exports, "triggerSchema", { enumerable: true, get: functio
 var provider_1 = require("./entities/provider");
 Object.defineProperty(exports, "providerSchema", { enumerable: true, get: function () { return provider_1.providerSchema; } });
 var fields_1 = require("./minified-utils/fields");
+Object.defineProperty(exports, "alter", { enumerable: true, get: function () { return fields_1.alter; } });
 Object.defineProperty(exports, "extract", { enumerable: true, get: function () { return fields_1.extract; } });
 Object.defineProperty(exports, "fieldSchema", { enumerable: true, get: function () { return fields_1.fieldSchema; } });
 Object.defineProperty(exports, "fieldsSchema", { enumerable: true, get: function () { return fields_1.fieldsSchema; } });

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.d.ts

@@ -1,18 +1,16 @@
 import Joi from "joi";
-import { OneOf } from "./types";
 import { Where } from "./where";
 export type Condition = {
     condition: Where;
-} & OneOf<{
     overrides: Partial<Field>;
-    show: boolean;
-}>;
+};
 type Common = {
     key: string;
     altered_by?: Condition[];
     disabled?: boolean;
     required?: boolean;
     as_password?: boolean;
+    show?: boolean;
     show_label?: boolean;
 } & ({
     as_array?: false;
@@ -30,6 +28,7 @@ type Any = string | number | boolean | Any[] | {
 type AnyInputField<Extend = Record<never, never>> = {
     type: `any`;
     default?: Any | Any[];
+    allow_nullish?: boolean;
 } & (SelectField<Any, Extend> | {});
 type StringInputField<Extend = Record<never, never>> = {
     type: `string`;
@@ -127,6 +126,7 @@ export type ValidationResult<Extended = Record<string, never>> = {
     valid: boolean;
     fields: Field<Extended & ValidationExtended>[];
 };
+export declare const alter: (field: Field, relative: string, data: Record<string, any>) => Field<Record<never, never>>;
 export declare const validate: <I>(fields: Field<I>[], data: Record<string, any>, options?: {
     secure?: boolean;
     break?: boolean;

package/dist/minified-utils/fields.js

@@ -3,23 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract = exports.validate = exports.fieldsSchema = exports.fieldSchema = void 0;
+exports.extract = exports.validate = exports.alter = exports.fieldsSchema = exports.fieldSchema = void 0;
 const joi_1 = __importDefault(require("joi"));
 const lodash_1 = __importDefault(require("lodash"));
 const moment_timezone_1 = __importDefault(require("moment-timezone"));
 const context_1 = __importDefault(require("./context"));
 const where_1 = require("./where");
 const conditionSchema = () => joi_1.default.object({
-    condition: joi_1.default.object(),
-    overrides: joi_1.default.object(),
-    show: joi_1.default.bool(),
-}).xor(`overrides`, `show`);
+    condition: joi_1.default.object().required(),
+    overrides: joi_1.default.object().required(),
+});
 const commonFieldSchema = () => joi_1.default.object({
     key: joi_1.default.string().required(),
     altered_by: joi_1.default.array().items(conditionSchema()),
     disabled: joi_1.default.bool(),
     required: joi_1.default.bool(),
     as_password: joi_1.default.bool(),
+    show: joi_1.default.bool(),
     show_label: joi_1.default.bool().default(true),
     as_array: joi_1.default.bool(),
     array_min: joi_1.default.when(`as_array`, {
@@ -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`, `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,11 +227,17 @@ 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`:
             typeSchema = anySchema();
+            if (field.allow_nullish) {
+                typeSchema = typeSchema.allow(null, ``, 0, undefined);
+            }
             break;
         case `boolean`:
             typeSchema = joi_1.default.bool();
@@ -285,37 +314,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,77 +332,162 @@ 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);
     }
-    return field.required ? typeSchema.required() : typeSchema;
+    if (field.array_min) {
+        schema = schema.min(field.array_min);
+    }
+    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,
+        }));
+    }
+    if (field.unknown) {
+        schema = schema.unknown(field.unknown);
+    }
+    return getGeneralSchema(field, schema);
+};
+const getGeneralSchema = (field, schema) => {
+    if (field.required) {
+        schema = schema.required();
+    }
+    if (field.disabled) {
+        schema = schema.forbidden();
     }
     return 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 alter = (field, relative, data) => {
+    const cloned = lodash_1.default.cloneDeep(field);
+    for (const alteration of cloned.altered_by) {
+        const condition = relative_condition(alteration.condition, relative);
+        const matches = (0, where_1.where)(data, [condition]);
+        if (matches) {
+            lodash_1.default.assign(cloned, alteration.overrides);
+        }
+    }
+    return cloned;
+};
+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);
+            if (options.alter) {
+                delete newField.altered_by;
+            }
+        }
+        const alteredField = lodash_1.default.cloneDeep(newField);
+        if (newField.type === `file`) {
+            newField = fileReplacer(newField);
+        }
+        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 { schema: itemSchema } = await recursive_schema(lodash_1.default.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]), data, { alter: false, 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 items = [];
+            if (lodash_1.default.isObject(resolved)) {
+                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 });
+                    }
                 }
             }
-            const value = lodash_1.default.get(clonedData, field.key, field.default);
-            const resolved = context_1.default.resolve(value, options.context);
-            const schema = getFieldSchema(field);
+            calculatedSchema = getObjectFieldSchema(newField, items);
+            newField.items = items.map((i) => i.field);
+        }
+        else {
+            calculatedSchema = getSimpleFieldSchema(newField);
+        }
+        if (!calculatedSchema) {
+            throw new Error(`Could not resolve schema for field ${newField.key}`);
+        }
+        if (typeof newField.show === `boolean` && !newField.show) {
+            lodash_1.default.unset(data, relativeKey);
+            return;
+        }
+        else if (newField.disabled) {
+            lodash_1.default.unset(data, relativeKey);
+        }
+        return { schema: calculatedSchema, field: field.type === `file` ? alteredField : newField };
+    }
+    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 recursive = await recursive_schema(field, cloned, { alter: true, context: options.context });
+            if (!recursive) {
+                continue;
+            }
+            const resolved = lodash_1.default.get(cloned, field.key, field.default);
             let validation;
             let error;
             try {
-                validation = await schema.validateAsync(resolved, { abortEarly: false });
+                validation = await recursive.schema.validateAsync(resolved, { abortEarly: false });
             }
             catch (e) {
                 error = e;
@@ -422,10 +512,9 @@ 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,
+                ...recursive.field,
                 ...options.secure ? await secure(field, extended) : extended,
             });
         }

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.1.0",
   "description": "Prow core functionalities and classes",
   "main": "dist/index.js",
   "scripts": {

package/src/entities/events.ts

@@ -33,9 +33,10 @@ type EventConfig = Pick<CoreConfig, `credentials` | `outputs`> & {
     outputs: string[],
   },
   sources?: string[],
+  fields?: Record<string, any>,
 };
 
-type CommonEvents<Config extends EventConfig = {}> = Common<Config> & {
+type CommonEvents<Config extends EventConfig = { fields: Record<string, any> }> = Common<Config> & {
   model: `event`,
   categorization: {
     department: string,
@@ -59,75 +60,75 @@ export type Request = {
   body: any,
 };
 
-export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+export type ImmediateTrigger<Config extends EventConfig = { fields: Record<string, any> }> = CommonEvents<Config> & {
   type: `trigger`,
   immediate: true,
   outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>],
   functions: {
     mount?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, link: string },
+      inputs: { fields: Config[`fields`], link: string },
       outputs: { done: boolean, setup?: any },
     }>,
     unmount?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, link: string, setup?: any },
+      inputs: { fields: Config[`fields`], link: string, setup?: any },
       outputs: { done: boolean },
     }>,
     challenge?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, link: string, request: Request, setup?: any },
+      inputs: { fields: Config[`fields`], link: string, request: Request, setup?: any },
       outputs: { done: boolean, response?: any },
     }>,
     handle: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, request: Request, setup?: any },
+      inputs: { fields: Config[`fields`], request: Request, setup?: any },
       outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
     }>,
     fire?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, link: string, setup?: any },
+      inputs: { fields: Config[`fields`], link: string, setup?: any },
       outputs: { done: boolean },
     }>,
     poll?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, last_schedule?: string, limit?: number },
+      inputs: { fields: Config[`fields`], last_schedule?: string, limit?: number },
       outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
     }>,
   },
 };
 
-export type ScheduledTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+export type ScheduledTrigger<Config extends EventConfig = { fields: Record<string, any> }> = CommonEvents<Config> & {
   type: `trigger`,
   immediate: false,
   outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>],
   functions: {
     poll: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, last_schedule?: string, limit?: number },
+      inputs: { fields: Config[`fields`], last_schedule?: string, limit?: number },
       outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
     }>,
   },
 };
 
-export type Trigger<Config extends EventConfig = {}> =
+export type Trigger<Config extends EventConfig = { fields: Record<string, any> }> =
   | ImmediateTrigger<Config>
   | ScheduledTrigger<Config>;
 
-export type Action<Config extends EventConfig = {}> = CommonEvents<Config> & {
+export type Action<Config extends EventConfig = { fields: Record<string, any> }> = CommonEvents<Config> & {
   type: `action`,
   inputs: [DefaultConnectableEvent<Config[`flags`][`inputs`][number]>, ...AdditionalConnectableEvent<Config[`flags`][`inputs`][number]>[]],
   outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>, ...(AdditionalConnectableEvent<Config[`flags`][`outputs`][number]> | ErrorConnectableEvent<Config[`flags`][`outputs`][number]>)[]],
   functions: {
     execute: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, flags: Partial<Record<Config[`flags`][`inputs`][number], true>> },
+      inputs: { fields: Config[`fields`], flags: Partial<Record<Config[`flags`][`inputs`][number], true>> },
       outputs: { output: Config[`outputs`], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
     }>,
   },
 };
 
-export type Event<Config extends EventConfig = {}> =
+export type Event<Config extends EventConfig = { fields: Record<string, any> }> =
   | Action<Config>
   | Trigger<Config>;
 

package/src/index.ts

@@ -4,7 +4,7 @@ export { Credentials, credentialsSchema, OAuthCredentials, oauthCredentialsSchem
 export { Action, actionOutputSchema, actionSchema, Event, eventSchema, ImmediateTrigger, immediateTriggerSchema, Request, ScheduledTrigger, scheduledTriggerSchema, Trigger, triggerOutputSchema, triggerSchema } from './entities/events';
 export { Provider, providerSchema } from './entities/provider';
 export { Source } from './entities/source';
-export { extract, Field, fieldSchema, fieldsSchema, File, SelectFieldChoice, validate, ValidationResult } from './minified-utils/fields';
+export { alter, extract, Field, fieldSchema, fieldsSchema, File, SelectFieldChoice, validate, ValidationResult } from './minified-utils/fields';
 export { i18n, LocalizedField, LocalizedProperties, localizeFields, localizeGroup, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';
 export { Properties } from './minified-utils/properties';
 export { Protocol } from './minified-utils/protocol';

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

@@ -2,15 +2,12 @@ import Joi, { DateSchema, NumberSchema, StringSchema } from "joi";
 import _ from "lodash";
 import moment from "moment-timezone";
 import context from "./context";
-import { OneOf } from "./types";
 import { where, Where } from "./where";
 
 export type Condition = {
   condition: Where,
-} & OneOf<{
   overrides: Partial<Field>,
-  show: boolean,
-}>;
+};
 
 type Common = {
   key: string,
@@ -18,6 +15,7 @@ type Common = {
   disabled?: boolean,
   required?: boolean,
   as_password?: boolean,
+  show?: boolean,
   show_label?: boolean,
 } & ({
   as_array?: false,
@@ -47,6 +45,7 @@ type Any = string | number | boolean | Any[] | { [key: string]: Any };
 type AnyInputField<Extend = Record<never, never>> = {
   type: `any`,
   default?: Any | Any[],
+  allow_nullish?: boolean, // allow null values
 } & (
     | SelectField<Any, Extend>
     | {}
@@ -181,10 +180,9 @@ type ValidationExtended = {
 
 const conditionSchema = () =>
   Joi.object({
-    condition: Joi.object(),
-    overrides: Joi.object(),
-    show: Joi.bool(),
-  }).xor(`overrides`, `show`);
+    condition: Joi.object().required(),
+    overrides: Joi.object().required(),
+  });
 
 const commonFieldSchema = () =>
   Joi.object({
@@ -193,6 +191,7 @@ const commonFieldSchema = () =>
     disabled: Joi.bool(),
     required: Joi.bool(),
     as_password: Joi.bool(),
+    show: Joi.bool(),
     show_label: Joi.bool().default(true),
     as_array: Joi.bool(),
     array_min: Joi.when(`as_array`, {
@@ -363,6 +362,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`, `show_label`, `as_array`, `array_min`, `array_max`, `array_length`]),
+}) as Field;
+
 const fileInputFieldSchema = () =>
   Joi.object({
     default: defaultSchema(fileSchema()),
@@ -425,11 +449,15 @@ 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`:
       typeSchema = anySchema();
+      // allow null values for any type
+      if (field.allow_nullish) { typeSchema = typeSchema.allow(null, ``, 0, undefined); }
       break;
     case `boolean`:
       typeSchema = Joi.bool();
@@ -486,43 +514,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,41 +532,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,
+    }));
   }
 
+  if (field.unknown) { schema = schema.unknown(field.unknown); }
+
+  return getGeneralSchema(field, schema);
+};
+
+const getGeneralSchema = (field: Field, schema: Joi.Schema): Joi.Schema => {
+  if (field.required) { schema = schema.required(); }
+  if (field.disabled) { schema = schema.forbidden(); }
   return schema;
 };
 
@@ -585,45 +580,125 @@ 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; }
+};
+
+export const alter = (field: Field, relative: string, data: Record<string, any>) => {
+  const cloned = _.cloneDeep(field);
+  for (const alteration of cloned.altered_by) {
+    const condition = relative_condition(alteration.condition, relative);
+
+    const matches = where(data, [condition]);
+    if (matches) { _.assign(cloned, alteration.overrides); }
+  }
+  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 }> => {
+  try {
+    let newField: Field = _.cloneDeep(field);
+
+    // alterations over already resolved data (previous fields)
+    if (newField.altered_by?.length > 0) {
+      newField = alter(newField, options.relative, data);
 
-    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;
-            }
-          }
+      // 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; }
+    }
+
+    const alteredField: Field = _.cloneDeep(newField);
+
+    // ÑAPA: if the field is a file, replace it
+    if (newField.type === `file`) { newField = fileReplacer(newField); }
+
+    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 { schema: itemSchema } = await recursive_schema(
+            _.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]) as Field,
+            data, { alter: false, relative: `${relativeKey}[${i}]`, array: true, context: options.context });
+          if (itemSchema) { itemSchemas.push(itemSchema); }
         }
+      }
 
-        delete field.altered_by;
+      calculatedSchema = getArrayFieldSchema(newField, itemSchemas);
+    } else if (newField.type === `dict` && newField.items) {
+      const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
 
-        if (hide) { continue; }
+      if (_.isObject(resolved)) {
+        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 }); }
+        }
       }
 
-      const value = _.get(clonedData, field.key, field.default);
+      calculatedSchema = getObjectFieldSchema(newField, items);
+      newField.items = items.map((i) => i.field);
+    } else {
+      calculatedSchema = getSimpleFieldSchema(newField);
+    }
+
+    if (!calculatedSchema) { throw new Error(`Could not resolve schema for field ${newField.key}`); }
+
+    if (typeof newField.show === `boolean` && !newField.show) {
+      // if the field is hidden, we don't need to validate it
+      _.unset(data, relativeKey);
+      return;
+    } else if (newField.disabled) {
+      // TODO: check this
+      _.unset(data, relativeKey);
+    }
+
+    return { schema: calculatedSchema, field: field.type === `file` ? alteredField : newField };
+  } 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 recursive = await recursive_schema(field, cloned, { alter: true, context: options.context });
+      if (!recursive) { continue; }
 
-      // 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 {
-        validation = await schema.validateAsync(resolved, { abortEarly: false });
+        validation = await recursive.schema.validateAsync(resolved, { abortEarly: false });
       } catch (e) { error = e; }
 
       let extended: ValidationExtended;
@@ -646,10 +721,9 @@ 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,
+        ...recursive.field as any,
         ...options.secure ? await secure(field, extended) : extended,
       });
 

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; }

package/tsconfig.json

@@ -11,10 +11,9 @@
     "declaration": true
   },
   "include": [
-    "src/**/*.ts",
+    "src/**/*.ts"
   ],
   "exclude": [
-    "./test",
     "node_modules",
     "dist/**/*.js"
   ]