@useparagon/core 0.0.1-canary.1

package/src/steps/index.ts

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

package/src/steps/library/action/action.interface.ts

@@ -0,0 +1,69 @@
+import { KeyedSource } from '../../../resolvers/resolvers.interface';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../../step.interface-base';
+
+/**
+ * parameters for initializing an ActionStep
+ */
+export interface IActionStepInit<I extends Record<string, unknown>, _O = any>
+  extends IBaseStepParameters {
+  parameters: I;
+
+  /**
+   * the name of the intent for the action
+   */
+  intent: string;
+
+  /**
+   * the name of the integration that the action belongs to
+   */
+  actionType: string;
+}
+
+/**
+ * parameters used for initializing an ActionStep
+ */
+export interface IActionStepParameters extends IBaseStepParameters {
+  /**
+   * the name of the intent for the action
+   */
+  intent: string;
+
+  /**
+   * parameters for the intent
+   */
+  actionParameters: KeyedSource[];
+
+  /**
+   * the name of the integration that the action belongs to
+   */
+  actionType: string;
+
+  /**
+   * whether or not to retry when the step fails
+   */
+  retryOnFailure?: boolean;
+
+  /**
+   * whether or not to continue if the step fails
+   */
+  ignoreFailure?: boolean;
+}
+
+/**
+ * a step used for executing an action belonging to an integration
+ */
+export interface IActionStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.ACTION;
+
+  /**
+   * configuration for the step
+   */
+  parameters: IActionStepParameters;
+}

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

@@ -0,0 +1,70 @@
+import { resolveParamsToSources } from '../../../resolvers/resolver.utils';
+import { KeyedSource } from '../../../resolvers/resolvers.interface';
+import { Step } from '../../step';
+import { StepType } from '../../step.interface';
+import {
+  IActionStep,
+  IActionStepInit,
+  IActionStepParameters,
+} from './action.interface';
+
+/**
+ * a step that executes an action
+ */
+export class ActionStep<I extends Record<string, unknown>, O = any>
+  extends Step<IActionStepInit<I, O>, IActionStepParameters>
+  implements IActionStep
+{
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.ACTION = StepType.ACTION;
+
+  /**
+   * configuration for the step
+   */
+  parameters: IActionStepParameters;
+
+  /**
+   * initialization parameters
+   */
+  private _parameters: IActionStepInit<I, O>;
+
+  /**
+   *
+   *
+   * @readonly
+   * @type {O}
+   * @memberof ActionStep
+   */
+  get output(): O {
+    return {} as O;
+  }
+
+  constructor(params: IActionStepInit<I, O>) {
+    super(params);
+    this._parameters = params;
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IActionStepParameters {
+    const actionParameters = this._parameters.parameters;
+    const serializedActionParameters: KeyedSource[] =
+      resolveParamsToSources(actionParameters);
+
+    const output: IActionStepParameters = {
+      ...this._parameters,
+      actionParameters: serializedActionParameters,
+    };
+
+    delete output['parameters'];
+
+    return output;
+  }
+}

package/src/steps/library/action/index.ts

@@ -0,0 +1,2 @@
+export * from './action.interface';
+export * from './action.step';

package/src/steps/library/conditional/conditional.interface.ts

@@ -0,0 +1,82 @@
+import {
+  Condition,
+  ConditionWrapper,
+} from '../../../resolvers/resolvers.interface';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../../step.interface-base';
+
+/**
+ * conditional input
+ * 1- Operator is used when there is no AND and OR operator used
+ * 2- Array<Operator> is used for AND(...operators)
+ * 3 - Array<Operator[]> is used for OR(AND(...operators))
+ */
+export type ConditionalInput =
+  | Condition
+  | Array<Condition>
+  | Array<Condition[]>;
+
+/**
+ * represents a path of steps that can be traversed based on an evaluation of a condition
+ */
+export type Choice = {
+  /**
+   * the condition to be evaluated
+   */
+  conditionWrapper?: ConditionWrapper;
+
+  /**
+   * signifies this is the preferred path
+   */
+  isDefault: boolean;
+
+  /**
+   * a label for the path; used in the UI
+   */
+  label: string;
+
+  /**
+   * the id of the first step in the path
+   */
+  next: string | undefined | null;
+};
+
+/**
+ * parameters used to initialize a conditional step
+ */
+export interface IConditionalStepInit extends IBaseStepParameters {
+  /**
+   * conditions for conditional step
+   */
+  if: ConditionalInput;
+}
+
+/**
+ * parameters used for initializing a ConditionalStep
+ */
+export interface IConditionalStepParameters extends IBaseStepParameters {
+  /**
+   * the choices for the conditional step
+   */
+  choices: Choice[];
+}
+
+/**
+ * a step used for iterating over arrays
+ */
+export interface IConditionalStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.IFELSE;
+
+  /**
+   * configuration for the step
+   */
+  parameters: {
+    choices: Choice[];
+  };
+}

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

