@beseif-solutions/prow-core 1.1.0 → 1.2.1

package/dist/core.d.ts

@@ -4,7 +4,7 @@ import lodash from "lodash";
 import moment from "moment-timezone";
 import { FromCatalog, FromDirectory, T } from "./minified-utils/locales";
 import { SourceConfig } from "./entities/source";
-import { File } from "./minified-utils/fields";
+import { File, RawFile } from "./minified-utils/fields";
 export type SourceFunctions = {
     register: <SC extends SourceConfig = SourceConfig>(source: SC[`id`], sandbox: boolean, data: SC[`fields`]) => Promise<{
         id: string;
@@ -16,8 +16,8 @@ export type SourceFunctions = {
     unregister: <SC extends SourceConfig = SourceConfig>(source: SC[`id`], sandbox: boolean, id: string) => Promise<void>;
 };
 export type StorageFunctions = {
-    read: (id: string) => Promise<string>;
-    store: (file: File) => Promise<File>;
+    read: (file: File) => Promise<RawFile>;
+    store: (file: RawFile) => Promise<File>;
 };
 export type Core = {
     axios: AxiosInstance;

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { Action, actionOutputSchema, actionSchema, AsyncAction, Event, eventSche
 export { Provider, providerSchema } from './entities/provider';
 export { Source } from './entities/source';
 export { getPath, hasExpression, isDynamic, isExpression, split } from './minified-utils/context';
-export { Condition, Field, File, SelectFieldChoice } from './minified-utils/fields';
+export { Condition, Field, File, RawFile, SelectFieldChoice } from './minified-utils/fields';
 export { DEFAULT_LOCALE, i18n, LocalizedField, LocalizedProperties, localizeFields, localizeGroup, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';
 export { Properties } from './minified-utils/properties';
 export { alter, extract, fieldSchema, fieldsSchema, validate, ValidationOptions, ValidationResult } from './minified-utils/validation';

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

@@ -82,14 +82,19 @@ export type DictInputField<Extend = Record<never, never>> = {
     items?: Field<Extend>[];
     unknown?: boolean;
 };
-export type File = {
+export type RawFile = {
     name: string;
     type: string;
     content: string;
 };
+export type File = {
+    name: string;
+    type: string;
+    id: string;
+};
 export type FileInputField<Extend = Record<never, never>> = {
     type: `file`;
-    default?: File | File[];
+    default?: never;
     accept?: string | string[];
 } & (SelectField<File, Extend> | {});
 export type SelectField<Values = string | number | boolean | File, Extend = Record<never, never>> = {

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

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

package/dist/minified-utils/locales.js

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

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

@@ -1,6 +1,5 @@
 import Joi from "joi";
 import { Field } from "./fields";
-import { StorageFunctions } from "../core";
 type ValidationExtended = {
     original: any;
     value: any;
@@ -17,7 +16,6 @@ type ValidationExtended = {
 export declare const fieldSchema: () => Joi.ObjectSchema<any>;
 export declare const fieldsSchema: () => Joi.ArraySchema<any[]>;
 export type ValidationOptions = {
-    files: StorageFunctions;
     secure?: boolean;
     break?: boolean;
     context?: Record<string, any>;

package/dist/minified-utils/validation.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extract = exports.validate = exports.alter = exports.fieldsSchema = exports.fieldSchema = void 0;
-const axios_1 = __importDefault(require("axios"));
 const joi_1 = __importDefault(require("joi"));
 const lodash_1 = __importDefault(require("lodash"));
 const moment_timezone_1 = __importDefault(require("moment-timezone"));
@@ -164,10 +163,9 @@ const dictInputFieldSchema = () => joi_1.default.object({
 const fileSchema = () => joi_1.default.object({
     name: joi_1.default.string().required(),
     type: joi_1.default.string().required(),
-    content: joi_1.default.string().required(),
+    id: joi_1.default.string().required(),
 });
 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(),
 })
     .concat(joi_1.default.object({
@@ -218,7 +216,7 @@ const fieldSchema = () => inputFieldBaseSchema()
 exports.fieldSchema = fieldSchema;
 const fieldsSchema = () => joi_1.default.array().items((0, exports.fieldSchema)());
 exports.fieldsSchema = fieldsSchema;
-const getSimpleFieldSchema = (field, configuration) => {
+const getSimpleFieldSchema = (field) => {
     if (field.as_array) {
         throw new Error(`Cannot use as_array with simple field schema generator`);
     }
@@ -310,26 +308,7 @@ const getSimpleFieldSchema = (field, configuration) => {
             typeSchema = joi_1.default.object().unknown(true);
             break;
         case `file`:
-            typeSchema = fileSchema()
-                .external(async (value) => {
-                if (value.content.startsWith(`http://`) || value.content.startsWith(`https://`)) {
-                    try {
-                        const { data: content } = await axios_1.default.get(value.content, { responseType: `arraybuffer` });
-                        value.content = Buffer.from(content).toString(`base64`);
-                    }
-                    catch (e) {
-                        console.log(e);
-                        throw new Error(`Could not fetch file from URL`);
-                    }
-                }
-                else if (value.content.startsWith(`id:`)) {
-                    const id = value.content.replace(`id:`, ``);
-                    value.content = await configuration.files.read(id);
-                }
-                else {
-                }
-                return value;
-            });
+            typeSchema = fileSchema();
             break;
     }
     if (`format` in field && field.format === `select`) {
@@ -441,7 +420,6 @@ const recursive_schema = async (field, data, options) => {
                 return;
             }
         }
-        const alteredField = lodash_1.default.cloneDeep(newField);
         const relativeKey = options.relative ?
             options.relative.endsWith(`]`) ?
                 options.array ? options.relative : `${options.relative}.${newField.key}`
@@ -467,7 +445,7 @@ const recursive_schema = async (field, data, options) => {
                 const itemSchemas = [];
                 if (lodash_1.default.isArray(resolved)) {
                     for (let i = 0; i < (resolved || []).length; i++) {
-                        const { schema: itemSchema } = await recursive_schema(noArrayField, data, { files: options.files, alter: false, relative: `${relativeKey}[${i}]`, array: true, context: options.context });
+                        const { schema: itemSchema } = await recursive_schema(noArrayField, data, { alter: false, relative: `${relativeKey}[${i}]`, array: true, context: options.context });
                         if (itemSchema) {
                             itemSchemas.push(itemSchema);
                         }
@@ -482,7 +460,7 @@ const recursive_schema = async (field, data, options) => {
                 if (noArrayField.type === `dict` && noArrayField.items) {
                     const items = [];
                     for (const item of noArrayField.items) {
-                        const recursive = await recursive_schema(item, data, { files: options.files, alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context, no_undefined: true });
+                        const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context, no_undefined: true });
                         if (recursive) {
                             items.push({ key: item.key, schema: recursive.schema, field: recursive.field });
                         }
@@ -491,7 +469,7 @@ const recursive_schema = async (field, data, options) => {
                     noArrayField.items = items.map((i) => i.field);
                 }
                 else {
-                    genericItemSchema = getSimpleFieldSchema(noArrayField, { files: options.files });
+                    genericItemSchema = getSimpleFieldSchema(noArrayField);
                 }
                 calculatedSchema = getItemsArrayFieldSchema(newField, [genericItemSchema]);
             }
@@ -500,7 +478,7 @@ const recursive_schema = async (field, data, options) => {
             if (resolved || newField.required) {
                 const items = [];
                 for (const item of newField.items) {
-                    const recursive = await recursive_schema(item, data, { files: options.files, alter: options.alter && true, relative: relativeKey, context: options.context });
+                    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 });
                     }
@@ -510,11 +488,11 @@ const recursive_schema = async (field, data, options) => {
             }
             else {
                 delete newField.items;
-                calculatedSchema = getSimpleFieldSchema(newField, { files: options.files });
+                calculatedSchema = getSimpleFieldSchema(newField);
             }
         }
         else {
-            calculatedSchema = getSimpleFieldSchema(newField, { files: options.files });
+            calculatedSchema = getSimpleFieldSchema(newField);
         }
         if (!calculatedSchema) {
             throw new Error(`Could not resolve schema for field ${newField.key}`);
@@ -522,7 +500,7 @@ const recursive_schema = async (field, data, options) => {
         if (newField.disabled) {
             lodash_1.default.unset(data, relativeKey);
         }
-        return { schema: calculatedSchema, field: field.type === `file` ? alteredField : newField };
+        return { schema: calculatedSchema, field: newField };
     }
     catch (e) {
         throw e;
@@ -534,7 +512,7 @@ const validate_internal = async (fields, data, options) => {
         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, { files: options.files, alter: true, context: options.context });
+            const recursive = await recursive_schema(field, cloned, { alter: true, context: options.context });
             if (!recursive) {
                 continue;
             }

package/package.json

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

package/src/core.ts

@@ -4,7 +4,7 @@ import lodash from "lodash";
 import moment from "moment-timezone";
 import { FromCatalog, FromDirectory, i18n, T } from "./minified-utils/locales";
 import { SourceConfig } from "./entities/source";
-import { File } from "./minified-utils/fields";
+import { File, RawFile } from "./minified-utils/fields";
 
 export type SourceFunctions = {
   register: <SC extends SourceConfig = SourceConfig>(source: SC[`id`], sandbox: boolean, data: SC[`fields`]) => Promise<{ id: string }>,
@@ -13,8 +13,8 @@ export type SourceFunctions = {
 };
 
 export type StorageFunctions = {
-  read: (id: string) => Promise<string>,
-  store: (file: File) => Promise<File>,
+  read: (file: File) => Promise<RawFile>,
+  store: (file: RawFile) => Promise<File>,
 };
 
 const FALLBACK_SOURCES: SourceFunctions = {

package/src/index.ts

@@ -5,7 +5,7 @@ export { Action, actionOutputSchema, actionSchema, AsyncAction, Event, eventSche
 export { Provider, providerSchema } from './entities/provider';
 export { Source } from './entities/source';
 export { getPath, hasExpression, isDynamic, isExpression, split } from './minified-utils/context';
-export { Condition, Field, File, SelectFieldChoice } from './minified-utils/fields';
+export { Condition, Field, File, RawFile, SelectFieldChoice } from './minified-utils/fields';
 export { DEFAULT_LOCALE, i18n, LocalizedField, LocalizedProperties, localizeFields, localizeGroup, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';
 export { Properties } from './minified-utils/properties';
 export { alter, extract, fieldSchema, fieldsSchema, validate, ValidationOptions, ValidationResult } from './minified-utils/validation';

package/src/minified-utils/fields.ts

@@ -126,15 +126,22 @@ export type DictInputField<Extend = Record<never, never>> = {
   unknown?: boolean,
 };
 
+export type RawFile = {
+  name: string,
+  type: string,
+  content: string,
+};
+
 export type File = {
   name: string,
   type: string,
-  content: string, // base64 encoded content
+  id: string,
 };
 
+
 export type FileInputField<Extend = Record<never, never>> = {
   type: `file`,
-  default?: File | File[],
+  default?: never,
   accept?: string | string[], // mime type
 } & (
     | SelectField<File, Extend>

package/src/minified-utils/locales.ts

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

package/src/minified-utils/validation.ts

@@ -1,11 +1,9 @@
-import axios from "axios";
 import Joi, { DateSchema, NumberSchema, StringSchema } from "joi";
 import _ from "lodash";
 import moment from "moment-timezone";
 import context from "./context";
-import { Field, File, SelectFieldChoice } from "./fields";
+import { Field, SelectFieldChoice } from "./fields";
 import { where, Where } from "./where";
-import { StorageFunctions } from "../core";
 
 type ValidationExtended = {
   original: any,
@@ -217,39 +215,12 @@ const dictInputFieldSchema = () =>
 const fileSchema = () => Joi.object({
   name: Joi.string().required(),
   type: Joi.string().required(), // mime type
-  content: Joi.string().required(), // base64 encoded content
+  id: Joi.string().required(), // file id - not validated
 });
 
-// // ÑAPA: translate file to structured dict
-// const fileReplacer = (field: CommonField & 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()),
+    // default: defaultSchema(fileSchema()),
     accept: Joi.alternatives(
       Joi.string(),
       Joi.array().items(Joi.string())
@@ -309,7 +280,7 @@ export const fieldSchema = () =>
 export const fieldsSchema = () =>
   Joi.array().items(fieldSchema());
 
-const getSimpleFieldSchema = (field: Field, configuration: { files: StorageFunctions }) => {
+const getSimpleFieldSchema = (field: Field) => {
   if (field.as_array) { throw new Error(`Cannot use as_array with simple field schema generator`); }
 
   let typeSchema: Joi.Schema;
@@ -380,28 +351,7 @@ const getSimpleFieldSchema = (field: Field, configuration: { files: StorageFunct
       typeSchema = Joi.object().unknown(true);
       break;
     case `file`:
-      typeSchema = fileSchema()
-        .external(async (value: File) => {
-          if (value.content.startsWith(`http://`) || value.content.startsWith(`https://`)) {
-            try {
-              // get content from public URL
-              const { data: content } = await axios.get(value.content, { responseType: `arraybuffer` });
-              // content to base64
-              value.content = Buffer.from(content).toString(`base64`);
-            } catch (e) {
-              console.log(e);
-              throw new Error(`Could not fetch file from URL`);
-            }
-          } else if (value.content.startsWith(`id:`)) {
-            const id = value.content.replace(`id:`, ``);
-            // get content from internal storage
-            value.content = await configuration.files.read(id);
-          } else {
-            // content as base64
-          }
-
-          return value;
-        });
+      typeSchema = fileSchema();
       break;
   }
 
@@ -471,7 +421,6 @@ const secure = async (field: Field, validation: ValidationExtended): Promise<Val
   field.as_password ? _.omit(validation, [`value`, `original`]) as any : validation;
 
 export type ValidationOptions = {
-  files: StorageFunctions,
   secure?: boolean,
   break?: boolean,
   context?: Record<string, any>,
@@ -508,7 +457,7 @@ export const alter = (field: Field, relative: string, data: Record<string, any>)
   return cloned;
 };
 
-const recursive_schema = async (field: Field, data: Record<string, any>, options: { files: StorageFunctions, alter: boolean, context: Record<string, any>, relative?: string, array?: boolean, no_undefined?: boolean }): Promise<{ schema: Joi.Schema, field: Field }> => {
+const recursive_schema = async (field: Field, data: Record<string, any>, options: { alter: boolean, context: Record<string, any>, relative?: string, array?: boolean, no_undefined?: boolean }): Promise<{ schema: Joi.Schema, field: Field }> => {
   try {
     let newField: Field = _.cloneDeep(field);
 
@@ -522,11 +471,6 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
       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}`
@@ -558,7 +502,7 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
         const itemSchemas: Joi.Schema[] = [];
         if (_.isArray(resolved)) {
           for (let i = 0; i < (resolved || []).length; i++) {
-            const { schema: itemSchema } = await recursive_schema(noArrayField, data, { files: options.files, alter: false, relative: `${relativeKey}[${i}]`, array: true, context: options.context });
+            const { schema: itemSchema } = await recursive_schema(noArrayField, data, { alter: false, relative: `${relativeKey}[${i}]`, array: true, context: options.context });
             if (itemSchema) { itemSchemas.push(itemSchema); }
           }
 
@@ -574,14 +518,14 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
           const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
 
           for (const item of noArrayField.items) {
-            const recursive = await recursive_schema(item, data, { files: options.files, alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context, no_undefined: true });
+            const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: `${relativeKey}[0]`, context: options.context, no_undefined: true });
             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, { files: options.files });
+          genericItemSchema = getSimpleFieldSchema(noArrayField);
         }
 
         calculatedSchema = getItemsArrayFieldSchema(newField, [genericItemSchema]);
@@ -591,7 +535,7 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
         const items: { key: string, schema: Joi.Schema, field: Field }[] = [];
 
         for (const item of newField.items) {
-          const recursive = await recursive_schema(item, data, { files: options.files, alter: options.alter && true, relative: relativeKey, context: options.context });
+          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 }); }
         }
 
@@ -599,10 +543,10 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
         newField.items = items.map((i) => i.field);
       } else {
         delete newField.items;
-        calculatedSchema = getSimpleFieldSchema(newField, { files: options.files });
+        calculatedSchema = getSimpleFieldSchema(newField);
       }
     } else {
-      calculatedSchema = getSimpleFieldSchema(newField, { files: options.files });
+      calculatedSchema = getSimpleFieldSchema(newField);
     }
 
     if (!calculatedSchema) { throw new Error(`Could not resolve schema for field ${newField.key}`); }
@@ -610,11 +554,11 @@ const recursive_schema = async (field: Field, data: Record<string, any>, options
     // 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 };
+    return { schema: calculatedSchema, field: newField };
   } catch (e) { throw e; }
 };
 
-const validate_internal = async (fields: Field[], data: Record<string, any>, options: { files: StorageFunctions, secure: boolean, break: boolean, context: Record<string, any> }): Promise<ValidationResult> => {
+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: [] };
 
@@ -624,7 +568,7 @@ const validate_internal = async (fields: Field[], data: Record<string, any>, opt
 
       const cloned = _.cloneDeep(data);
 
-      const recursive = await recursive_schema(field, cloned, { files: options.files, alter: true, context: options.context });
+      const recursive = await recursive_schema(field, cloned, { alter: true, context: options.context });
       if (!recursive) { continue; }
 
       const resolved = _.get(cloned, field.key, field.default);