@useparagon/core 0.0.1-canary.1

package/src/triggers/endpoint/endpoint.interface.ts

@@ -0,0 +1,66 @@
+import { DataType } from '../../resolvers/resolvers.interface';
+import { IBaseStep, StepType } from '../../steps/step.interface';
+import { ITriggerStepParameters } from '../trigger.interface';
+
+/**
+ * validation options for request params
+ */
+type ParamValidation = { key: string; required: boolean };
+
+/**
+ * validation options for request headers
+ */
+
+type HeaderValidation = { key: string; value: string };
+
+/**
+ * validation options for request body
+ */
+type BodyValidation = {
+  key: string;
+  dataType: keyof typeof DataType;
+  required: boolean;
+};
+
+/**
+ * parameters used for initializing a endpoint step
+ */
+export type IEndpointStepInitParameters = ITriggerStepParameters &
+  (
+    | {
+        allowArbitraryPayload: true;
+      }
+    | {
+        allowArbitraryPayload: false;
+        paramValidations: ParamValidation[];
+        headerValidations: HeaderValidation[];
+        bodyValidations: BodyValidation[];
+      }
+  );
+
+/**
+ * parameters used for initializing a IntegrationEnabledStep
+ */
+export interface IEndpointStepParameters extends ITriggerStepParameters {
+  path: string;
+  httpMethod: 'POST';
+  allowArbitraryPayload: boolean;
+  paramValidations: ParamValidation[];
+  headerValidations: HeaderValidation[];
+  bodyValidations: BodyValidation[];
+}
+
+/**
+ * a step used for endponit step trigger
+ */
+export interface IEndpointStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.ENDPOINT;
+
+  /**
+   * configuration for the endpoint step
+   */
+  parameters: IEndpointStepParameters;
+}

package/src/triggers/endpoint/endpoint.step.ts

@@ -0,0 +1,61 @@
+import { StepType } from '../../steps/step.interface';
+import { TriggerStep } from '../trigger';
+import {
+  IEndpointStep,
+  IEndpointStepParameters,
+  IEndpointStepInitParameters,
+} from './endpoint.interface';
+
+/**
+ * a step used for cron trigger
+ */
+export class EndpointStep extends TriggerStep implements IEndpointStep {
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.ENDPOINT = StepType.ENDPOINT;
+
+  /**
+   * initial configuraiton for the endpoint step
+   * @type {IEndpointStepInitParameters}
+   * @memberof EndpointStep
+   */
+  private _parameters: IEndpointStepInitParameters;
+
+  /**
+   * configuration for the endpoint step
+   */
+  parameters: IEndpointStepParameters;
+
+  constructor(params: IEndpointStepInitParameters) {
+    super(params);
+    this._parameters = params;
+
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IEndpointStepParameters {
+    const initParams: IEndpointStepInitParameters = this._parameters;
+
+    const defaultParams: IEndpointStepParameters = {
+      httpMethod: 'POST',
+      paramValidations: [],
+      headerValidations: [],
+      bodyValidations: [],
+      allowArbitraryPayload: false,
+      path: this.workflowId!,
+    };
+
+    if (initParams.allowArbitraryPayload) {
+      return defaultParams;
+    }
+
+    return { ...defaultParams, ...initParams };
+  }
+}

package/src/triggers/endpoint/index.ts

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

package/src/triggers/event/event.interface.ts

@@ -0,0 +1,43 @@
+import { IEvent } from '../../event';
+import { IBaseStep, StepType } from '../../steps/step.interface';
+import { ITriggerStepParameters } from '../trigger.interface';
+
+/**
+ * parameters used for initializing an event trigger
+ */
+export interface IEventStepInitParameters<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> extends IEvent<T>,
+    ITriggerStepParameters {}
+
+/**
+ * parameters used for initializing an event trigger
+ */
+export interface IEventStepParameters extends ITriggerStepParameters {
+  /**
+   * event id of event
+   */
+  eventId: string;
+}
+
+/**
+ * an app event trigger
+ */
+export interface IEventStep<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.EVENT;
+
+  /**
+   * configuration for the event step
+   */
+  parameters: IEventStepParameters;
+
+  /**
+   * schema of event
+   */
+  schema: T;
+}

package/src/triggers/event/event.step.ts

@@ -0,0 +1,41 @@
+import { IEvent } from '../../event/event.interface';
+import { StepType } from '../../steps/step.interface';
+import { TriggerStep } from '../trigger';
+import { IEventStep, IEventStepParameters } from './event.interface';
+
+/**
+ * an app event trigger
+ */
+export class EventStep<E extends Record<string, unknown>>
+  extends TriggerStep
+  implements IEventStep<E>
+{
+  /**
+   * the step type
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.EVENT = StepType.EVENT;
+
+  /**
+   * instance of event
+   */
+  schema: E;
+
+  /**
+   * configuration for the cron step
+   */
+  parameters: IEventStepParameters;
+
+  constructor(params: IEvent<E>) {
+    super(params);
+    this.schema = params.schema as unknown as E;
+
+    if (!params.id) {
+      throw new Error(`id not present in event`);
+    }
+    this.parameters = {
+      eventId: params.id,
+    };
+  }
+}

