@beseif-solutions/prow-core 0.0.16

package/src/entities/commons.ts

@@ -0,0 +1,40 @@
+import Joi from "joi";
+import { Core } from "../core";
+
+export type CoreConfig = {
+  inputs?: Record<string, any>,
+  credentials?: Record<string, any>,
+  outputs?: Record<string, any>,
+};
+
+export type CoreFunction<Config extends CoreConfig = {}> = (core: Core, configuration: ({
+  sandbox: boolean,
+} & (
+    Config[`inputs`] extends undefined ?
+    {} :
+    { inputs: Config[`inputs`] }
+  )
+  & (
+    Config[`credentials`] extends undefined ?
+    {} :
+    { credentials: Config[`credentials`] }
+  )
+)) => Promise<Config[`outputs`]>;
+
+
+type CommonConfig = Pick<CoreConfig, `credentials`>;
+
+export type Common<Config extends CommonConfig = {}> = {
+  id: string,
+  helpers?: Record<string, CoreFunction<{ credentials: Config[`credentials`], inputs: any, outputs: any }>>,
+};
+
+export const idSchema = () =>
+  Joi.string().required().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+
+export const commonSchema = () =>
+  Joi.object({
+    id: idSchema(),
+    helpers: Joi.object()
+      .pattern(Joi.string(), Joi.function()),
+  });

package/src/entities/credentials.ts

@@ -0,0 +1,131 @@
+import Joi from "joi";
+import { Field, fieldsSchema } from "../minified-utils/fields";
+import { Common, commonSchema, CoreConfig, CoreFunction } from "./commons";
+
+type CredentialsConfig = Pick<CoreConfig, `credentials`>;
+
+type CommonCredentials<Config extends CredentialsConfig = {}> = Common<Config> & {
+  model: `credentials`,
+  sandbox: boolean,
+  functions: {
+    check: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: undefined,
+      outputs: { valid: boolean },
+    }>,
+  },
+};
+
+export type OAuthCredentials<Config extends CredentialsConfig = {}> = CommonCredentials<Config> & {
+  type: `oauth`,
+  functions: {
+    oauth: CoreFunction<{
+      credentials: undefined,
+      inputs: { redirect: string },
+      outputs: {
+        action: string,
+        method: string,
+        body: Record<string, any>,
+      },
+    }>,
+    connect: CoreFunction<{
+      credentials: undefined,
+      inputs: { redirect: string, code: string },
+      outputs: {
+        username?: string,
+        credentials: Config[`credentials`],
+      },
+    }>,
+    refresh: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: undefined,
+      outputs: {
+        username?: string,
+        credentials: Config[`credentials`],
+      },
+    }>,
+    disconnect: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: undefined,
+      outputs: {
+        done: true,
+      },
+    }>,
+  },
+};
+
+export type SessionCredentials<Config extends CredentialsConfig = {}> = CommonCredentials<Config> & {
+  type: `session`,
+  fields: Field[],
+  functions: {
+    connect: CoreFunction<{
+      credentials: undefined,
+      inputs: { fields: Record<string, any> },
+      outputs: {
+        username?: string,
+        credentials: Config[`credentials`],
+      },
+    }>,
+    // refresh: CoreFunction<{
+    //   credentials: Config[`credentials`],
+    //   inputs: undefined,
+    //   outputs: {
+    //     username?: string,
+    //     credentials: Config[`credentials`],
+    //   },
+    // }>,
+  },
+};
+
+export type StaticCredentials<Config extends CredentialsConfig = {}> = CommonCredentials<Config> & {
+  type: `static`,
+  fields: Field[],
+};
+
+export type Credentials<Config extends CredentialsConfig = {}> = OAuthCredentials<Config> | StaticCredentials<Config> | SessionCredentials<Config>;
+
+
+const commonCredentialsSchema = () =>
+  Joi.object({
+    model: Joi.valid(`credentials`).required(),
+    sandbox: Joi.bool().required(),
+    functions: Joi.object({
+      check: Joi.function().required(),
+    }).required(),
+  });
+
+export const oauthCredentialsSchema = () =>
+  Joi.object({
+    type: Joi.valid(`oauth`).required(),
+    functions: Joi.object({
+      oauth: Joi.function().required(),
+      connect: Joi.function().required(),
+      refresh: Joi.function().required(),
+      disconnect: Joi.function().required(),
+    }).required(),
+  })
+    .concat(commonCredentialsSchema())
+    .concat(commonSchema());
+
+export const sessionCredentialsSchema = () =>
+  Joi.object({
+    type: Joi.valid(`session`).required(),
+    functions: Joi.object({
+      connect: Joi.function().required(),
+    }).required(),
+  })
+    .concat(commonCredentialsSchema())
+    .concat(commonSchema());
+
+export const staticCredentialsSchema = () =>
+  Joi.object({
+    type: Joi.valid(`static`).required(),
+    fields: fieldsSchema()
+      .required()
+      .min(1),
+  })
+    .concat(commonCredentialsSchema())
+    .concat(commonSchema());
+
+export const credentialsSchema = () =>
+  Joi.alternatives(oauthCredentialsSchema, staticCredentialsSchema, sessionCredentialsSchema);

