@beseif-solutions/prow-core 0.0.16

package/src/minified-utils/locales.ts

@@ -0,0 +1,124 @@
+import I18n from 'i18n';
+import _ from 'lodash';
+import fs from 'fs';
+import path from 'path';
+import { Credentials, SessionCredentials, StaticCredentials } from '../entities/credentials';
+import { Action, ConnectableEvent, Trigger } from '../entities/events';
+import { Field, SelectFieldChoice } from './fields';
+import { Provider } from '../entities/provider';
+import { validateDirectory } from './utils';
+
+type LocalizedField = {
+  label: string,
+  help: string,
+};
+
+type LocalizedProperties = {
+  name: string,
+  description: string,
+};
+
+type TOptions = { fallback?: boolean };
+
+const DEFAULT_LOCALE = `en`;
+
+export const i18n = (directory: string, options: { locale?: string } = {}) => {
+  try {
+    if (!validateDirectory(directory)) {
+      throw new Error(`Invalid directory: ${directory}`);
+    }
+
+    const availableLocales = fs.readdirSync(directory).map((file) => path.basename(file, path.extname(file)));
+    const requestedLocale = options.locale || DEFAULT_LOCALE;
+
+    const activeLocale = availableLocales.includes(requestedLocale) ? requestedLocale : DEFAULT_LOCALE;
+
+    const i18nInstance: I18n.I18n = new I18n.I18n({
+      locales: availableLocales,
+      directory: directory,
+      defaultLocale: DEFAULT_LOCALE,
+      objectNotation: true,
+      autoReload: true,
+      missingKeyFn: () => ``,
+    });
+    i18nInstance.setLocale(activeLocale);
+
+    return {
+      t: (code: string, opts: TOptions = {}) => {
+        let response = i18nInstance.__(code);
+        if (!response && opts.fallback) {
+          response = i18nInstance.__({ phrase: code, locale: DEFAULT_LOCALE });
+        }
+        return response;
+      }, i18n: i18nInstance,
+    };
+  } catch (e) { throw e; }
+};
+
+const localizeField = (
+  t: ReturnType<typeof i18n>[`t`],
+  element: string,
+  field: Field<LocalizedField>,
+  parent = ``,
+): Field<LocalizedField> => {
+  const key = _.compact([parent, field.key]).join(`.`);
+  field.label = t(`${element}.fields.${key}.label`, { fallback: true });
+  field.help = t(`${element}.fields.${key}.help`);
+
+  if (field.type === `dict` && field.items) {
+    field.items = field.items.map((f) => localizeField(t, element, f, `${key}.items`));
+  } else if (`format` in field && field.format === `select` && _.isArray(field.choices)) {
+    field.choices = field.choices.map((fc: SelectFieldChoice<any, LocalizedField>) => ({
+      ...fc,
+      label: t(`${element}.fields.${key}.choices.${fc.key}.label`, { fallback: true }),
+      help: t(`${element}.fields.${key}.choices.${fc.key}.help`),
+    }));
+  }
+
+  return field;
+};
+
+export const localizeFields = (
+  t: ReturnType<typeof i18n>[`t`],
+  element: Action | Trigger | StaticCredentials | SessionCredentials,
+): Field<LocalizedField>[] => {
+  const response: Field<LocalizedField>[] = [];
+  if (element[`fields`] && element[`fields`].length > 0) {
+    response.push(...element[`fields`].map((f) => localizeField(t, element.id, f as any)));
+  }
+  return response;
+};
+
+export const localizeProperties = (
+  t: ReturnType<typeof i18n>[`t`],
+  element: Action | Trigger | Credentials | Provider,
+): LocalizedProperties => ({
+  name: t(`${element.id}.name`, { fallback: true }),
+  description: t(`${element.id}.description`),
+});
+
+const localizeConnectable = (
+  t: ReturnType<typeof i18n>[`t`],
+  element: Action | Trigger,
+  type: `inputs` | `outputs`,
+): (ConnectableEvent & LocalizedProperties)[] => {
+  const response: (ConnectableEvent & LocalizedProperties)[] = [];
+  if (element[type] && element[type].length > 0) {
+    response.push(...(element[type] as ConnectableEvent[]).map((c) => ({
+      ...c,
+      name: t(`${element.id}.${type}.${c.key}.name`, { fallback: true }),
+      description: t(`${element.id}.${type}.${c.key}.description`),
+    })));
+  }
+  return response;
+};
+
+export const localizeInputs = (
+  t: ReturnType<typeof i18n>[`t`],
+  element: Action,
+) => localizeConnectable(t, element, `inputs`);
+
+export const localizeOutputs = (
+  t: ReturnType<typeof i18n>[`t`],
+  element: Action | Trigger,
+) => localizeConnectable(t, element, `outputs`);

