@useparagon/core 0.0.1-canary.1

package/src/steps/library/response/response.step.ts

@@ -0,0 +1,68 @@
+import { DataType, TokenizedSource } from '../../../resolvers';
+import {
+  resolveParamsToSources,
+  resolveToSource,
+} from '../../../resolvers/resolver.utils';
+import { Step } from '../../step';
+import { StepType } from '../../step.interface';
+import {
+  IResponseStep,
+  IResponseStepInit,
+  IResponseStepParameters,
+  ResponseTypeEnum,
+} from './response.interface';
+
+/**
+ * a step used for making HTTP Responses
+ */
+export class ResponseStep extends Step implements IResponseStep {
+  /**
+   * the step type
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.RESPONSE = StepType.RESPONSE;
+
+  /**
+   * configuration for the response step
+   * @type {IResponseStepParameters}
+   * @memberof ResponseStep
+   */
+  parameters: IResponseStepParameters;
+
+  /**
+   * initialization parameters
+   * @type {IResponseStepInit}
+   * @memberof ResponseStep
+   */
+  _parameters: IResponseStepInit;
+
+  constructor(params: IResponseStepInit) {
+    super(params);
+    this._parameters = params;
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IResponseStepParameters {
+    const initParams: IResponseStepInit = this._parameters;
+
+    if (initParams.responseType === ResponseTypeEnum.FILE) {
+      return {
+        statusCode: initParams.statusCode,
+        bodyData: [],
+        bodyFile: resolveToSource(
+          initParams.body,
+          DataType.FILE,
+        ) as TokenizedSource<DataType.FILE>,
+      };
+    }
+
+    return {
+      statusCode: initParams.statusCode,
+      bodyData: resolveParamsToSources(initParams.body),
+    };
+  }
+}

package/src/steps/step.constants.ts

@@ -0,0 +1,4 @@
+/**
+ * placeholder for step ids
+ */
+export const UNSET_STEP_ID: string = '__UNSET_STEP_ID__';

package/src/steps/step.interface-base.ts

@@ -0,0 +1,81 @@
+import { IStep } from './step.interface';
+
+/**
+ * the supported step types
+ */
+export enum StepType {
+  ACTION = 'ACTION/CUSTOM',
+  ACTION_TRIGGER = 'TRIGGER/ACTION',
+  CRON = 'TRIGGER/CRON',
+  CUSTOM_INTEGRATION_REQUEST = 'ACTION/CUSTOM_INTEGRATION_REQUEST',
+  DELAY = 'ACTION/DELAY',
+  ENDPOINT = 'TRIGGER/ENDPOINT',
+  EVENT = 'TRIGGER/EVENT',
+  FUNCTION = 'ACTION/FUNCTION',
+  IFELSE = 'TRANSITION/IFELSE',
+  INTEGRATION_ENABLED = 'TRIGGER/INTEGRATION_ENABLED',
+  MAP = 'TRANSITION/MAP',
+  OAUTH = 'TRIGGER/OAUTH',
+  REDIRECT = 'ACTION/REDIRECT',
+  RESPONSE = 'ACTION/RESPONSE',
+  REQUEST = 'ACTION/REQUEST',
+  UNSELECTED_TRIGGER = 'TRIGGER/NONE',
+}
+
+/**
+ * step types that are valid triggers
+ */
+export const TRIGGER_TYPES = [
+  StepType.UNSELECTED_TRIGGER,
+  StepType.CRON,
+  StepType.ENDPOINT,
+  StepType.OAUTH,
+  StepType.ACTION_TRIGGER,
+  StepType.EVENT,
+  StepType.INTEGRATION_ENABLED,
+];
+
+/**
+ * parameters used to initialize a Step
+ */
+export interface IBaseStepParameters extends Record<string, unknown> {}
+
+/**
+ * a step used in a workflow
+ */
+export interface IBaseStep {
+  /**
+   * the id of the step
+   */
+  id: string;
+
+  /**
+   * the step type
+   */
+  type: StepType;
+
+  /**
+   * configuration for the step
+   */
+  parameters: IBaseStepParameters;
+
+  /**
+   * the id of the step after the current step
+   */
+  next: string | null;
+
+  /**
+   * description of step
+   */
+  description?: string;
+
+  /**
+   * used for storing data used in migrations or (de)serialization transformations
+   */
+  readonly _migrations?: Record<string, unknown>;
+}
+
+/**
+ * key / value map of steps where the keys are the step ids
+ */
+export type StepMap = Record<string, IStep>;

package/src/steps/step.interface.ts

@@ -0,0 +1,31 @@
+import { ICronStep } from '../triggers/cron/cron.interface';
+import { IEndpointStep } from '../triggers/endpoint/endpoint.interface';
+import { IEventStep } from '../triggers/event/event.interface';
+import { IIntegrationEnabledStep } from '../triggers/integrationEnabled/integrationEnabled.interface';
+import { IActionStep } from './library/action/action.interface';
+import { IConditionalStep } from './library/conditional/conditional.interface';
+import { IDelayStep } from './library/delay/delay.interface';
+import { IFanOutStep } from './library/fanout/fanout.interface';
+import { IFunctionStep } from './library/function/function.interface';
+import { IIntegrationRequestStep } from './library/integrationRequest/integrationRequest.interface';
+import { IRequestStep } from './library/request/request.interface';
+import { IResponseStep } from './library/response/response.interface';
+
+/**
+ * a union type comprised of the different step types
+ */
+export type IStep =
+  | IActionStep
+  | IConditionalStep
+  | ICronStep
+  | IDelayStep
+  | IEndpointStep
+  | IEventStep
+  | IFanOutStep
+  | IFunctionStep
+  | IIntegrationEnabledStep
+  | IIntegrationRequestStep
+  | IRequestStep
+  | IResponseStep;
+
+export * from './step.interface-base';

package/src/steps/step.ts

@@ -0,0 +1,136 @@
+import { getRandomNumberInRange } from '../utils';
+import { UNSET_STEP_ID } from './step.constants';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  IStep,
+  StepType,
+} from './step.interface';
+
+/**
+ * a step used in a workflow
+ */
+export abstract class Step<I = any, O extends IBaseStepParameters = any>
+  implements IBaseStep
+{
+  /**
+   * the id of the step
+   *
+   * @type {string}
+   * @memberof Step
+   */
+  id: string = `${UNSET_STEP_ID}${getRandomNumberInRange(10000, 99999)}`;
+
+  /**
+   * configuration for the step
+   *
+   * @type {IBaseStepParameters}
+   * @memberof Step
+   */
+  abstract parameters: IBaseStepParameters;
+
+  /**
+   * the step type
+   *
+   * @abstract
+   * @type {StepType}
+   * @memberof Step
+   */
+  abstract type: StepType;
+
+  /**
+   * the next step in the sequence
+   *
+   * @private
+   * @type {Step}
+   * @memberof Step
+   */
+  private _next?: Step;
+
+  /**
+   * some steps needed workflowId in param like endpoint trigger
+   */
+  protected workflowId?: string;
+
+  /**
+   * used for storing data used in migrations or (de)serialization transformations
+   *
+   * @private
+   * @type {Record<string, unknown>}
+   * @memberof Step
+   */
+  readonly _migrations: Record<string, unknown> = {};
+
+  /**
+   * returns the id of the next step in the sequence
+   *
+   * @readonly
+   * @type {(string | null)}
+   * @memberof Step
+   */
+  get next(): string | null {
+    return this._next?.id ?? null;
+  }
+
+  constructor(_params: I) {}
+
+  /**
+   * sets a value in the migrations
+   *
+   * @param key
+   * @param value
+   */
+  setMigration(key: string, value: unknown): void {
+    this._migrations[key] = value;
+  }
+
+  /**
+   * sets workflowid
+   * @param workflowId
+   */
+  setWorkflowId(workflowId: string): void {
+    this.workflowId = workflowId;
+  }
+
+  /**
+   * used to specify the next Step in the sequence
+   * @param step the next Step in the sequence
+   */
+  nextStep(step: Step): Step {
+    this._next = step;
+    return step;
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): O {
+    return this.parameters as unknown as O;
+  }
+
+  /**
+   * serializes (to object)
+   * @returns
+   */
+  toObject(): IStep {
+    const step: IStep = {
+      id: this.id,
+      // @ts-ignore: ignore error; TODO: fix type conflicts
+      type: this.type,
+      // @ts-ignore: ignore error; TODO: fix type conflicts
+      parameters: this.serializeParameters(),
+      next: this._next?.id ?? null,
+      _migrations: this._migrations,
+    };
+
+    return step;
+  }
+
+  /**
+   * serializes (to string)
+   * @returns
+   */
+  toString(): string {
+    return JSON.stringify(this.toObject());
+  }
+}

