@beseif-solutions/prow-core 0.0.16

package/src/minified-utils/fields.ts

@@ -0,0 +1,628 @@
+import Joi, { ArraySchema, DateSchema, NumberSchema, StringSchema } from "joi";
+import _ from "lodash";
+import { OneOf } from "./types";
+import { where, Where } from "./where";
+import moment from "moment-timezone";
+import axios from "axios";
+import context from "./context";
+
+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,
+} & ({
+  as_array?: false,
+} | {
+  as_array: true,
+  array_min?: number,
+  array_max?: number,
+  array_length?: number,
+});
+
+export type Field<Extend = Record<never, never>> = Common & InputField<Extend>;
+
+type InputField<Extend = Record<never, never>> = (
+  | AnyInputField<Extend>
+  | StringInputField<Extend>
+  | NumberInputField<Extend>
+  | BooleanInputField<Extend>
+  | DateTimeInputField<Extend>
+  | DateInputField<Extend>
+  | TimeInputField<Extend>
+  | DictInputField<Extend>
+) & Extend;
+
+type Any = string | number | boolean;
+
+type AnyInputField<Extend = Record<never, never>> = {
+  type: `any`,
+  default?: Any | Any[],
+} & (
+    | SelectField<Any, Extend>
+    | {}
+  );
+
+type StringInputField<Extend = Record<never, never>> = {
+  type: `string`,
+  default?: string | string[],
+  length?: number,
+  min?: number,
+  max?: number,
+  regexp?: string,
+  pattern?: `email` | `uri`,
+} & (
+    | SelectField<string, Extend>
+    | FileField
+    | TextareaField
+    | RichTextField
+    | {}
+  );
+
+type NumberInputField<Extend = Record<never, never>> = {
+  type: `number`,
+  default?: number | number[],
+  min?: number,
+  max?: number,
+} & (
+    | { float: true, decimals?: number }
+    | { float: false }
+  ) & (
+    | SelectField<number, Extend>
+    | {}
+  );
+
+type BooleanInputField<Extend = Record<never, never>> = {
+  type: `boolean`,
+  default?: boolean | boolean[],
+} & (
+    | SelectField<boolean, Extend>
+    | { format: `checkbox` }
+    | { format: `switch` }
+    | {}
+  );
+
+type DateTimeInputField<Extend = Record<never, never>> = {
+  type: `datetime`,
+  timezone?: string,
+  default?: string | number | (string | number)[],
+  min?: number | string,
+  max?: number | string,
+} & (
+    | SelectField<string | number, Extend>
+    | {}
+  );
+
+type DateInputField<Extend = Record<never, never>> = {
+  type: `date`,
+  default?: string | string[],
+  min?: string,
+  max?: string,
+} & (
+    | SelectField<string, Extend>
+    | {}
+  );
+
+type TimeInputField<Extend = Record<never, never>> = {
+  type: `time`,
+  timezone?: string,
+  default?: string | string[],
+} & (
+    | SelectField<string, Extend>
+    | {}
+  );
+
+type DictInputField<Extend = Record<never, never>> = {
+  type: `dict`,
+  default?: Record<string, any> | Record<string, any>[],
+  items?: Field<Extend>[],
+  unknown?: boolean,
+};
+
+/* select configuration */
+type SelectField<Values = string | number | boolean, 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,
+  unknown?: boolean,
+};
+
+export type SelectFieldChoice<Values = string | number | boolean, Extend = Record<never, never>> = {
+  key: string,
+  value: Values,
+} & Extend;
+
+/* file configuration */
+type FileField = {
+  format: `file`,
+};
+
+/* textarea configuration */
+type TextareaField = {
+  format: `textarea`,
+};
+
+/* rich text configuration */
+type RichTextField = {
+  format: `rich-text`,
+};
+
+type ValidationExtended = {
+  original: any,
+  value: any,
+} & ({
+  valid: true,
+} | {
+  valid: false,
+  errors: {
+    path: string,
+    message: string,
+    type: string,
+  }[],
+});
+
+const conditionSchema = () =>
+  Joi.object({
+    condition: Joi.object(),
+    overrides: Joi.object(),
+    show: Joi.bool(),
+  }).xor(`overrides`, `show`);
+
+const commonFieldSchema = () =>
+  Joi.object({
+    key: Joi.string().required(),
+    altered_by: Joi.array().items(conditionSchema()),
+    disabled: Joi.bool(),
+    required: Joi.bool(),
+    as_password: Joi.bool(),
+    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(),
+    }),
+  });
+
+const types = [`any`, `string`, `number`, `boolean`, `date`, `datetime`, `time`, `dict`];
+
+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(),
+  }).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 = () =>
+  Joi.alternatives(Joi.string(), Joi.bool(), Joi.number());
+
+const anyInputFieldSchema = () =>
+  Joi.object({
+    default: defaultSchema(anySchema()),
+  })
+    .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`),
+  })
+    .concat(
+      Joi.object({
+        format: Joi.string().valid(`file`, `select`, `textarea`, `rich-text`),
+        choices: Joi.when(`format`, {
+          is: `select`,
+          then: choicesSchema(Joi.string()).required(),
+          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().required(),
+      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(),
+    }),
+  });
+
+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.invalid(...types) }).unknown(), {
+      then: Joi.forbidden(),
+    });
+
+export const fieldsSchema = () =>
+  Joi.array().items(fieldSchema());
+
+const getFieldSchema = (field: Field) => {
+  let typeSchema: Joi.Schema;
+  switch (field.type) {
+    case `any`:
+      typeSchema = anySchema();
+      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) {
+        typeSchema = (typeSchema as StringSchema).min(field.min);
+      } else {
+        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(); }
+
+      if (`format` in field && field.format === `file`) {
+        typeSchema = typeSchema.external(async (value, helpers) => {
+          if (!helpers.original && !field.required) { return helpers.original; }
+
+          const [asURL, asBase64] = await Promise.allSettled([
+            (async () => {
+              try {
+                const { value: url, error } = Joi.string().uri().validate(helpers.original);
+                if (error) { throw new Error(`Invalid URL schema`); }
+
+                const { data: content } = await axios.get(url, { responseType: `arraybuffer` });
+                return Buffer.from(content).toString(`base64`);
+              } catch (e) { throw e; }
+            })(),
+            (async () => {
+              try {
+                // fastest approach: https://stackoverflow.com/a/8571649
+                const base64regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+                if (!base64regex.test(helpers.original)) { throw new Error(`Invalid regexp`); }
+                return Buffer.from(helpers.original, `base64`).toString(`base64`);
+              } catch (e) { throw e; }
+            })(),
+          ]);
+
+          if (asURL.status === `fulfilled`) {
+            return asURL.value;
+          } else if (asBase64.status === `fulfilled`) {
+            return asBase64.value;
+          }
+
+          return helpers.message({ external: `invalid value, expected URL or Base64 string` });
+        });
+      }
+      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); }
+      if (field.float) {
+        typeSchema = (typeSchema as NumberSchema).precision(field.decimals || 2);
+      } else {
+        typeSchema = (typeSchema as NumberSchema).precision(0);
+      }
+      break;
+    case `dict`:
+      if (field.items) {
+        typeSchema = getFieldsSchema(field.items).unknown(field.unknown || false);
+      } else {
+        typeSchema = Joi.object().unknown(true);
+      }
+      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
+      }
+    }
+  }
+
+  if (field.as_array) {
+    typeSchema = Joi.array().items(typeSchema);
+
+    if (field.array_length) { typeSchema = (typeSchema as ArraySchema).length(field.array_length); }
+    if (field.array_min) { typeSchema = (typeSchema as ArraySchema).min(field.array_min); }
+    if (field.array_max) { typeSchema = (typeSchema as ArraySchema).max(field.array_max); }
+  }
+
+  if (field.disabled) { typeSchema = typeSchema.forbidden(); }
+
+  return field.required ? typeSchema.required() : typeSchema;
+};
+
+const getFieldsSchema = (fields: Field[]) => {
+  let schema = Joi.object();
+
+  for (const field of fields) {
+    const fSchema = getFieldSchema(field);
+    schema = schema.concat(Joi.object({ [field.key]: fSchema }));
+  }
+
+  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 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: [] };
+
+    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;
+            }
+          }
+        }
+
+        delete field.altered_by;
+
+        if (hide) { continue; }
+      }
+
+      const value = _.get(clonedData, field.key, field.default);
+
+      // resolve value with context
+      const resolved = context.resolve(value, options.context);
+
+      // validate resolved value
+      const schema = getFieldSchema(field);
+      let validation: any;
+      let error: any;
+      try {
+        validation = await schema.validateAsync(resolved, { abortEarly: false });
+      } catch (e) { error = e; }
+
+      let extended: ValidationExtended;
+      if (error) {
+        extended = {
+          valid: false,
+          errors: error.details.map((d) => ({
+            type: d.type,
+            path: convertPath([field.key, ...d.path]),
+            message: d.message,
+          })),
+          original: value,
+          value: null,
+        };
+      } else {
+        extended = {
+          valid: true,
+          original: value,
+          value: validation,
+        };
+      }
+
+      _.set(clonedData, field.key, validation);
+      response.valid &&= error ? false : true;
+      response.fields.push({
+        ...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; }
+};