@beseif-solutions/prow-core 1.0.1 → 1.0.3

package/src/minified-utils/validation.ts

@@ -0,0 +1,666 @@
+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 { CommonField, Field, FileInputField, SelectFieldChoice } from "./fields";
+
+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: 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()),
+    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)
+    const resolved = context.resolve(newField, value, options.context);
+    _.set(data, relativeKey, resolved);
+
+    // omit undefined for array mappings
+    if (typeof resolved === `undefined` && options.array) { return { schema: null, field: null }; }
+
+    // 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); }
+          }
+
+          // override array value - omit undefined items
+          const withoutUndefined = resolved.filter((r) => typeof r !== `undefined`);
+          _.set(data, relativeKey, withoutUndefined);
+        }
+
+        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) {
+      if (resolved || newField.required) {
+        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 {
+        delete newField.items;
+        calculatedSchema = getSimpleFieldSchema(newField);
+      }
+    } 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);
+    }
+    // remove undefined values
+    return JSON.parse(JSON.stringify(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; }
+};