package/src/minified-utils/proxy.ts

@@ -0,0 +1,44 @@
+import { AsyncReturnType } from "./types";
+
+export type ProxyLogs<F extends (...args: any[]) => any> = {
+  before?: (name: string, args: Parameters<F>) => (void | Promise<void>),
+  after?: (name: string, response: AsyncReturnType<F>) => (void | Promise<void>),
+  error?: (name: string, error: Error) => (void | Promise<void>),
+};
+
+export const logProxy = <F extends (...args: any[]) => any>(name: string, f: F, logs: ProxyLogs<F> = {}) => new Proxy(f, {
+  apply: async (target, self, args: Parameters<F>) => {
+    try {
+      if (logs.before) { await logs.before(name, args); }
+      const response = await target(...args);
+      if (logs.after) { await logs.after(name, response); }
+      return response;
+    } catch (e) {
+      if (logs.error) { await logs.error(name, e); }
+      throw e;
+    }
+  },
+});
+
+export const functionProxy = <F extends (...args: any[]) => (any | Promise<any>)>(f: F, name?: string) => new Proxy(f, {
+  apply: async (target, self, args) => {
+    try {
+      console.log(`Call to ${name || target}`);
+      const response = await target(...args);
+      return response;
+    } catch (e) { throw e; }
+  },
+});
+
+export const accessProxy = <T extends object>(obj: T, custom?: Partial<{ [K in keyof T]: T[K] }>) => new Proxy(obj, {
+  get: (target, prop) => {
+    const value = target[prop];
+    if (custom && custom[prop]) {
+      return custom[prop];
+    } else if (typeof value === `function`) {
+      return functionProxy(value, prop as string);
+    } else if (typeof value === `object`) {
+      return accessProxy(value);
+    } else { return value; }
+  },
+});

package/src/minified-utils/types.ts