@@ -0,0 +1,96 @@
+import { ConditionWrapper } from '../../../resolvers';
+import { Step } from '../../step';
+import { StepType } from '../../step.interface';
+import {
+  Choice,
+  IConditionalStep,
+  IConditionalStepInit,
+  IConditionalStepParameters,
+} from './conditional.interface';
+import { parseConditionInput } from './conditional.utils';
+
+/**
+ * a step used for iterating over arrays
+ */
+export class ConditionalStep
+  extends Step<IConditionalStepInit, IConditionalStepParameters>
+  implements IConditionalStep
+{
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.IFELSE = StepType.IFELSE;
+
+  /**
+   * configuration for the fanout step
+   *
+   * @type {IConditionalStepParameters}
+   * @memberof FanOutStep
+   */
+  parameters: IConditionalStepParameters;
+
+  private _parameters: IConditionalStepInit;
+
+  /**
+   *  step pointing to when if condition is true
+   */
+  private _ifStep: Step | undefined = undefined;
+
+  /**
+   * step pointing to when if condition is false
+   */
+  private _elseStep: Step | undefined = undefined;
+
+  constructor(params: IConditionalStepInit) {
+    super(params);
+    this._parameters = params;
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * chain steps that should executed for "true" condition
+   * @param step
+   */
+  whenTrue(step: Step): Step {
+    this._ifStep = step;
+    this.parameters = this.serializeParameters();
+    return this;
+  }
+
+  /**
+   * chain steps that should executed for "false" condition
+   * @param step
+   */
+  whenFalse(step: Step): Step {
+    this._elseStep = step;
+    this.parameters = this.serializeParameters();
+    return this;
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IConditionalStepParameters {
+    const conditionWrapper: ConditionWrapper = parseConditionInput(
+      this._parameters.if,
+    );
+    const ifTrue: Choice = {
+      conditionWrapper,
+      isDefault: true,
+      label: 'Yes',
+      next: this._ifStep?.id,
+    };
+    const ifFalse: Choice = {
+      isDefault: false,
+      label: 'No',
+      next: this._elseStep?.id,
+    };
+    const choices: Choice[] = [ifTrue, ifFalse];
+    return {
+      choices,
+    };
+  }
+}

package/src/steps/library/conditional/conditional.utils.ts

@@ -0,0 +1,110 @@
+import {
+  Condition,
+  ConditionWrapper,
+  OperatorCondition,
+} from '../../../resolvers';
+import { ConditionalInput } from './conditional.interface';
+
+/**
+ * check if passed object is of condition type
+ * @param mayBeCondition
+ * @returns
+ */
+const isCondition = (mayBeCondition: unknown): mayBeCondition is Condition => {
+  if (
+    mayBeCondition &&
+    typeof mayBeCondition === 'object' &&
+    mayBeCondition['type'] === 'OPERATOR'
+  ) {
+    return true;
+  }
+  return false;
+};
+
+/**
+ * check if value is conditional input
+ * @param value
+ * @returns
+ */
+export const isConditionalInput = (
+  value: unknown,
+): value is ConditionalInput => {
+  if (typeof value !== 'object' || !value) {
+    return false;
+  }
+  if (isCondition(value)) {
+    return true;
+  } else if (Array.isArray(value)) {
+    const isAndCondition: boolean = value.every((value) => isCondition(value));
+    const isOrCondition: boolean = value.every(
+      (value) =>
+        Array.isArray(value) &&
+        value.every((innerValue) => isCondition(innerValue)),
+    );
+    return isAndCondition || isOrCondition;
+  }
+  return false;
+};
+
+/**
+ * parse condition input to condition wrapper object
+ * @param conditionInput
+ * @returns
+ */
+export const parseConditionInput = (
+  conditionInput: ConditionalInput,
+): ConditionWrapper => {
+  if (isCondition(conditionInput)) {
+    return {
+      type: 'JOIN',
+      join: 'OR',
+      conditions: [
+        {
+          join: 'AND',
+          type: 'JOIN',
+          conditions: [
+            {
+              type: 'OPERATOR',
+              condition: conditionInput,
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  const firstCondition: Condition | Condition[] = conditionInput[0];
+  if (isCondition(firstCondition)) {
+    return {
+      type: 'JOIN',
+      join: 'OR',
+      conditions: [
+        {
+          join: 'AND',
+          type: 'JOIN',
+          conditions: (conditionInput as Condition[]).map(
+            (condition: Condition): OperatorCondition => ({
+              type: 'OPERATOR',
+              condition,
+            }),
+          ),
+        },
+      ],
+    };
+  }
+
+  return {
+    type: 'JOIN',
+    join: 'OR',
+    conditions: (conditionInput as Array<Condition[]>).map(
+      (conditions: Condition[]) => ({
+        join: 'AND',
+        type: 'JOIN',
+        conditions: conditions.map((condition: Condition) => ({
+          type: 'OPERATOR',
+          condition,
+        })),
+      }),
+    ),
+  };
+};

package/src/steps/library/conditional/index.ts

@@ -0,0 +1,2 @@
+export * from './conditional.interface';
+export * from './conditional.step';

package/src/steps/library/delay/delay.interface.ts

@@ -0,0 +1,71 @@
+import { DataType, Source } from '../../../resolvers/resolvers.interface';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../../step.interface-base';
+
+/**
+ * unit of delay value
+ */
+export enum DelayUnit {
+  SECONDS = 'SECONDS',
+  MINUTES = 'MINUTES',
+  HOURS = 'HOURS',
+  DAYS = 'DAYS',
+}
+
+/**
+ * parameters used for initializing an delay step
+ */
+export interface IDelayStepInit extends IBaseStepParameters {
+  /**
+   * unit for delay value
+   */
+  unit?: keyof typeof DelayUnit;
+
+  /**
+   * value of delay time in seconds if unit key is not passed
+   */
+  value: number;
+}
+
+/**
+ * parameters for delay step
+ */
+export interface IDelayStepParameters extends IBaseStepParameters {
+  /**
+   * unit for delay value
+   */
+  unit: DelayUnit;
+
+  /**
+   * value of delay time
+   */
+  value: Source<DataType.NON_DECIMAL>;
+
+  /**
+   * whether or not to retry when the step fails
+   */
+  retryOnFailure?: boolean;
+
+  /**
+   * whether or not to continue if the step fails
+   */
+  ignoreFailure?: boolean;
+}
+
+/**
+ * a delay step
+ */
+export interface IDelayStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.DELAY;
+
+  /**
+   * configuration for the step
+   */
+  parameters: IDelayStepParameters;
+}

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

@@ -0,0 +1,51 @@
+import { DataType, resolveToSource } from '../../../resolvers';
+import { Step } from '../../step';
+import { StepType } from '../../step.interface';
+import {
+  DelayUnit,
+  IDelayStep,
+  IDelayStepInit,
+  IDelayStepParameters,
+} from './delay.interface';
+
+/**
+ * a step that executes an delay step
+ */
+export class DelayStep
+  extends Step<IDelayStepInit, IDelayStepParameters>
+  implements IDelayStep
+{
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.DELAY = StepType.DELAY;
+
+  /**
+   * configuration for the step
+   */
+  parameters: IDelayStepParameters;
+
+  /**
+   * initialization parameters
+   */
+  private _parameters: IDelayStepInit;
+
+  constructor(params: IDelayStepInit) {
+    super(params);
+    this._parameters = params;
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IDelayStepParameters {
+    return {
+      unit: (this._parameters.unit || DelayUnit.SECONDS) as DelayUnit,
+      value: resolveToSource(this._parameters.value, DataType.NON_DECIMAL),
+    };
+  }
+}

package/src/steps/library/delay/index.ts

@@ -0,0 +1,2 @@
+export * from './delay.interface';
+export * from './delay.step';

package/src/steps/library/fanout/fanout.interface.ts

@@ -0,0 +1,46 @@
+import { DataType, Source } from '../../../resolvers/resolvers.interface';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../../step.interface-base';
+
+/**
+ * parameters for initializing fanout step
+ */
+export interface IFanOutStepInit extends IBaseStepParameters {
+  /**
+   * the items to iterate over
+   */
+  iterator: Array<unknown>;
+}
+
+/**
+ * parameters used for initializing a FanOutStep
+ */
+export interface IFanOutStepParameters extends IBaseStepParameters {
+  /**
+   * the items to iterate over
+   */
+  iterator: Source<DataType.ARRAY>;
+
+  /**
+   * first step in the fanout
+   */
+  nextToIterate?: string | null;
+}
+
+/**
+ * a step used for iterating over arrays
+ */
+export interface IFanOutStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.MAP;
+
+  /**
+   * configuration for the step
+   */
+  parameters: IFanOutStepParameters;
+}

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

@@ -0,0 +1,68 @@
+import { resolveToSource } from '../../../resolvers/resolver.utils';
+import { DataType } from '../../../resolvers/resolvers.interface';
+import { Step } from '../../step';
+import { StepType } from '../../step.interface';
+import {
+  IFanOutStep,
+  IFanOutStepInit,
+  IFanOutStepParameters,
+} from './fanout.interface';
+
+/**
+ * a step used for iterating over arrays
+ */
+export class FanOutStep extends Step implements IFanOutStep {
+  /**
+   * the step type
+   *
+   * @type {StepType.MAP}
+   * @memberof Step
+   */
+  type: StepType.MAP = StepType.MAP;
+
+  /**
+   * configuration for the fanout step
+   *
+   * @type {IFanOutStep['parameters']}
+   * @memberof FanOutStep
+   */
+  parameters: IFanOutStepParameters;
+
+  /**
+   * parameters used for initializing fanout
+   */
+  private _parameters: IFanOutStepInit;
+
+  /**
+   * step to iterate
+   */
+  private _nextToIterate: Step | undefined = undefined;
+
+  constructor(params: IFanOutStepInit) {
+    super(params);
+    this._parameters = params;
+    this._parameters.iterator = params.iterator;
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * used to specify the first step within the fanout
+   * @param step the first step within the fanout
+   */
+  branch(step: Step): Step {
+    this._nextToIterate = step;
+    this.parameters.nextToIterate = this._nextToIterate.id;
+    return this;
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IFanOutStepParameters {
+    const iterator: Array<any> = this._parameters.iterator;
+    return {
+      iterator: resolveToSource(iterator, DataType.ARRAY),
+      nextToIterate: this._nextToIterate?.id,
+    };
+  }
+}

package/src/steps/library/fanout/index.ts

@@ -0,0 +1,2 @@
+export * from './fanout.interface';
+export * from './fanout.step';