package/src/steps/step.utils.ts

@@ -0,0 +1,103 @@
+import { FanOutStep } from './library/fanout/fanout.step';
+import { IStep, StepMap, StepType, TRIGGER_TYPES } from './step.interface';
+
+/**
+ * determines if a step is a valid trigger step
+ *
+ * @param step
+ * @returns
+ */
+export function isTrigger(step: IStep): boolean {
+  return TRIGGER_TYPES.includes(step.type);
+}
+
+/**
+ * finds the first trigger step in an array of steps
+ *
+ * @param steps
+ * @returns
+ */
+export function getTriggerStep(steps: IStep[]): IStep | undefined {
+  return steps.find(isTrigger);
+}
+
+/**
+ * determines if a step is a conditional
+ *
+ * @param step
+ * @returns
+ */
+export function isConditional(step: IStep): boolean {
+  return step.type === StepType.IFELSE;
+}
+
+/**
+ * determines if a step is a fanout
+ *
+ * @param step
+ * @returns
+ */
+export function isFanout(step: IStep): step is FanOutStep {
+  return step.type === StepType.MAP;
+}
+
+/**
+ * converts an array of steps to a map where the keys are the step ids
+ *
+ * @param steps
+ * @returns
+ */
+export function stepArrayToMap(steps: IStep[]): StepMap {
+  const stepMap: StepMap = {};
+  steps.forEach((step: IStep) => (stepMap[step.id] = step));
+  return stepMap;
+}
+
+/**
+ * converts a map of steps to an array
+ *
+ * @param stepMap
+ * @returns
+ */
+export function stepMapToArray(stepMap: StepMap): IStep[] {
+  return Object.keys(stepMap).map((stepId: string) => stepMap[stepId]);
+}
+
+/**
+ * given a step and an array of steps, it determines if the step is in the list
+ *
+ * @param step
+ * @param stepList
+ * @returns
+ */
+export function isStepInStepList(
+  step: IStep | undefined,
+  stepList: IStep[],
+): boolean {
+  return step && stepList.filter((s: IStep) => s.id === step.id).length > 0
+    ? true
+    : false;
+}
+
+/**
+ * combines two arrays of steps and removes duplicates
+ *
+ * @param a
+ * @param b
+ * @param createNewArray if true, a new array is created; otherwise the first array is modified
+ * @returns
+ */
+export function concatAndDedupeStepLists(
+  a: IStep[],
+  b: IStep[],
+  createNewArray: boolean,
+): IStep[] {
+  const c: IStep[] = createNewArray ? [...a] : a;
+  for (const step of b) {
+    if (c.filter((s: IStep) => s.id === step.id).length === 0) {
+      c.push(step);
+    }
+  }
+
+  return c;
+}

