@beseif-solutions/prow-core 1.0.0 → 1.0.2

package/dist/minified-utils/fields.js

@@ -1,617 +1,2 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract = exports.validate = exports.alter = exports.fieldsSchema = exports.fieldSchema = void 0;
-const joi_1 = __importDefault(require("joi"));
-const lodash_1 = __importDefault(require("lodash"));
-const moment_timezone_1 = __importDefault(require("moment-timezone"));
-const context_1 = __importDefault(require("./context"));
-const where_1 = require("./where");
-const conditionSchema = () => joi_1.default.object({
-    condition: joi_1.default.object().required(),
-    overrides: joi_1.default.object().required(),
-});
-const commonFieldSchema = () => joi_1.default.object({
-    key: joi_1.default.string().required(),
-    altered_by: joi_1.default.array().items(conditionSchema()),
-    disabled: joi_1.default.bool(),
-    required: joi_1.default.bool(),
-    as_password: joi_1.default.bool(),
-    show: joi_1.default.bool(),
-    t: joi_1.default.string(),
-    as_array: joi_1.default.bool(),
-    array_min: joi_1.default.when(`as_array`, {
-        is: true,
-        then: joi_1.default.number(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-    array_max: joi_1.default.when(`as_array`, {
-        is: true,
-        then: joi_1.default.number(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-    array_length: joi_1.default.when(`as_array`, {
-        is: true,
-        then: joi_1.default.number(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-}).concat(joi_1.default.object()
-    .pattern(joi_1.default.string().regex(/^experimental_/), joi_1.default.any()));
-const types = [`any`, `string`, `number`, `boolean`, `date`, `datetime`, `time`, `dict`, `file`];
-const inputFieldBaseSchema = () => joi_1.default.object({
-    type: joi_1.default.string().required()
-        .valid(...types),
-})
-    .concat(commonFieldSchema())
-    .unknown();
-const choiceSchema = (type) => joi_1.default.object({
-    key: joi_1.default.string().required(),
-    value: type.required(),
-    group: joi_1.default.string(),
-}).unknown();
-const choicesSchema = (type) => joi_1.default.alternatives(joi_1.default.string(), joi_1.default.array().min(1)
-    .items(choiceSchema(type)));
-const defaultSchema = (type) => joi_1.default.when(`as_array`, {
-    is: true,
-    then: joi_1.default.array().items(type),
-    otherwise: type,
-});
-const anySchema = (nullish = true) => {
-    const randId = Math.random().toString(36).substring(2, 15);
-    return joi_1.default.alternatives(joi_1.default.string(), joi_1.default.bool(), joi_1.default.number(), joi_1.default.array().items(joi_1.default.link(`#${randId}`)), joi_1.default.object().pattern(joi_1.default.string(), joi_1.default.link(`#${randId}`)), ...nullish ? [joi_1.default.valid(null, ``)] : [])
-        .id(randId);
-};
-const anyInputFieldSchema = () => joi_1.default.object({
-    default: defaultSchema(anySchema()),
-    allow_nullish: joi_1.default.bool().default(true),
-})
-    .concat(joi_1.default.object({
-    format: joi_1.default.string().valid(`select`),
-    choices: joi_1.default.when(`format`, {
-        is: `select`,
-        then: choicesSchema(anySchema()).required(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-}));
-const stringInputFieldSchema = () => joi_1.default.object({
-    default: defaultSchema(joi_1.default.string()),
-    length: joi_1.default.number(),
-    min: joi_1.default.number(),
-    max: joi_1.default.number(),
-    regexp: joi_1.default.string(),
-    pattern: joi_1.default.string().valid(`email`, `uri`),
-    allow_empty: joi_1.default.bool().default(false),
-})
-    .concat(joi_1.default.object({
-    format: joi_1.default.string().valid(`select`, `textarea`, `rich-text`, `markdown`, `code`),
-    choices: joi_1.default.when(`format`, {
-        is: `select`,
-        then: choicesSchema(joi_1.default.string()).required(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-    language: joi_1.default.when(`format`, {
-        is: `code`,
-        then: joi_1.default.string(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-}));
-const numberInputFieldSchema = () => joi_1.default.object({
-    default: defaultSchema(joi_1.default.number()),
-    min: joi_1.default.number(),
-    max: joi_1.default.number(),
-    float: joi_1.default.bool(),
-    decimals: joi_1.default.when(`float`, {
-        is: true,
-        then: joi_1.default.number(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-})
-    .concat(joi_1.default.object({
-    format: joi_1.default.string().valid(`select`),
-    choices: joi_1.default.when(`format`, {
-        is: `select`,
-        then: choicesSchema(joi_1.default.number()).required(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-}));
-const booleanInputFieldSchema = () => joi_1.default.object({
-    default: defaultSchema(joi_1.default.bool()),
-})
-    .concat(joi_1.default.object({
-    format: joi_1.default.string().valid(`select`, `checkbox`, `switch`),
-    choices: joi_1.default.when(`format`, {
-        is: `select`,
-        then: choicesSchema(joi_1.default.bool()).required(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-}));
-const dateInputFieldSchema = () => joi_1.default.object({
-    default: defaultSchema(joi_1.default.alternatives(joi_1.default.string(), joi_1.default.number())),
-    min: joi_1.default.alternatives(joi_1.default.string(), joi_1.default.number()),
-    max: joi_1.default.alternatives(joi_1.default.string(), joi_1.default.number()),
-})
-    .concat(joi_1.default.object({
-    format: joi_1.default.string().valid(`select`),
-    choices: joi_1.default.when(`format`, {
-        is: `select`,
-        then: choicesSchema(joi_1.default.alternatives(joi_1.default.string(), joi_1.default.number())).required(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-}));
-const timeInputFieldSchema = () => joi_1.default.object({
-    default: defaultSchema(joi_1.default.alternatives(joi_1.default.string(), joi_1.default.number())),
-})
-    .concat(joi_1.default.object({
-    format: joi_1.default.string().valid(`select`),
-    choices: joi_1.default.when(`format`, {
-        is: `select`,
-        then: choicesSchema(joi_1.default.alternatives(joi_1.default.string(), joi_1.default.number())).required(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-}));
-const dictInputFieldSchema = () => joi_1.default.object({
-    default: defaultSchema(joi_1.default.object()),
-    items: joi_1.default.array().items(joi_1.default.link(`#field`)).min(1),
-    unknown: joi_1.default.when(`items`, {
-        is: joi_1.default.exist(),
-        then: joi_1.default.bool(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-});
-const fileSchema = () => joi_1.default.object({
-    name: joi_1.default.string().required(),
-    type: joi_1.default.string().required(),
-    content: joi_1.default.string().required(),
-});
-const fileReplacer = (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,
-    ...lodash_1.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 } : {})),
-});
-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({
-    format: joi_1.default.string().valid(`select`),
-    choices: joi_1.default.when(`format`, {
-        is: `select`,
-        then: choicesSchema(fileSchema()).required(),
-        otherwise: joi_1.default.forbidden(),
-    }),
-}));
-const fieldSchema = () => inputFieldBaseSchema()
-    .id(`field`)
-    .when(joi_1.default.object({ type: joi_1.default.valid(`any`) }).unknown(), {
-    then: inputFieldBaseSchema()
-        .concat(anyInputFieldSchema()),
-})
-    .when(joi_1.default.object({ type: joi_1.default.valid(`string`) }).unknown(), {
-    then: inputFieldBaseSchema()
-        .concat(stringInputFieldSchema()),
-})
-    .when(joi_1.default.object({ type: joi_1.default.valid(`number`) }).unknown(), {
-    then: inputFieldBaseSchema()
-        .concat(numberInputFieldSchema()),
-})
-    .when(joi_1.default.object({ type: joi_1.default.valid(`boolean`) }).unknown(), {
-    then: inputFieldBaseSchema()
-        .concat(booleanInputFieldSchema()),
-})
-    .when(joi_1.default.object({ type: joi_1.default.valid(`date`, `datetime`) }).unknown(), {
-    then: inputFieldBaseSchema()
-        .concat(dateInputFieldSchema()),
-})
-    .when(joi_1.default.object({ type: joi_1.default.valid(`time`) }).unknown(), {
-    then: inputFieldBaseSchema()
-        .concat(timeInputFieldSchema()),
-})
-    .when(joi_1.default.object({ type: joi_1.default.valid(`dict`) }).unknown(), {
-    then: inputFieldBaseSchema()
-        .concat(dictInputFieldSchema()),
-})
-    .when(joi_1.default.object({ type: joi_1.default.valid(`file`) }).unknown(), {
-    then: inputFieldBaseSchema()
-        .concat(fileInputFieldSchema()),
-})
-    .when(joi_1.default.object({ type: joi_1.default.invalid(...types) }).unknown(), {
-    then: joi_1.default.forbidden(),
-});
-exports.fieldSchema = fieldSchema;
-const fieldsSchema = () => joi_1.default.array().items((0, exports.fieldSchema)());
-exports.fieldsSchema = fieldsSchema;
-const getSimpleFieldSchema = (field) => {
-    if (field.as_array) {
-        throw new Error(`Cannot use as_array with simple field schema generator`);
-    }
-    let typeSchema;
-    switch (field.type) {
-        case `any`:
-            typeSchema = anySchema(field.allow_nullish);
-            break;
-        case `boolean`:
-            typeSchema = joi_1.default.bool();
-            break;
-        case `string`:
-            typeSchema = joi_1.default.string();
-            if (field.length) {
-                typeSchema = typeSchema.length(field.length);
-            }
-            if (field.min > 0) {
-                typeSchema = typeSchema.min(field.min);
-            }
-            else if (field.allow_empty) {
-                typeSchema = typeSchema.allow(``);
-            }
-            if (field.max) {
-                typeSchema = typeSchema.max(field.max);
-            }
-            if (field.regexp) {
-                typeSchema = typeSchema.regex(new RegExp(field.regexp));
-            }
-            if (field.pattern === `email`) {
-                typeSchema = typeSchema.email();
-            }
-            if (field.pattern === `uri`) {
-                typeSchema = typeSchema.uri();
-            }
-            break;
-        case `date`:
-        case `datetime`:
-        case `time`:
-            if (field.type === `time`) {
-                typeSchema = joi_1.default.string();
-            }
-            else {
-                typeSchema = joi_1.default.date().strict(false);
-                if (field.min) {
-                    typeSchema = typeSchema.min(field.min);
-                }
-                if (field.max) {
-                    typeSchema = typeSchema.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_timezone_1.default.unix(helpers.original).tz(`UTC`)
-                    : moment_timezone_1.default.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_1.default.number();
-            if (field.min) {
-                typeSchema = typeSchema.min(field.min);
-            }
-            if (field.max) {
-                typeSchema = typeSchema.max(field.max);
-            }
-            if (typeof field.float === `boolean`) {
-                if (!field.float) {
-                    typeSchema = typeSchema.precision(0);
-                }
-                else if (field.decimals) {
-                    typeSchema = typeSchema.precision(field.decimals);
-                }
-            }
-            break;
-        case `dict`:
-            if (field.items) {
-                throw new Error(`No simple field`);
-            }
-            typeSchema = joi_1.default.object().unknown(true);
-            break;
-        case `file`:
-            typeSchema = fileSchema();
-            break;
-    }
-    if (`format` in field && field.format === `select`) {
-        if (!field.unknown) {
-            if (lodash_1.default.isArray(field.choices)) {
-                typeSchema = typeSchema.valid(...field.choices.map((c) => c.value));
-            }
-            else {
-            }
-        }
-    }
-    return getGeneralSchema(field, typeSchema);
-};
-const getGeneralArraySchema = (field, schema) => {
-    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, alternatives) => {
-    if (!field.as_array) {
-        throw new Error(`as_array required for array schema generator`);
-    }
-    const schema = joi_1.default.array().items(...alternatives);
-    return getGeneralArraySchema(field, schema);
-};
-const getOrderedArrayFieldSchema = (field, items) => {
-    if (!field.as_array) {
-        throw new Error(`as_array required for array schema generator`);
-    }
-    const schema = joi_1.default.array().ordered(...items);
-    return getGeneralArraySchema(field, schema);
-};
-const getObjectFieldSchema = (field, items) => {
-    if (field.type !== `dict`) {
-        throw new Error(`type must be dict for object schema generator`);
-    }
-    if (!field.items) {
-        throw new Error(`items required for object schema generator`);
-    }
-    let schema = joi_1.default.object();
-    for (const item of items) {
-        schema = schema.concat(joi_1.default.object({
-            [item.key]: item.schema,
-        }));
-    }
-    if (field.unknown) {
-        schema = schema.unknown(field.unknown);
-    }
-    return getGeneralSchema(field, schema);
-};
-const getGeneralSchema = (field, schema) => {
-    if (field.required) {
-        schema = schema.required();
-    }
-    if (field.disabled) {
-        schema = schema.forbidden();
-    }
-    return schema;
-};
-const convertPath = (parts) => parts.map((p, i) => typeof p === `string` ? (i === 0 ? p : `.${p}`) : `[${p}]`).join(``);
-const secure = async (field, validation) => field.as_password ? lodash_1.default.omit(validation, [`value`, `original`]) : validation;
-const relative_condition = (condition, relative) => {
-    try {
-        const newCondition = lodash_1.default.cloneDeep(condition);
-        for (const key of Object.keys(newCondition)) {
-            if (key.startsWith(`@relative`)) {
-                const newKey = key.replace(`@relative`, relative ? relative : ``);
-                newCondition[newKey] = newCondition[key];
-                delete newCondition[key];
-            }
-        }
-        return newCondition;
-    }
-    catch (e) {
-        throw e;
-    }
-};
-const alter = (field, relative, data) => {
-    const cloned = lodash_1.default.cloneDeep(field);
-    for (const alteration of cloned.altered_by) {
-        const condition = relative_condition(alteration.condition, relative);
-        const matches = (0, where_1.where)(data, [condition]);
-        if (matches) {
-            lodash_1.default.assign(cloned, alteration.overrides);
-        }
-    }
-    return cloned;
-};
-exports.alter = alter;
-const recursive_schema = async (field, data, options) => {
-    try {
-        let newField = lodash_1.default.cloneDeep(field);
-        if (newField.altered_by?.length > 0) {
-            newField = (0, exports.alter)(newField, options.relative, data);
-            if (options.alter) {
-                delete newField.altered_by;
-            }
-            if (typeof newField.show === `boolean` && !newField.show) {
-                return;
-            }
-        }
-        const alteredField = lodash_1.default.cloneDeep(newField);
-        if (newField.type === `file`) {
-            newField = fileReplacer(newField);
-        }
-        const relativeKey = options.relative ?
-            options.relative.endsWith(`]`) ?
-                options.array ? options.relative : `${options.relative}.${newField.key}`
-                : `${options.relative}.${newField.key}`
-            : newField.key;
-        const value = lodash_1.default.get(data, relativeKey, newField.default);
-        const resolved = context_1.default.resolve(newField, value, options.context);
-        if (typeof resolved !== `undefined`) {
-            lodash_1.default.set(data, relativeKey, resolved);
-        }
-        let calculatedSchema;
-        if (newField.as_array) {
-            const noArrayField = lodash_1.default.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]);
-            if (resolved) {
-                const itemSchemas = [];
-                if (lodash_1.default.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;
-                if (noArrayField.type === `dict` && noArrayField.items) {
-                    const items = [];
-                    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 = [];
-            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 (newField.disabled) {
-            lodash_1.default.unset(data, relativeKey);
-        }
-        return { schema: calculatedSchema, field: field.type === `file` ? alteredField : newField };
-    }
-    catch (e) {
-        throw e;
-    }
-};
-const validate_internal = async (fields, data, options) => {
-    try {
-        const response = { valid: true, fields: [] };
-        for (const field of fields) {
-            const value = lodash_1.default.get(data, field.key, field.default);
-            const cloned = lodash_1.default.cloneDeep(data);
-            const recursive = await recursive_schema(field, cloned, { alter: true, context: options.context });
-            if (!recursive) {
-                continue;
-            }
-            const resolved = lodash_1.default.get(cloned, field.key, field.default);
-            let validation;
-            let error;
-            try {
-                validation = await recursive.schema.validateAsync(resolved, { abortEarly: false });
-            }
-            catch (e) {
-                error = e;
-            }
-            let extended;
-            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 {
-                lodash_1.default.set(data, field.key, validation);
-                extended = {
-                    valid: true,
-                    original: value,
-                    value: validation,
-                };
-            }
-            response.valid && (response.valid = error ? false : true);
-            response.fields.push({
-                ...recursive.field,
-                ...options.secure ? await secure(field, extended) : extended,
-            });
-        }
-        return response;
-    }
-    catch (e) {
-        throw e;
-    }
-};
-const validate = async (fields, data, options = {}) => {
-    try {
-        const { error } = (0, exports.fieldsSchema)().validate(fields);
-        if (error) {
-            throw new Error(`Invalid fields definition: ${error.message}`);
-        }
-        const defaultOptions = lodash_1.default.assign({ secure: true, break: false, context: {} }, options);
-        const response = await validate_internal(fields, data, defaultOptions);
-        return response;
-    }
-    catch (e) {
-        throw e;
-    }
-};
-exports.validate = validate;
-const extract_recursive = async (validation, options, path = ``) => {
-    try {
-        const response = {};
-        for (const field of validation) {
-            const key = lodash_1.default.compact([path, field.key]).join(`.`);
-            lodash_1.default.set(response, key, options.original ? field.original : field.value);
-        }
-        return response;
-    }
-    catch (e) {
-        throw e;
-    }
-};
-const extract = async (validation, options = {}) => {
-    try {
-        return await extract_recursive(validation, options);
-    }
-    catch (e) {
-        throw e;
-    }
-};
-exports.extract = extract;

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

@@ -0,0 +1,31 @@
+import Joi from "joi";
+import { Field } from "./fields";
+type ValidationExtended = {
+    original: any;
+    value: any;
+} & ({
+    valid: true;
+} | {
+    valid: false;
+    errors: {
+        path: string;
+        message: string;
+        type: string;
+    }[];
+});
+export declare const fieldSchema: () => Joi.ObjectSchema<any>;
+export declare const fieldsSchema: () => Joi.ArraySchema<any[]>;
+export type ValidationResult<Extended = Record<string, never>> = {
+    valid: boolean;
+    fields: Field<Extended & ValidationExtended>[];
+};
+export declare const alter: (field: Field, relative: string, data: Record<string, any>) => Field;
+export declare const validate: <I>(fields: Field<I>[], data: Record<string, any>, options?: {
+    secure?: boolean;
+    break?: boolean;
+    context?: Record<string, any>;
+}) => Promise<ValidationResult<I>>;
+export declare const extract: (validation: Field<ValidationExtended>[], options?: {
+    original?: boolean;
+}) => Promise<Record<string, any>>;
+export {};