package/src/triggers/event/index.ts

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

package/src/triggers/index.ts

@@ -0,0 +1,4 @@
+export * from './event';
+export * from './cron';
+export * from './integrationEnabled';
+export * from './endpoint';

package/src/triggers/integrationEnabled/index.ts

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

package/src/triggers/integrationEnabled/integrationEnabled.interface.ts

@@ -0,0 +1,29 @@
+import { IBaseStep, StepType } from '../../steps/step.interface';
+import { ITriggerStepParameters } from '../trigger.interface';
+
+/**
+ * parameters used for initializing a IntegrationEnabledStep
+ */
+export interface IIntegrationEnabledStepInitParameters
+  extends ITriggerStepParameters {}
+
+/**
+ * parameters used for initializing a IntegrationEnabledStep
+ */
+export interface IIntegrationEnabledStepParameters
+  extends ITriggerStepParameters {}
+
+/**
+ * a step used for cron trigger
+ */
+export interface IIntegrationEnabledStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.INTEGRATION_ENABLED;
+
+  /**
+   * configuration for the integration enabled step
+   */
+  parameters: IIntegrationEnabledStepParameters;
+}

package/src/triggers/integrationEnabled/integrationEnabled.step.ts

@@ -0,0 +1,33 @@
+import { StepType } from '../../steps/step.interface';
+import { TriggerStep } from '../trigger';
+import {
+  IIntegrationEnabledStep,
+  IIntegrationEnabledStepInitParameters,
+  IIntegrationEnabledStepParameters,
+} from './integrationEnabled.interface';
+
+/**
+ * a step used for cron trigger
+ */
+export class IntegrationEnabledStep
+  extends TriggerStep
+  implements IIntegrationEnabledStep
+{
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.INTEGRATION_ENABLED = StepType.INTEGRATION_ENABLED;
+
+  /**
+   * configuration for the integration enabled step
+   */
+  parameters: IIntegrationEnabledStepParameters;
+
+  constructor(params: IIntegrationEnabledStepInitParameters) {
+    super(params);
+    this.parameters = params;
+  }
+}

package/src/triggers/trigger.interface.ts

@@ -0,0 +1,28 @@
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../steps/step.interface';
+
+/**
+ * parameters used for initializing a TriggerStep
+ */
+export interface ITriggerStepParameters extends IBaseStepParameters {}
+
+/**
+ * a step used to trigger a workflow
+ */
+export interface ITriggerStep extends IBaseStep {
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof TriggerStep
+   */
+  type: StepType;
+
+  /**
+   * configuration for the trigger step
+   */
+  parameters: ITriggerStepParameters;
+}

package/src/triggers/trigger.ts

@@ -0,0 +1,25 @@
+import { Step, StepType } from '../steps';
+import { ITriggerStep } from './trigger.interface';
+
+/**
+ * a step used to trigger a workflow
+ */
+export abstract class TriggerStep extends Step implements ITriggerStep {
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof TriggerStep
+   */
+  type: StepType = StepType.UNSELECTED_TRIGGER;
+}
+
+/**
+ * class for unselected trigger
+ * needed to generate workflow from paragon cloud
+ */
+export class UnSelectedTriggerStep extends TriggerStep {
+  type: StepType = StepType.UNSELECTED_TRIGGER;
+
+  parameters: {} = {};
+}

package/src/user/index.ts

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

package/src/user/user.interface.ts

@@ -0,0 +1,4 @@
+/**
+ * an end-user that has connected an integration for use in a workflow
+ */
+export interface IConnectUser {}

package/src/user/user.ts

@@ -0,0 +1,6 @@
+import { IConnectUser } from './user.interface';
+
+/**
+ * an end-user that has connected an integration for use in a workflow
+ */
+export class ConnectUser implements IConnectUser {}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './utils';

package/src/utils/utils.ts

@@ -0,0 +1,10 @@
+/**
+ * generates a random number between a range of two numbers
+ *
+ * @param min
+ * @param max
+ * @returns
+ */
+export function getRandomNumberInRange(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}

package/src/workflow/index.ts

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

package/src/workflow/workflow.interface.ts