package/src/triggers/cron/cron.interface.ts

@@ -0,0 +1,94 @@
+import { DataType, TokenizedSource } from '../../resolvers/';
+import { IBaseStep, StepType } from '../../steps/step.interface';
+import { ITriggerStepParameters } from '../trigger.interface';
+
+export enum Unit {
+  SECONDS = 'SECONDS',
+  MINUTES = 'MINUTES',
+  HOURLY = 'HOURLY',
+  DAILY = 'DAILY',
+  WEEKLY = 'WEEKLY',
+}
+
+export enum Weekday {
+  MONDAY = 'MONDAY',
+  TUESDAY = 'TUESDAY',
+  WEDNESDAY = 'WEDNESDAY',
+  THURSDAY = 'THURSDAY',
+  FRIDAY = 'FRIDAY',
+  SATURDAY = 'SATURDAY',
+  SUNDAY = 'SUNDAY',
+}
+
+export type Time = {
+  minutes: number;
+  timezone: TokenizedSource<DataType.STRING> | string;
+};
+
+export type SecondsSchedule = { unit: Unit.SECONDS; seconds: number };
+export type MinutesSchedule = { unit: Unit.MINUTES; minutes: number };
+export type HourlySchedule = {
+  unit: Unit.HOURLY;
+  hours: number;
+  offset: number;
+};
+export type DailySchedule<T = Time> = {
+  unit: Unit.DAILY;
+  days: number;
+  time: T;
+};
+export type WeeklySchedule<T = Time> = {
+  unit: Unit.WEEKLY;
+  weekday: Weekday;
+  time: T;
+};
+
+export type Schedule =
+  | SecondsSchedule
+  | MinutesSchedule
+  | HourlySchedule
+  | DailySchedule
+  | WeeklySchedule;
+
+export type Timezone = {
+  offset: string;
+  label: string;
+  tzCode: string;
+};
+
+/**
+ * parameters used for initializing a CronStep
+ */
+export interface ICronStepInitParameters extends ITriggerStepParameters {
+  /**
+   * cron expression
+   */
+  cron: string;
+
+  /**
+   * timzone for cron
+   */
+  timezone: string;
+}
+
+/**
+ * parameters used for initializing a CronStep
+ */
+export interface ICronStepParameters extends ITriggerStepParameters {
+  schedule: Schedule;
+}
+
+/**
+ * a step used for cron trigger
+ */
+export interface ICronStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.CRON;
+
+  /**
+   * configuration for the cron step
+   */
+  parameters: ICronStepParameters;
+}

package/src/triggers/cron/cron.step.ts