package/src/entities/events.ts

@@ -0,0 +1,198 @@
+import { Request } from "express";
+import Joi from "joi";
+import { Field, fieldsSchema } from "../minified-utils/fields";
+import { Common, commonSchema, CoreConfig, CoreFunction, idSchema } from "./commons";
+
+type CommonConnectableEvent<Keys extends string = string> = {
+  key: Keys,
+};
+
+type DefaultConnectableEvent<Keys extends string = string> = CommonConnectableEvent<Keys> & {
+  default: true,
+};
+
+type ErrorConnectableEvent<Keys extends string = string> = CommonConnectableEvent<Keys> & {
+  error: true,
+};
+
+type AdditionalConnectableEvent<Keys extends string = string> = CommonConnectableEvent<Keys> & {};
+
+export type ConnectableEvent<Keys extends string = string> = DefaultConnectableEvent<Keys> | ErrorConnectableEvent<Keys> | AdditionalConnectableEvent<Keys>;
+
+type EventConfig = Pick<CoreConfig, `credentials` | `outputs`> & {
+  flags?: {
+    inputs?: string[],
+    outputs: string[],
+  },
+};
+
+type CommonEvents<Config extends EventConfig = {}> = Common<Config> & {
+  model: `event`,
+  categories: string[],
+  credentials: string[],
+  sandbox: boolean,
+  fields: Field[],
+  examples: EventConfig[`outputs`][],
+};
+
+export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+  type: `trigger`,
+  immediate: true,
+  outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>],
+  functions: {
+    mount?: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Record<string, any> },
+      outputs: { done: boolean },
+    }>,
+    unmount?: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Record<string, any> },
+      outputs: { done: boolean },
+    }>,
+    handle: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Record<string, any>, request: Request },
+      outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
+    }>,
+    fire?: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Record<string, any> },
+      outputs: { done: boolean },
+    }>,
+    poll?: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Record<string, any>, last_schedule?: string, limit?: number },
+      outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
+    }>,
+  },
+};
+
+export type ScheduledTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+  type: `trigger`,
+  immediate: false,
+  outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>],
+  functions: {
+    poll: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Record<string, any>, last_schedule?: string, limit?: number },
+      outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
+    }>,
+  },
+};
+
+export type Trigger<Config extends EventConfig = {}> =
+  | ImmediateTrigger<Config>
+  | ScheduledTrigger<Config>;
+
+export type Action<Config extends EventConfig = {}> = CommonEvents<Config> & {
+  type: `action`,
+  inputs: [DefaultConnectableEvent<Config[`flags`][`inputs`][number]>, ...AdditionalConnectableEvent<Config[`flags`][`inputs`][number]>[]],
+  outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>, ...(AdditionalConnectableEvent<Config[`flags`][`outputs`][number]> | ErrorConnectableEvent<Config[`flags`][`outputs`][number]>)[]],
+  functions: {
+    execute: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Record<string, any>, flags: Partial<Record<Config[`flags`][`inputs`][number], true>> },
+      outputs: { output: Config[`outputs`], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
+    }>,
+  },
+};
+
+export type Event<Config extends EventConfig = {}> =
+  | Action<Config>
+  | Trigger<Config>;
+
+const commonConnectableEventSchema = () =>
+  Joi.object({
+    key: Joi.string().required(),
+  });
+
+const defaultConnectableEventSchema = () =>
+  Joi.object({
+    default: Joi.valid(true).required(),
+  })
+    .concat(commonConnectableEventSchema());
+
+const errorConnectableEventSchema = () =>
+  Joi.object({
+    error: Joi.valid(true).required(),
+  })
+    .concat(commonConnectableEventSchema());
+
+const additionalConnectableEventSchema = () =>
+  Joi.object({})
+    .concat(commonConnectableEventSchema());
+
+const commonEventsSchema = () =>
+  Joi.object({
+    model: Joi.valid(`event`).required(),
+    categories: Joi.array().items(Joi.string()).required(),
+    credentials: Joi.array().items(idSchema().optional()).required().min(0),
+    sandbox: Joi.bool().required(),
+    fields: fieldsSchema().required(),
+    examples: Joi.array(),
+  });
+
+export const scheduledTriggerSchema = () =>
+  Joi.object({
+    type: Joi.valid(`trigger`).required(),
+    immediate: Joi.valid(false).required(),
+    outputs: Joi.array()
+      .length(1)
+      .items(defaultConnectableEventSchema())
+      .required(),
+    functions: Joi.object({
+      poll: Joi.function().required(),
+    }).required(),
+  })
+    .concat(commonSchema())
+    .concat(commonEventsSchema());
+
+export const immediateTriggerSchema = () =>
+  Joi.object({
+    type: Joi.valid(`trigger`).required(),
+    immediate: Joi.valid(true).required(),
+    outputs: Joi.array()
+      .items(defaultConnectableEventSchema())
+      .length(1)
+      .required(),
+    functions: Joi.object({
+      mount: Joi.function(),
+      unmount: Joi.function(),
+      handle: Joi.function().required(),
+      poll: Joi.function(),
+    }).required(),
+  })
+    .concat(commonSchema())
+    .concat(commonEventsSchema());
+
+export const triggerSchema = () =>
+  Joi.alternatives(scheduledTriggerSchema(), immediateTriggerSchema());
+
+export const actionSchema = () =>
+  Joi.object({
+    type: Joi.valid(`action`).required(),
+    inputs: Joi.array()
+      .items(
+        defaultConnectableEventSchema().required(),
+        additionalConnectableEventSchema(),
+      )
+      .min(1)
+      .required(),
+    outputs: Joi.array()
+      .items(
+        defaultConnectableEventSchema().required(),
+        errorConnectableEventSchema().optional(),
+        additionalConnectableEventSchema().optional(),
+      )
+      .min(1)
+      .required(),
+    functions: Joi.object({
+      execute: Joi.function().required(),
+    }).required(),
+  })
+    .concat(commonSchema())
+    .concat(commonEventsSchema());
+
+export const eventSchema = () =>
+  Joi.alternatives(triggerSchema(), actionSchema());

