@beseif-solutions/prow-core 0.0.16

package/dist/minified-utils/env.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Env = void 0;
+const dotenv_1 = require("dotenv");
+const fs_1 = require("fs");
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = __importDefault(require("path"));
+const readline_1 = require("readline");
+class Env {
+    constructor(root) {
+        this.getEnv = (flag) => {
+            try {
+                const fd = (0, fs_1.openSync)(this.filepath, flag);
+                const buffer = (0, fs_1.readFileSync)(fd);
+                const parsed = (0, dotenv_1.parse)(buffer);
+                return parsed;
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.read = async (name, options = {}) => {
+            try {
+                let value;
+                if (!lodash_1.default.has(this.env, name)) {
+                    if (!options.create) {
+                        throw new Error(`Environment variable not found: ${name}`);
+                    }
+                    value = await this.prompt(`${name}: `);
+                    await this.write(name, value);
+                }
+                else {
+                    value = lodash_1.default.get(this.env, name);
+                }
+                return value;
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.write = async (name, value) => {
+            try {
+                const fd = (0, fs_1.openSync)(this.filepath, `w`);
+                this.env[name] = value;
+                const arr = [];
+                for (const key of Object.keys(this.env)) {
+                    arr.push(`${key}=${this.env[key]}`);
+                }
+                const buffer = Buffer.from(arr.join(`\n`));
+                (0, fs_1.writeSync)(fd, buffer, 0, buffer.length);
+                (0, fs_1.closeSync)(fd);
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.prompt = async (text) => new Promise(async (resolve, reject) => {
+            try {
+                const stdin = (0, readline_1.createInterface)({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                stdin.on(`close`, () => { reject(`Aborted`); });
+                stdin.question(text, (answer) => {
+                    resolve(answer);
+                    stdin.close();
+                });
+            }
+            catch (e) {
+                reject(e.message || e);
+            }
+        });
+        if (path_1.default.isAbsolute(root)) {
+            this.filepath = path_1.default.resolve(root, `.env`);
+        }
+        else {
+            const absolute = process.cwd();
+            this.filepath = path_1.default.resolve(absolute, root, `.env`);
+        }
+        try {
+            this.env = this.getEnv(`r`);
+        }
+        catch (e) {
+            if (e?.code === `ENOENT`) {
+                this.env = this.getEnv(`w`);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+}
+exports.Env = Env;

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

@@ -0,0 +1,128 @@
+import Joi from "joi";
+import { OneOf } from "./types";
+import { Where } from "./where";
+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;
+};
+type SelectField<Values = string | number | boolean, Extend = Record<never, never>> = {
+    format: `select`;
+    choices: SelectFieldChoice<Values, Extend>[] | string;
+    unknown?: boolean;
+};
+export type SelectFieldChoice<Values = string | number | boolean, Extend = Record<never, never>> = {
+    key: string;
+    value: Values;
+} & Extend;
+type FileField = {
+    format: `file`;
+};
+type TextareaField = {
+    format: `textarea`;
+};
+type RichTextField = {
+    format: `rich-text`;
+};
+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 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 {};

package/dist/minified-utils/fields.js

@@ -0,0 +1,458 @@
+"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.fieldsSchema = exports.fieldSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const lodash_1 = __importDefault(require("lodash"));
+const where_1 = require("./where");
+const moment_timezone_1 = __importDefault(require("moment-timezone"));
+const axios_1 = __importDefault(require("axios"));
+const context_1 = __importDefault(require("./context"));
+const conditionSchema = () => joi_1.default.object({
+    condition: joi_1.default.object(),
+    overrides: joi_1.default.object(),
+    show: joi_1.default.bool(),
+}).xor(`overrides`, `show`);
+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(),
+    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(),
+    }),
+});
+const types = [`any`, `string`, `number`, `boolean`, `date`, `datetime`, `time`, `dict`];
+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(),
+}).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 = () => joi_1.default.alternatives(joi_1.default.string(), joi_1.default.bool(), joi_1.default.number());
+const anyInputFieldSchema = () => joi_1.default.object({
+    default: defaultSchema(anySchema()),
+})
+    .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`),
+})
+    .concat(joi_1.default.object({
+    format: joi_1.default.string().valid(`file`, `select`, `textarea`, `rich-text`),
+    choices: joi_1.default.when(`format`, {
+        is: `select`,
+        then: choicesSchema(joi_1.default.string()).required(),
+        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().required(),
+        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 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.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 getFieldSchema = (field) => {
+    let typeSchema;
+    switch (field.type) {
+        case `any`:
+            typeSchema = anySchema();
+            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) {
+                typeSchema = typeSchema.min(field.min);
+            }
+            else {
+                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();
+            }
+            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_1.default.string().uri().validate(helpers.original);
+                                if (error) {
+                                    throw new Error(`Invalid URL schema`);
+                                }
+                                const { data: content } = await axios_1.default.get(url, { responseType: `arraybuffer` });
+                                return Buffer.from(content).toString(`base64`);
+                            }
+                            catch (e) {
+                                throw e;
+                            }
+                        })(),
+                        (async () => {
+                            try {
+                                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_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 (field.float) {
+                typeSchema = typeSchema.precision(field.decimals || 2);
+            }
+            else {
+                typeSchema = typeSchema.precision(0);
+            }
+            break;
+        case `dict`:
+            if (field.items) {
+                typeSchema = getFieldsSchema(field.items).unknown(field.unknown || false);
+            }
+            else {
+                typeSchema = joi_1.default.object().unknown(true);
+            }
+            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 {
+            }
+        }
+    }
+    if (field.as_array) {
+        typeSchema = joi_1.default.array().items(typeSchema);
+        if (field.array_length) {
+            typeSchema = typeSchema.length(field.array_length);
+        }
+        if (field.array_min) {
+            typeSchema = typeSchema.min(field.array_min);
+        }
+        if (field.array_max) {
+            typeSchema = typeSchema.max(field.array_max);
+        }
+    }
+    if (field.disabled) {
+        typeSchema = typeSchema.forbidden();
+    }
+    return field.required ? typeSchema.required() : typeSchema;
+};
+const getFieldsSchema = (fields) => {
+    let schema = joi_1.default.object();
+    for (const field of fields) {
+        const fSchema = getFieldSchema(field);
+        schema = schema.concat(joi_1.default.object({ [field.key]: fSchema }));
+    }
+    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 validate_internal = async (fields, data, options) => {
+    try {
+        const response = { valid: true, fields: [] };
+        const clonedData = lodash_1.default.cloneDeep(data);
+        for (const field of lodash_1.default.compact(fields)) {
+            if (options.break && !response.valid) {
+                break;
+            }
+            if (field.altered_by?.length > 0) {
+                let hide = false;
+                for (const alteration of field.altered_by) {
+                    const matches = (0, where_1.where)(clonedData, [alteration.condition]);
+                    if (matches) {
+                        if (`overrides` in alteration) {
+                            lodash_1.default.assign(field, alteration.overrides);
+                        }
+                        else if (`show` in alteration) {
+                            hide = !alteration.show;
+                        }
+                    }
+                }
+                delete field.altered_by;
+                if (hide) {
+                    continue;
+                }
+            }
+            const value = lodash_1.default.get(clonedData, field.key, field.default);
+            const resolved = context_1.default.resolve(value, options.context);
+            const schema = getFieldSchema(field);
+            let validation;
+            let error;
+            try {
+                validation = await schema.validateAsync(resolved, { abortEarly: false });
+            }
+            catch (e) {
+                error = e;
+            }
+            let extended;
+            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,
+                };
+            }
+            lodash_1.default.set(clonedData, field.key, validation);
+            response.valid && (response.valid = error ? false : true);
+            response.fields.push({
+                ...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;