@@ -0,0 +1,52 @@
+import { StepType } from '../../steps/step.interface';
+import { TriggerStep } from '../trigger';
+import {
+  ICronStep,
+  ICronStepInitParameters,
+  ICronStepParameters,
+} from './cron.interface';
+import { getSchedule } from './cron.utils';
+
+/**
+ * a step used for cron trigger
+ */
+export class CronStep extends TriggerStep implements ICronStep {
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.CRON = StepType.CRON;
+
+  /**
+   * configuraiton for the cron step
+   *
+   * @type {ICronStepInitParameters}
+   * @memberof CronStep
+   */
+  private _parameters: ICronStepInitParameters;
+
+  /**
+   * configuration for the cron step
+   */
+  parameters: ICronStepParameters;
+
+  constructor(params: ICronStepInitParameters) {
+    super(params);
+    this._parameters = params;
+
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): ICronStepParameters {
+    const cronParameters: ICronStepInitParameters = this._parameters;
+    return {
+      ...this.parameters,
+      schedule: getSchedule(cronParameters.cron, cronParameters.timezone),
+    };
+  }
+}

package/src/triggers/cron/cron.utils.ts

@@ -0,0 +1,117 @@
+import { parseExpression } from 'cron-parser';
+
+import { Schedule, Unit, Weekday } from './cron.interface';
+
+/**
+ * get cron options from schedule
+ * @param schedule
+ * @returns
+ */
+export const getCronOptions = (
+  schedule: Schedule,
+): { cron: string; timeZone?: string } => {
+  switch (schedule.unit) {
+    case Unit.SECONDS:
+      return { cron: `*/${schedule.seconds} * * * * *` };
+    case Unit.MINUTES:
+      return {
+        cron: `0 */${schedule.minutes} * * * *`,
+      };
+    case Unit.HOURLY:
+      return {
+        cron: `0 ${schedule.offset} */${schedule.hours} * * *`,
+      };
+    case Unit.DAILY:
+      const dailyMinutes: number = schedule.time.minutes % 60;
+      const dailyHours: number = Math.floor(schedule.time.minutes / 60);
+      return {
+        cron: `0 ${dailyMinutes} ${dailyHours} */${schedule.days} * *`,
+        timeZone: 'America/Los_Angeles',
+      };
+    case Unit.WEEKLY:
+      const weeklyMinutes: number = schedule.time.minutes % 60;
+      const weeklyHours: number = Math.floor(schedule.time.minutes / 60);
+      const weeklyWeekday: number =
+        Object.keys(Weekday).indexOf(schedule.weekday) + 1;
+      return {
+        cron: `0 ${weeklyMinutes} ${weeklyHours} * * ${weeklyWeekday}`,
+        timeZone: 'America/Los_Angeles',
+      };
+  }
+};
+
+/**
+ * get schedule from cron expression
+ * @param cron
+ */
+export const getSchedule = (
+  cron: string,
+  timezone: string = 'America/Los_Angeles',
+): Schedule => {
+  const parser = parseExpression(cron);
+  const firstIteration: Date = parser.next().toDate();
+  const secondIteration: Date = parser.next().toDate();
+
+  const diffSeconds: number = Math.floor(
+    (secondIteration.getTime() - firstIteration.getTime()) / 1000,
+  );
+  if (diffSeconds < 60) {
+    return {
+      unit: Unit.SECONDS,
+      seconds: diffSeconds,
+    };
+  }
+
+  const diffMinutes: number = Math.floor(diffSeconds / 60);
+  if (diffMinutes < 60) {
+    return {
+      unit: Unit.MINUTES,
+      minutes: diffMinutes,
+    };
+  }
+
+  const diffHours: number = Math.floor(diffMinutes / 60);
+  if (diffHours < 24) {
+    return {
+      unit: Unit.HOURLY,
+      hours: diffHours,
+      offset: (diffMinutes / 60) % 60,
+    };
+  }
+
+  // update this
+  const diffDays: number = Math.floor(diffMinutes / 24);
+
+  if (diffDays < 7) {
+    return {
+      unit: Unit.DAILY,
+      days: diffDays,
+      time: {
+        minutes: 2,
+        timezone,
+      },
+    };
+  }
+
+  if (diffDays > 7) {
+    throw new Error(`not supported crons with more than weekly interval.`);
+  }
+
+  const weekday: Weekday = new Intl.DateTimeFormat('en-US', {
+    weekday: 'long',
+  })
+    .format(firstIteration)
+    .toUpperCase() as Weekday;
+
+  const minutes: number =
+    firstIteration.getHours() * 60 + firstIteration.getMinutes();
+
+  return {
+    unit: Unit.WEEKLY,
+    weekday,
+    time: {
+      minutes,
+      timezone: timezone,
+    },
+  };
+};

package/src/triggers/cron/index.ts

@@ -0,0 +1,3 @@
+export * from './cron.interface';
+export * from './cron.step';
+export * from './cron.utils';