@@ -0,0 +1,50 @@
+import { IContext } from '../execution';
+import { IIntegration } from '../integration';
+import { StateMachine } from '../stateMachine';
+import { IStep, Step } from '../steps';
+import { IConnectUser } from '../user';
+
+/**
+ * placeholder for workflow ids
+ */
+export const UNSET_WORKFLOW_ID: string = '__UNSET_WORKFLOW_ID__';
+
+/**
+ * a sequence of activities (steps) meant to be orchestrated and executed
+ */
+export interface IWorkflow {
+  /**
+   * the id of the workflow
+   */
+  id: string;
+
+  /**
+   * the steps within the workflow
+   */
+  steps: IStep[];
+}
+
+/**
+ * a sequence of activities (steps) meant to be orchestrated and executed
+ * provides methods for defining itself
+ */
+export interface IExecutableWorkflow<I extends IIntegration> extends IWorkflow {
+  /**
+   * used to define a workflow
+   *
+   * @param integration the integration being used
+   * @param context the execution context
+   * @param user the end-user whose data is flowing through the workflow
+   */
+  define(
+    integration: I,
+    context: IContext,
+    user: IConnectUser,
+  ): Promise<StateMachine>;
+
+  /**
+   * associates steps with a workflow
+   * @param steps the steps to register
+   */
+  register(steps: Record<string, Step>): Promise<StateMachine>;
+}

package/src/workflow/workflow.ts

@@ -0,0 +1,132 @@
+import { v4 } from 'uuid';
+
+import { IContext } from '../execution';
+import { IIntegration } from '../integration';
+import { StateMachine } from '../stateMachine/stateMachine.interface';
+import { workflowStepsToStateMachine } from '../stateMachine/stateMachine.utils';
+import { IStep, Step } from '../steps';
+import { IConnectUser } from '../user';
+import { IExecutableWorkflow, UNSET_WORKFLOW_ID } from './workflow.interface';
+
+/**
+ * a sequence of activities meant to be orchestrated and executed
+ */
+export abstract class Workflow<I extends IIntegration>
+  implements IExecutableWorkflow<I>
+{
+  /**
+   * the id of the workflow
+   *
+   * @memberof Workflow
+   */
+  id = UNSET_WORKFLOW_ID;
+
+  /**
+   * the steps within the workflow
+   *
+   * @type {IStep[]}
+   * @memberof Workflow
+   */
+  steps: IStep[] = [];
+
+  /**
+   * the previous state machine for the workflow
+   * used to reassociate metadata, like step ids
+   *
+   * @type {StateMachine}
+   * @memberof Workflow
+   */
+  previousStateMachine?: StateMachine;
+
+  constructor(previousStateMachine?: StateMachine) {
+    this.previousStateMachine = previousStateMachine;
+  }
+
+  /**
+   * used to define a workflow
+   *
+   * @param integration the integration being used
+   * @param context the execution context
+   * @param user the end-user whose data is flowing through the workflow
+   */
+  abstract define(
+    integration: I,
+    context: IContext,
+    user: IConnectUser,
+  ): Promise<StateMachine>;
+
+  /**
+   * associates steps with a workflow and builds a state machine
+   *
+   * @param steps the steps to register
+   */
+  public register(steps: Record<string, Step>): Promise<StateMachine> {
+    return new Promise(
+      (
+        resolve: (stateMachine: StateMachine) => void,
+        reject: (error: unknown) => void,
+      ) => {
+        try {
+          this.reset();
+          steps = this.attemptToRehydrateIdentifiers(steps);
+
+          const stepList: IStep[] = Object.values(steps)
+            .map((step: Step) => step.toObject())
+            .map((step: IStep) => {
+              this.steps.push(step);
+              return step;
+            });
+
+          const stateMachine: StateMachine =
+            workflowStepsToStateMachine(stepList);
+          resolve(stateMachine);
+        } catch (e) {
+          reject(e);
+        }
+      },
+    );
+  }
+
+  /**
+   * attempts to associate previously used uuids with steps
+   * otherwise creates new ones
+   *
+   * @param steps
+   */
+  private attemptToRehydrateIdentifiers(
+    steps: Record<string, Step>,
+  ): Record<string, Step> {
+    const previousSteps: IStep[] = this.previousStateMachine
+      ? Object.values(this.previousStateMachine.stepMap)
+      : [];
+    const entries: Array<[key: string, step: Step]> = Object.entries(steps);
+    for (const [name, step] of entries) {
+      // set workflow id
+      step.setWorkflowId(this.id);
+
+      const previousStep: IStep | undefined = previousSteps.find(
+        (s: IStep) => s._migrations?.name === name,
+      );
+      if (previousStep) {
+        step.id = previousStep.id;
+        for (const key of Object.keys(previousStep._migrations ?? {})) {
+          step.setMigration(key, previousStep._migrations?.[key]);
+        }
+      } else {
+        step.id = v4();
+        step.setMigration('name', name);
+      }
+    }
+
+    return steps;
+  }
+
+  /**
+   * empties the steps array
+   */
+  private reset(): void {
+    while (this.steps.length) {
+      this.steps.pop();
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["./src"],
+  "compilerOptions": {
+    "composite": true,
+    "outDir": "./dist",
+    "baseUrl": "./"
+  }
+}

package/tsconfig.release.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.release.json",
+  "include": ["./src/"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "baseUrl": "./"
+  }
+}