@beseif-solutions/prow-core 1.0.0 → 1.0.2

package/src/minified-utils/fields.ts

@@ -1,15 +1,11 @@
-import Joi, { DateSchema, NumberSchema, StringSchema } from "joi";
-import _ from "lodash";
-import moment from "moment-timezone";
-import context from "./context";
-import { where, Where } from "./where";
+import { Where } from "./where";
 
 export type Condition = {
   condition: Where,
   overrides: Partial<Field>,
 };
 
-type Common = {
+export type CommonField = {
   key: string,
   altered_by?: Condition[],
   disabled?: boolean,
@@ -29,9 +25,9 @@ type Common = {
   & Record<`experimental_${string}`, any>
   ;
 
-export type Field<Extend = Record<never, never>> = Common & InputField<Extend>;
+export type Field<Extend = Record<never, never>> = CommonField & InputField<Extend>;
 
-type InputField<Extend = Record<never, never>> = (
+export type InputField<Extend = Record<never, never>> = (
   | AnyInputField<Extend>
   | StringInputField<Extend>
   | NumberInputField<Extend>
@@ -43,9 +39,9 @@ type InputField<Extend = Record<never, never>> = (
   | FileInputField<Extend>
 ) & Extend;
 
-type Any = string | number | boolean | Any[] | { [key: string]: Any };
+export type Any = string | number | boolean | Any[] | { [key: string]: Any };
 
-type AnyInputField<Extend = Record<never, never>> = {
+export type AnyInputField<Extend = Record<never, never>> = {
   type: `any`,
   default?: Any | Any[],
   allow_nullish?: boolean, // allow null values
@@ -54,7 +50,7 @@ type AnyInputField<Extend = Record<never, never>> = {
     | {}
   );
 
-type StringInputField<Extend = Record<never, never>> = {
+export type StringInputField<Extend = Record<never, never>> = {
   type: `string`,
   default?: string | string[],
   length?: number,
@@ -70,7 +66,7 @@ type StringInputField<Extend = Record<never, never>> = {
     | {}
   );
 
-type NumberInputField<Extend = Record<never, never>> = {
+export type NumberInputField<Extend = Record<never, never>> = {
   type: `number`,
   default?: number | number[],
   min?: number,
@@ -83,7 +79,7 @@ type NumberInputField<Extend = Record<never, never>> = {
     | {}
   );
 
-type BooleanInputField<Extend = Record<never, never>> = {
+export type BooleanInputField<Extend = Record<never, never>> = {
   type: `boolean`,
   default?: boolean | boolean[],
 } & (
@@ -93,7 +89,7 @@ type BooleanInputField<Extend = Record<never, never>> = {
     | {}
   );
 
-type DateTimeInputField<Extend = Record<never, never>> = {
+export type DateTimeInputField<Extend = Record<never, never>> = {
   type: `datetime`,
   timezone?: string,
   default?: string | number | (string | number)[],
@@ -104,7 +100,7 @@ type DateTimeInputField<Extend = Record<never, never>> = {
     | {}
   );
 
-type DateInputField<Extend = Record<never, never>> = {
+export type DateInputField<Extend = Record<never, never>> = {
   type: `date`,
   default?: string | string[],
   min?: string,
@@ -114,7 +110,7 @@ type DateInputField<Extend = Record<never, never>> = {
     | {}
   );
 
-type TimeInputField<Extend = Record<never, never>> = {
+export type TimeInputField<Extend = Record<never, never>> = {
   type: `time`,
   timezone?: string,
   default?: string | string[],
@@ -123,7 +119,7 @@ type TimeInputField<Extend = Record<never, never>> = {
     | {}
   );
 
-type DictInputField<Extend = Record<never, never>> = {
+export type DictInputField<Extend = Record<never, never>> = {
   type: `dict`,
   default?: Record<string, any> | Record<string, any>[],
   items?: Field<Extend>[],
@@ -136,7 +132,7 @@ export type File = {
   content: string, // base64 encoded content
 };
 
-type FileInputField<Extend = Record<never, never>> = {
+export type FileInputField<Extend = Record<never, never>> = {
   type: `file`,
   default?: File | File[],
   accept?: string | string[], // mime type
@@ -146,7 +142,7 @@ type FileInputField<Extend = Record<never, never>> = {
   );
 
 /* select configuration */
-type SelectField<Values = string | number | boolean | File, Extend = Record<never, never>> = {
+export type SelectField<Values = string | number | boolean | File, Extend = Record<never, never>> = {
   format: `select`,
   // el type string representa el nombre de una función del repositorio que devuelve SelectFieldChoice[]
   choices: SelectFieldChoice<Values, Extend>[] | string,
@@ -160,658 +156,11 @@ export type SelectFieldChoice<Values = string | number | boolean | File, Extend
 } & Extend;
 
 /* custom display configuration */
-type CustomDisplayTextField = {
+export type CustomDisplayTextField = {
   format: `textarea` | `rich-text` | `markdown`,
 };
 
-type IDETextField = {
+export type IDETextField = {
   format: `code`,
   language?: string, // language for code highlighting
-};
-
-type ValidationExtended = {
-  original: any,
-  value: any,
-} & ({
-  valid: true,
-} | {
-  valid: false,
-  errors: {
-    path: string,
-    message: string,
-    type: string,
-  }[],
-});
-
-const conditionSchema = () =>
-  Joi.object({
-    condition: Joi.object().required(),
-    overrides: Joi.object().required(),
-  });
-
-const commonFieldSchema = () =>
-  Joi.object({
-    key: Joi.string().required(),
-    altered_by: Joi.array().items(conditionSchema()),
-    disabled: Joi.bool(),
-    required: Joi.bool(),
-    as_password: Joi.bool(),
-    show: Joi.bool(),
-    t: Joi.string(),
-    as_array: Joi.bool(),
-    array_min: Joi.when(`as_array`, {
-      is: true,
-      then: Joi.number(),
-      otherwise: Joi.forbidden(),
-    }),
-    array_max: Joi.when(`as_array`, {
-      is: true,
-      then: Joi.number(),
-      otherwise: Joi.forbidden(),
-    }),
-    array_length: Joi.when(`as_array`, {
-      is: true,
-      then: Joi.number(),
-      otherwise: Joi.forbidden(),
-    }),
-  }).concat(Joi.object() // experimental properties for custom front features
-    .pattern(Joi.string().regex(/^experimental_/), Joi.any()));
-
-const types = [`any`, `string`, `number`, `boolean`, `date`, `datetime`, `time`, `dict`, `file`];
-
-const inputFieldBaseSchema = () =>
-  Joi.object({
-    type: Joi.string().required()
-      .valid(...types),
-    // switch by type properties
-  })
-    .concat(commonFieldSchema())
-    .unknown();
-
-const choiceSchema = (type: Joi.Schema) =>
-  Joi.object({
-    key: Joi.string().required(),
-    value: type.required(),
-    group: Joi.string(),
-  }).unknown();
-
-const choicesSchema = (type: Joi.Schema) =>
-  Joi.alternatives(
-    Joi.string(),
-    Joi.array().min(1)
-      .items(choiceSchema(type))
-  );
-
-const defaultSchema = (type: Joi.Schema) =>
-  Joi.when(`as_array`, {
-    is: true,
-    then: Joi.array().items(type),
-    otherwise: type,
-  });
-
-const anySchema = (nullish = true) => {
-  // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-  const randId = Math.random().toString(36).substring(2, 15);
-  return Joi.alternatives(
-    Joi.string(),
-    Joi.bool(),
-    Joi.number(),
-    Joi.array().items(Joi.link(`#${randId}`)),
-    Joi.object().pattern(Joi.string(), Joi.link(`#${randId}`)),
-    ...nullish ? [Joi.valid(null, ``)] : [],
-  )
-    .id(randId);
-};
-
-const anyInputFieldSchema = () =>
-  Joi.object({
-    default: defaultSchema(anySchema()),
-    allow_nullish: Joi.bool().default(true),
-  })
-    .concat(Joi.object({
-      format: Joi.string().valid(`select`),
-      choices: Joi.when(`format`, {
-        is: `select`,
-        then: choicesSchema(anySchema()).required(),
-        otherwise: Joi.forbidden(),
-      }),
-    }));
-
-const stringInputFieldSchema = () =>
-  Joi.object({
-    default: defaultSchema(Joi.string()),
-    length: Joi.number(),
-    min: Joi.number(),
-    max: Joi.number(),
-    regexp: Joi.string(),
-    pattern: Joi.string().valid(`email`, `uri`),
-    allow_empty: Joi.bool().default(false),
-  })
-    .concat(
-      Joi.object({
-        format: Joi.string().valid(`select`, `textarea`, `rich-text`, `markdown`, `code`),
-        choices: Joi.when(`format`, {
-          is: `select`,
-          then: choicesSchema(Joi.string()).required(),
-          otherwise: Joi.forbidden(),
-        }),
-        language: Joi.when(`format`, {
-          is: `code`,
-          then: Joi.string(),
-          otherwise: Joi.forbidden(),
-        }),
-      })
-    );
-
-const numberInputFieldSchema = () =>
-  Joi.object({
-    default: defaultSchema(Joi.number()),
-    min: Joi.number(),
-    max: Joi.number(),
-    float: Joi.bool(),
-    decimals: Joi.when(`float`, {
-      is: true,
-      then: Joi.number(),
-      otherwise: Joi.forbidden(),
-    }),
-  })
-    .concat(Joi.object({
-      format: Joi.string().valid(`select`),
-      choices: Joi.when(`format`, {
-        is: `select`,
-        then: choicesSchema(Joi.number()).required(),
-        otherwise: Joi.forbidden(),
-      }),
-    }));
-
-const booleanInputFieldSchema = () =>
-  Joi.object({
-    default: defaultSchema(Joi.bool()),
-  })
-    .concat(Joi.object({
-      format: Joi.string().valid(`select`, `checkbox`, `switch`),
-      choices: Joi.when(`format`, {
-        is: `select`,
-        then: choicesSchema(Joi.bool()).required(),
-        otherwise: Joi.forbidden(),
-      }),
-    }));
-
-const dateInputFieldSchema = () =>
-  Joi.object({
-    default: defaultSchema(Joi.alternatives(Joi.string(), Joi.number())),
-    min: Joi.alternatives(Joi.string(), Joi.number()),
-    max: Joi.alternatives(Joi.string(), Joi.number()),
-  })
-    .concat(Joi.object({
-      format: Joi.string().valid(`select`),
-      choices: Joi.when(`format`, {
-        is: `select`,
-        then: choicesSchema(Joi.alternatives(Joi.string(), Joi.number())).required(),
-        otherwise: Joi.forbidden(),
-      }),
-    }));
-
-const timeInputFieldSchema = () =>
-  Joi.object({
-    default: defaultSchema(Joi.alternatives(Joi.string(), Joi.number())),
-  })
-    .concat(Joi.object({
-      format: Joi.string().valid(`select`),
-      choices: Joi.when(`format`, {
-        is: `select`,
-        then: choicesSchema(Joi.alternatives(Joi.string(), Joi.number())).required(),
-        otherwise: Joi.forbidden(),
-      }),
-    }));
-
-const dictInputFieldSchema = () =>
-  Joi.object({
-    default: defaultSchema(Joi.object()),
-    items: Joi.array().items(Joi.link(`#field`)).min(1),
-    unknown: Joi.when(`items`, {
-      is: Joi.exist(),
-      then: Joi.bool(),
-      otherwise: Joi.forbidden(),
-    }),
-  });
-
-const fileSchema = () => Joi.object({
-  name: Joi.string().required(),
-  type: Joi.string().required(), // mime type
-  content: Joi.string().required(), // base64 encoded content
-});
-
-// ÑAPA: translate file to structured dict
-const fileReplacer = (field: Common & FileInputField): Field => ({
-  key: field.key,
-  type: `dict`,
-  unknown: true,
-  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`, `as_array`, `array_min`, `array_max`, `array_length`]),
-  ...Object.assign({}, ...Object.entries(field).map(([k, v]) => k.startsWith(`experimental_`) ? { [k]: v } : {})),
-}) as Field;
-
-const fileInputFieldSchema = () =>
-  Joi.object({
-    default: defaultSchema(fileSchema()),
-    accept: Joi.alternatives(
-      Joi.string(),
-      Joi.array().items(Joi.string())
-    ).optional(),
-  })
-    .concat(
-      Joi.object({
-        format: Joi.string().valid(`select`),
-        choices: Joi.when(`format`, {
-          is: `select`,
-          then: choicesSchema(fileSchema()).required(),
-          otherwise: Joi.forbidden(),
-        }),
-      })
-    );
-
-export const fieldSchema = () =>
-  inputFieldBaseSchema()
-    .id(`field`)
-    .when(Joi.object({ type: Joi.valid(`any`) }).unknown(), {
-      then: inputFieldBaseSchema()
-        .concat(anyInputFieldSchema()),
-    })
-    .when(Joi.object({ type: Joi.valid(`string`) }).unknown(), {
-      then: inputFieldBaseSchema()
-        .concat(stringInputFieldSchema()),
-    })
-    .when(Joi.object({ type: Joi.valid(`number`) }).unknown(), {
-      then: inputFieldBaseSchema()
-        .concat(numberInputFieldSchema()),
-    })
-    .when(Joi.object({ type: Joi.valid(`boolean`) }).unknown(), {
-      then: inputFieldBaseSchema()
-        .concat(booleanInputFieldSchema()),
-    })
-    .when(Joi.object({ type: Joi.valid(`date`, `datetime`) }).unknown(), {
-      then: inputFieldBaseSchema()
-        .concat(dateInputFieldSchema()),
-    })
-    .when(Joi.object({ type: Joi.valid(`time`) }).unknown(), {
-      then: inputFieldBaseSchema()
-        .concat(timeInputFieldSchema()),
-    })
-    .when(Joi.object({ type: Joi.valid(`dict`) }).unknown(), {
-      then: inputFieldBaseSchema()
-        .concat(dictInputFieldSchema()),
-    })
-    .when(Joi.object({ type: Joi.valid(`file`) }).unknown(), {
-      then: inputFieldBaseSchema()
-        .concat(fileInputFieldSchema()),
-    })
-    // invalid fallback
-    .when(Joi.object({ type: Joi.invalid(...types) }).unknown(), {
-      then: Joi.forbidden(),
-    });
-
-export const fieldsSchema = () =>
-  Joi.array().items(fieldSchema());
-
-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(field.allow_nullish);
-      break;
-    case `boolean`:
-      typeSchema = Joi.bool();
-      break;
-    case `string`:
-      typeSchema = Joi.string();
-      if (field.length) { typeSchema = (typeSchema as StringSchema).length(field.length); }
-      if (field.min > 0) {
-        typeSchema = (typeSchema as StringSchema).min(field.min);
-      } else if (field.allow_empty) {
-        typeSchema = typeSchema.allow(``);
-      }
-      if (field.max) { typeSchema = (typeSchema as StringSchema).max(field.max); }
-      if (field.regexp) { typeSchema = (typeSchema as StringSchema).regex(new RegExp(field.regexp)); }
-      if (field.pattern === `email`) { typeSchema = (typeSchema as StringSchema).email(); }
-      if (field.pattern === `uri`) { typeSchema = (typeSchema as StringSchema).uri(); }
-
-      break;
-    case `date`:
-    case `datetime`:
-    case `time`:
-      if (field.type === `time`) {
-        typeSchema = Joi.string();
-      } else {
-        typeSchema = Joi.date().strict(false);
-        if (field.min) { typeSchema = (typeSchema as DateSchema).min(field.min); }
-        if (field.max) { typeSchema = (typeSchema as DateSchema).max(field.max); }
-      }
-
-      typeSchema = typeSchema.external(async (value, helpers) => {
-        if (!helpers.original && !field.required) { return helpers.original; }
-
-        const format = field.type === `date` ? `YYYY-MM-DD` :
-          field.type === `time` ? `HH:mmZ` :
-            `YYYY-MM-DDTHH:mm:ssZ`;
-        const d = (field.type === `datetime` && typeof helpers.original === `number`) ?
-          moment.unix(helpers.original).tz(`UTC`)
-          : moment.tz(helpers.original, format, `UTC`);
-        if (!d.isValid()) { return helpers.message({ external: `invalid format, expected ${format}` }); }
-
-        const timezone = (field.type === `date` ? `UTC` : field.timezone) || `UTC`;
-        return d.tz(timezone).format(format);
-      });
-
-      break;
-    case `number`:
-      typeSchema = Joi.number();
-      if (field.min) { typeSchema = (typeSchema as NumberSchema).min(field.min); }
-      if (field.max) { typeSchema = (typeSchema as NumberSchema).max(field.max); }
-      // don't check precision if float is not set
-      if (typeof field.float === `boolean`) {
-        if (!field.float) {
-          typeSchema = (typeSchema as NumberSchema).precision(0);
-        } else if (field.decimals) {
-          typeSchema = (typeSchema as NumberSchema).precision(field.decimals);
-        }
-      }
-
-      break;
-    case `dict`:
-      if (field.items) { throw new Error(`No simple field`); }
-      typeSchema = Joi.object().unknown(true);
-      break;
-    case `file`:
-      typeSchema = fileSchema();
-      break;
-  }
-
-  if (`format` in field && field.format === `select`) {
-    if (!field.unknown) {
-      if (_.isArray(field.choices)) {
-        typeSchema = typeSchema.valid(...field.choices.map((c: SelectFieldChoice) => c.value));
-      } else {
-        // async select values are not checked
-      }
-    }
-  }
-
-  return getGeneralSchema(field, typeSchema);
-};
-
-const getGeneralArraySchema = (field: Field, schema: Joi.ArraySchema) => {
-  if (!field.as_array) { throw new Error(`as_array required for array schema generator`); }
-
-  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 getGeneralSchema(field, schema);
-};
-
-const getItemsArrayFieldSchema = (field: Field, alternatives: Joi.Schema[]) => {
-  if (!field.as_array) { throw new Error(`as_array required for array schema generator`); }
-
-  const schema = Joi.array().items(...alternatives);
-  return getGeneralArraySchema(field, schema);
-};
-
-const getOrderedArrayFieldSchema = (field: Field, items: Joi.Schema[]) => {
-  if (!field.as_array) { throw new Error(`as_array required for array schema generator`); }
-
-  const schema = Joi.array().ordered(...items);
-  return getGeneralArraySchema(field, schema);
-};
-
-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`); }
-
-  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;
-};
-
-const convertPath = (parts: (string | number)[]): string =>
-  parts.map((p, i) => typeof p === `string` ? (i === 0 ? p : `.${p}`) : `[${p}]`).join(``);
-
-const secure = async (field: Field, validation: ValidationExtended): Promise<ValidationExtended> =>
-  field.as_password ? _.omit(validation, [`value`, `original`]) as any : validation;
-
-export type ValidationResult<Extended = Record<string, never>> = {
-  valid: boolean,
-  fields: Field<Extended & ValidationExtended>[],
-};
-
-const relative_condition = (condition: Where, relative: string): typeof condition => {
-  try {
-    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);
-
-      // 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 (typeof newField.show === `boolean` && !newField.show) { return; }
-    }
-
-    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 - omit undefined)
-    const resolved = context.resolve(newField, value, options.context);
-    if (typeof resolved !== `undefined`) { _.set(data, relativeKey, resolved); }
-
-    // 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 (resolved) {
-        const itemSchemas: Joi.Schema[] = [];
-        if (_.isArray(resolved)) {
-          for (let i = 0; i < (resolved || []).length; i++) {
-            const { schema: itemSchema } = await recursive_schema(noArrayField, data, { alter: false, relative: `${relativeKey}[${i}]`, array: true, context: options.context });
-            if (itemSchema) { itemSchemas.push(itemSchema); }
-          }
-        }
-
-        calculatedSchema = getOrderedArrayFieldSchema(newField, itemSchemas);
-      } else {
-        let genericItemSchema: Joi.Schema;
-        if (noArrayField.type === `dict` && noArrayField.items) {
-          const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
-
-          for (const item of noArrayField.items) {
-            const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context });
-            if (recursive) { items.push({ key: item.key, schema: recursive.schema, field: recursive.field }); }
-          }
-
-          genericItemSchema = getObjectFieldSchema(noArrayField, items);
-          noArrayField.items = items.map((i) => i.field);
-        } else {
-          genericItemSchema = getSimpleFieldSchema(noArrayField);
-        }
-
-        calculatedSchema = getItemsArrayFieldSchema(newField, [genericItemSchema]);
-      }
-    } else if (newField.type === `dict` && newField.items) {
-      const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
-
-      for (const item of newField.items) {
-        const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: relativeKey, context: options.context });
-        if (recursive) { items.push({ key: item.key, schema: recursive.schema, field: recursive.field }); }
-      }
-
-      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 disabled schema validation is done but the value is not set
-    if (newField.disabled) { _.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; }
-
-      const resolved = _.get(cloned, field.key, field.default);
-
-      let validation: any;
-      let error: any;
-      try {
-        validation = await recursive.schema.validateAsync(resolved, { abortEarly: false });
-      } catch (e) { error = e; }
-
-      let extended: ValidationExtended;
-      if (error) {
-        extended = {
-          valid: false,
-          errors: error.details ? error.details.map((d) => ({
-            type: d.type,
-            path: convertPath([field.key, ...d.path]),
-            message: d.message,
-          })) : [
-            {
-              type: `unknown`,
-              path: field.key,
-              message: error.message,
-            },
-          ],
-          original: value,
-          value: null,
-        };
-      } else {
-        _.set(data, field.key, validation);
-        extended = {
-          valid: true,
-          original: value,
-          value: validation,
-        };
-      }
-
-      response.valid &&= error ? false : true;
-      response.fields.push({
-        ...recursive.field as any,
-        ...options.secure ? await secure(field, extended) : extended,
-      });
-
-    }
-
-    return response;
-  } catch (e) { throw e; }
-};
-
-export const validate = async <I>(fields: Field<I>[], data: Record<string, any>, options: { secure?: boolean, break?: boolean, context?: Record<string, any> } = {}): Promise<ValidationResult<I>> => {
-  try {
-    const { error } = fieldsSchema().validate(fields);
-    if (error) { throw new Error(`Invalid fields definition: ${error.message}`); }
-    const defaultOptions = _.assign({ secure: true, break: false, context: {} }, options);
-    const response = await validate_internal(fields, data, defaultOptions);
-    return response as any;
-  } catch (e) { throw e; }
-};
-
-const extract_recursive = async (validation: Field<ValidationExtended>[], options: { original?: boolean }, path = ``): Promise<Record<string, any>> => {
-  try {
-    const response = {};
-    for (const field of validation) {
-      const key = _.compact([path, field.key]).join(`.`);
-      _.set(response, key, options.original ? field.original : field.value);
-    }
-    return response;
-  } catch (e) { throw e; }
-};
-
-export const extract = async (validation: Field<ValidationExtended>[], options: { original?: boolean } = {}): Promise<Record<string, any>> => {
-  try {
-    return await extract_recursive(validation, options);
-  } catch (e) { throw e; }
 };