package/src/entities/provider.ts

@@ -0,0 +1,29 @@
+import Joi from "joi";
+import { Credentials, credentialsSchema } from "./credentials";
+import { Action, actionSchema, Trigger, triggerSchema } from "./events";
+import { idSchema } from "./commons";
+
+export type Provider = {
+  id: string,
+  model: `provider`,
+  categories: string[],
+  credentials: Record<string, Credentials>,
+  triggers: Record<string, Trigger>,
+  actions: Record<string, Action>,
+};
+
+export const providerSchema = () =>
+  Joi.object({
+    id: idSchema(),
+    model: Joi.valid(`provider`).required(),
+    categories: Joi.array().items(Joi.string()).required(),
+    credentials: Joi.object()
+      .pattern(idSchema(), credentialsSchema())
+      .required(),
+    triggers: Joi.object()
+      .pattern(idSchema(), triggerSchema())
+      .required(),
+    actions: Joi.object()
+      .pattern(idSchema(), actionSchema())
+      .required(),
+  });

package/src/index.ts

@@ -0,0 +1,8 @@
+export { Core, core } from './core';
+export { getCategories } from './entities/category';
+export { CoreFunction, idSchema } from './entities/commons';
+export { Credentials, OAuthCredentials, StaticCredentials, SessionCredentials, credentialsSchema, oauthCredentialsSchema, staticCredentialsSchema, sessionCredentialsSchema } from './entities/credentials';
+export { Action, Event, ImmediateTrigger, ScheduledTrigger, Trigger, actionSchema, eventSchema, immediateTriggerSchema, scheduledTriggerSchema, triggerSchema } from './entities/events';
+export { Provider, providerSchema } from './entities/provider';
+export { Field, SelectFieldChoice, ValidationResult, extract, fieldSchema, fieldsSchema, validate } from './minified-utils/fields';
+export { i18n, localizeFields, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';

package/src/minified-utils/context.ts

@@ -0,0 +1,56 @@
+import Handlebars from "handlebars";
+import _ from "lodash";
+
+class Context {
+
+  constructor() {
+
+    // logic and math helpers
+    Handlebars.registerHelper({
+      eq: (v1: any, v2: any) => v1 === v2,
+      ne: (v1: any, v2: any) => v1 !== v2,
+      lt: (v1: any, v2: any) => v1 < v2,
+      gt: (v1: any, v2: any) => v1 > v2,
+      lte: (v1: any, v2: any) => v1 <= v2,
+      gte: (v1: any, v2: any) => v1 >= v2,
+      and: (v1: any, v2: any) => v1 && v2,
+      or: (v1: any, v2: any) => v1 || v2,
+      "+": (v1: number, v2: number) => v1 + v2,
+      "-": (v1: number, v2: number) => v1 - v2,
+      "*": (v1: number, v2: number) => v1 * v2,
+      "/": (v1: number, v2: number) => v1 / v2,
+      "sum": (v1: number, v2: number) => v1 + v2,
+      "subtract": (v1: number, v2: number) => v1 - v2,
+      "multiply": (v1: number, v2: number) => v1 * v2,
+      "divide": (v1: number, v2: number) => v1 / v2,
+      "abs": (v1: number) => Math.abs(v1),
+    });
+
+    // TODO: register helpers
+
+  }
+
+  public readonly resolve = (source: any, data: Record<string, any>) => {
+    let isObject = false;
+    let unresolved: string;
+
+    if (_.isNull(source) || _.isUndefined(source)) { return source; }
+
+    if (_.isObject(source) || _.isArray(source)) {
+      isObject = true;
+      unresolved = JSON.stringify(source);
+    } else if (typeof source === `string`) {
+      unresolved = source;
+    } else { return source; }
+
+    if (!unresolved.includes(`{{`)) { return source; }
+
+    const template = Handlebars.compile(unresolved);
+    const resolved = template(data);
+    return isObject ? JSON.parse(resolved) : resolved;
+  };
+
+}
+
+const context = new Context();
+export default context;

package/src/minified-utils/env.ts

@@ -0,0 +1,90 @@
+import { DotenvParseOutput, parse } from "dotenv";
+import { closeSync, openSync, readFileSync, writeSync } from "fs";
+import _ from "lodash";
+import path from "path";
+import { createInterface } from "readline";
+
+type ReadOptions = {
+  create?: boolean,
+};
+
+export class Env {
+
+  private readonly filepath: string;
+  private readonly env: DotenvParseOutput;
+
+  private readonly getEnv = (flag: `w` | `r`): DotenvParseOutput => {
+    try {
+      const fd = openSync(this.filepath, flag);
+      const buffer = readFileSync(fd);
+      const parsed = parse(buffer);
+      return parsed;
+    } catch (e) { throw e; }
+  };
+
+  constructor(root: string) {
+    if (path.isAbsolute(root)) {
+      this.filepath = path.resolve(root, `.env`);
+    } else {
+      const absolute = process.cwd();
+      this.filepath = path.resolve(absolute, root, `.env`);
+    }
+
+    try {
+      this.env = this.getEnv(`r`);
+    } catch (e) {
+      if (e?.code === `ENOENT`) {
+        this.env = this.getEnv(`w`);
+      } else { throw e; }
+    }
+  }
+
+  public readonly read = async (name: string, options: ReadOptions = {}): Promise<string> => {
+    try {
+      let value: string;
+      if (!_.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 = _.get(this.env, name);
+      }
+
+      return value;
+    } catch (e) { throw e; }
+  };
+
+  public readonly write = async (name: string, value: string): Promise<void> => {
+    try {
+      const fd = openSync(this.filepath, `w`);
+
+      this.env[name] = value;
+
+      const arr: string[] = [];
+      for (const key of Object.keys(this.env)) {
+        arr.push(`${key}=${this.env[key]}`);
+      }
+
+      const buffer = Buffer.from(arr.join(`\n`));
+      writeSync(fd, buffer, 0, buffer.length);
+      closeSync(fd);
+    } catch (e) { throw e; }
+  };
+
+  private readonly prompt = async (text: string): Promise<string> =>
+    new Promise(async (resolve, reject) => {
+      try {
+        const stdin = 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); }
+    });
+
+}