@@ -0,0 +1,18 @@
+export type RequireMinOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+  [K in Keys]-?: Required<Pick<T, K>>;
+}[Keys];
+
+export type RequireOne<T extends Record<string, any>, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+  [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+
+export type OneOf<T extends Record<string, any>> = Partial<RequireOne<T>>;
+
+export type DeepPartial<T extends Record<string, any>> = {
+  [P in keyof T]?: T[P] extends Record<string, any> ? DeepPartial<T[P]> : T[P];
+};
+
+export type AsyncReturnType<T extends (...args: any[]) => any> =
+  T extends (...args: any[]) => Promise<infer U> ? U :
+  T extends (...args: any[]) => infer U ? U :
+  any;

package/src/minified-utils/utils.ts

@@ -0,0 +1,18 @@
+import fs from 'fs';
+export const validateDirectory = (directory: string): boolean => {
+  try {
+    if (!fs.existsSync(directory)) {
+      console.error(`Directory does not exist: ${directory}`);
+      return false;
+    }
+    const files = fs.readdirSync(directory);
+    if (!files.some((file) => file.endsWith(`.json`))) {
+      console.error(`No valid localization files found in directory: ${directory}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error(`Error validating directory: ${error.message}`);
+    return false;
+  }
+};

package/src/minified-utils/where.ts

@@ -0,0 +1,330 @@
+import moment from "moment-timezone";
+import { DeepPartial, RequireMinOne } from "./types";
+import _ from "lodash";
+import Joi from "joi";
+
+type Basic = string | number | boolean;
+type Is<T extends Basic> = {
+  is: T,
+};
+type Like<T extends Basic> = T extends string ? {
+  like: T,
+} : undefined;
+type ILike<T extends Basic> = T extends string ? {
+  ilike: T,
+} : undefined;
+type In<T extends Basic> = {
+  in: T[],
+};
+type Range<T extends Basic> = RequireMinOne<{
+  lt: T,
+  eq: T,
+  gt: T,
+  gte: T,
+  lte: T,
+}> & {
+  date?: boolean,
+};
+type Contains<T extends (Basic | Record<string, any>)[]> = {
+  contains: T[number] | T,
+};
+type Complex<T extends (Basic | (Basic | Record<string, any>)[])> = T extends Basic ? Is<T> | Like<T> | ILike<T> | In<T> | Range<T> : T extends (Basic | Record<string, any>)[] ? T extends Record<string, any>[] ? Contains<DeepPartial<T[number]>[]> : Contains<T> : never;
+type Condition<T> = (T extends Basic ? T : T extends Complex<infer F> ? (Complex<F> & {
+  inverse?: boolean,
+  nullable?: boolean,
+  relational?: string,
+}) : never);
+
+export type Where<T extends Record<string, any> = Record<string, any>> = Partial<{
+  [K in keyof T]: T[K] extends Basic ? Condition<T[K] | Complex<T[K]>> | Condition<T[K] | Complex<T[K]>>[] : (T[K] extends Record<string, any> ? Where<T[K]> : (T[K] extends any[] ? Condition<Complex<T[K]>> : never));
+}>;
+
+const conditionSchema = () => Joi.object({
+  inverse: Joi.bool(),
+  nullable: Joi.bool(),
+});
+
+const relationalSchema = () => conditionSchema()
+  .concat(Joi.object({
+    relational: Joi.string().required(),
+    is: Joi.string().allow(null),
+    in: Joi.array().items(Joi.string().allow(null)),
+    lt: Joi.string().allow(null),
+    eq: Joi.string().allow(null),
+    gt: Joi.string().allow(null),
+    gte: Joi.string().allow(null),
+    lte: Joi.string().allow(null),
+  }));
+
+const numberSchema = (params: { strict: boolean }) => conditionSchema()
+  .concat(Joi.object({
+    is: Joi.number().strict(params.strict).allow(null),
+    in: Joi.array().items(Joi.number().strict(params.strict).allow(null)),
+    lt: Joi.number().strict(params.strict).allow(null),
+    eq: Joi.number().strict(params.strict).allow(null),
+    gt: Joi.number().strict(params.strict).allow(null),
+    gte: Joi.number().strict(params.strict).allow(null),
+    lte: Joi.number().strict(params.strict).allow(null),
+  })).or(`is`, `in`, `lt`, `eq`, `gt`, `gte`, `lte`);
+
+const stringSchema = (params: { strict: boolean }) => conditionSchema()
+  .concat(Joi.object({
+    is: Joi.string().strict(params.strict).allow(null),
+    like: Joi.string().strict(params.strict).allow(null),
+    ilike: Joi.string().strict(params.strict).allow(null),
+    in: Joi.array().items(Joi.string().strict(params.strict).allow(null)),
+  })).or(`is`, `ilike`, `like`, `in`);
+
+const boolSchema = (params: { strict: boolean }) => conditionSchema()
+  .concat(Joi.object({
+    is: Joi.bool().strict(params.strict).allow(null),
+  })).or(`is`);
+
+const dateSchema = (params: { strict: boolean }) => conditionSchema()
+  .concat(Joi.object({
+    lt: Joi.date().strict(params.strict).allow(null),
+    eq: Joi.date().strict(params.strict).allow(null),
+    gt: Joi.date().strict(params.strict).allow(null),
+    gte: Joi.date().strict(params.strict).allow(null),
+    lte: Joi.date().strict(params.strict).allow(null),
+    date: true,
+  })).or(`lt`, `eq`, `gt`, `gte`, `lte`);
+
+
+const arraySchema = () => conditionSchema()
+  .concat(Joi.object({
+    contains: Joi.alternatives(
+      basicSchema(),
+      Joi.array().items(Joi.any()),
+      Joi.object()
+        .pattern(Joi.string(), Joi.alternatives(basicSchema(), Joi.array().items(Joi.any()), Joi.link(`#object`)))
+        .id(`object`),
+    ),
+  }));
+
+const basicSchema = () => Joi.alternatives(Joi.string().strict(false), Joi.number().strict(false), Joi.bool().strict(false));
+
+const complexSchema = () => Joi.alternatives(
+  numberSchema({ strict: false }),
+  stringSchema({ strict: false }),
+  boolSchema({ strict: false }),
+  dateSchema({ strict: false }),
+  arraySchema(),
+  relationalSchema());
+
+const orSchema = () => Joi.array().items(Joi.alternatives(basicSchema(), complexSchema()));
+
+const whereSchema = () => Joi.object()
+  .pattern(Joi.string(), Joi.alternatives(
+    // and queries
+    basicSchema(), complexSchema(),
+    // or queries
+    orSchema(),
+    // recursive schema
+    Joi.link(`#where`)))
+  .id(`where`);
+
+const clearObject = (obj: Record<string, any>, path = ``): void => {
+  _.map(obj || {}, (v, k) => {
+    if (_.isUndefined(v)) { _.unset(obj, `${path}${k}`); }
+    if (_.isObject(v)) { clearObject(v, `${k}.`); }
+  });
+};
+
+const validate = <DataType>(schema: Joi.Schema, data: DataType, options?: any): DataType => {
+  try {
+    if (!_.isFunction(schema[`validate`])) { throw new Error(`Invalid schema`); }
+    if (_.isObject(data)) { clearObject(data); }
+    const result = schema.validate(data, options);
+    if (result.error) { throw result.error; }
+    return data;
+  } catch (err) {
+    throw new Error(_.get(err, `details.0.message`) || err.message || err);
+  }
+};
+
+const isBasic = (condition: any): condition is Basic => {
+  try {
+    basicSchema().validate(condition);
+    validate(basicSchema(), condition);
+    return true;
+  } catch (e) { return false; }
+};
+
+const isComplex = (condition: any): condition is Complex<any> => {
+  try {
+    validate(complexSchema(), condition);
+    return true;
+  } catch (e) { return false; }
+};
+
+const isOr = (condition: any): condition is (Basic | Complex<any>)[] => {
+  try {
+    validate(orSchema(), condition);
+    return true;
+  } catch (e) { return false; }
+};
+
+const isWhere = (condition: any): condition is Where => {
+  try {
+    validate(whereSchema(), condition);
+    return true;
+  } catch (e) { return false; }
+};
+
+const processRange = (condition: Basic, value: Basic, comparator: `<` | `=` | `>` | `>=` | `<=`, date: boolean): boolean => {
+  let v1: any;
+  let v2: any;
+  let compare: ((v1: any, v2: any) => boolean);
+
+  if (date) {
+    v1 = moment(value as any);
+    v2 = moment(condition as any);
+    switch (comparator) {
+      case `<`:
+        compare = (d1: moment.Moment, d2: moment.Moment) => d1.isBefore(d2);
+        break;
+      case `=`:
+        compare = (d1: moment.Moment, d2: moment.Moment) => !d1.isAfter(d2) && !d1.isBefore(d2);
+        break;
+      case `>`:
+        compare = (d1: moment.Moment, d2: moment.Moment) => d1.isAfter(d2);
+        break;
+      case `>=`:
+        compare = (d1: moment.Moment, d2: moment.Moment) => d1.isAfter(d2) || (!d1.isAfter(d2) && !d1.isBefore(d2));
+        break;
+      case `<=`:
+        compare = (d1: moment.Moment, d2: moment.Moment) => d1.isBefore(d2) || (!d1.isAfter(d2) && !d1.isBefore(d2));
+        break;
+    }
+  } else {
+    v1 = value;
+    v2 = condition;
+    switch (comparator) {
+      case `<`:
+        compare = (d1: any, d2: any) => d1 < d2;
+        break;
+      case `=`:
+        compare = (d1: any, d2: any) => d1 === d2;
+        break;
+      case `>`:
+        compare = (d1: any, d2: any) => d1 > d2;
+        break;
+      case `>=`:
+        compare = (d1: moment.Moment, d2: moment.Moment) => d1 >= d2;
+        break;
+      case `<=`:
+        compare = (d1: moment.Moment, d2: moment.Moment) => d1 <= d2;
+        break;
+    }
+  }
+  return compare(v1, v2);
+};
+
+type Flags = {
+  i?: boolean, // case insensitive
+};
+
+const processBasic = (value: Basic, condition: Condition<Basic>, flags?: Flags): boolean =>
+  (typeof value === `string` && typeof condition === `string` && flags?.i) ?
+    value.toLowerCase() === condition.toLowerCase()
+    : value === condition;
+
+const processComplex = (value: Basic, condition: Condition<Complex<any>>, flags?: Flags): boolean => {
+
+  const results: boolean[] = [];
+
+  // helpers
+  const withNullable = (bool: boolean, val: Basic) => (bool || condition.nullable && _.isNull(val));
+  const withInverse = (bool: boolean) => bool !== condition.inverse;
+
+  // is
+  if (`is` in condition) {
+    const is = (typeof value === `string` && typeof condition.is === `string` && flags?.i) ?
+      value.toLowerCase() === condition.is.toLowerCase()
+      : value === condition.is;
+    results.push(withInverse(withNullable(is, value)));
+  }
+
+  // like
+  if (`like` in condition) {
+    const regexp = new RegExp(`^${condition.like.replace(/%/g, `.*`).replace(/_/g, `.`)}$`);
+    const like = regexp.test(value as string);
+    results.push(withInverse(withNullable(like, value)));
+  }
+
+  if (`ilike` in condition) {
+    const regexp = new RegExp(`^${condition.ilike.replace(/%/g, `.*`).replace(/_/g, `.`)}$`, `i`);
+    const ilike = regexp.test(value as string);
+    results.push(withInverse(withNullable(ilike, value)));
+  }
+
+  // in
+  if (`in` in condition) {
+    const isIn = (condition.in && condition.in.length > 0) ?
+      _.includes(condition.in, value) :
+      _.isNull(value);
+    results.push(withInverse(withNullable(isIn, value)));
+  }
+
+  // range
+  if (`lt` in condition) {
+    const lt = processRange(condition.lt, value, `<`, condition.date || false);
+    results.push(withInverse(withNullable(lt, value)));
+  }
+  if (`eq` in condition) {
+    const eq = processRange(condition.eq, value, `=`, condition.date || false);
+    results.push(withInverse(withNullable(eq, value)));
+  }
+  if (`gt` in condition) {
+    const gt = processRange(condition.gt, value, `>`, condition.date || false);
+
+    results.push(withInverse(withNullable(gt, value)));
+  }
+  if (`gte` in condition) {
+    const gte = processRange(condition.gte, value, `>=`, condition.date || false);
+    results.push(withInverse(withNullable(gte, value)));
+  }
+  if (`lte` in condition) {
+    const lte = processRange(condition.lte, value, `<=`, condition.date || false);
+    results.push(withInverse(withNullable(lte, value)));
+  }
+
+  return !results.some((r) => !r);
+};
+
+const processWhere = (json: Record<string, any>, conditions: Where[], flags?: Flags): boolean => {
+
+  let matches = false;
+  for (const w of conditions) {
+
+    let matchesWhere = true;
+    for (const key of _.keys(w)) {
+      const value = _.get(json, key, null);
+      // if (_.isUndefined(value)) { matchesWhere = false; break; }
+
+      const cond = w[key];
+      if (isOr(cond)) {
+        matchesWhere &&= _.some(cond, (c) => processWhere({ [key]: value }, [{ [key]: c }], flags));
+      } else if (isBasic(cond)) {
+        matchesWhere &&= processBasic(value, cond, flags);
+      } else if (isComplex(cond)) {
+        matchesWhere &&= processComplex(value, cond, flags);
+      } else if (isWhere(cond)) {
+        matchesWhere &&= processWhere(value, [cond], flags);
+      } else {
+        // TODO
+        continue;
+      }
+
+      if (!matchesWhere) { break; }
+    }
+    matches ||= matchesWhere;
+    if (matches) { break; }
+  }
+
+  return matches;
+};
+
+export const where = (json: Record<string, any>, conditions: Where[], flags?: Flags): boolean =>
+  processWhere(json, conditions, flags);

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "removeComments": true,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": [
+    "src/**/*.ts",
+  ],
+  "exclude": [
+    "./test",
+    "node_modules",
+    "dist/**/*.js"
+  ]
+}