@useparagon/core 0.0.1-canary.1

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

@@ -0,0 +1,69 @@
+import { KeyedSource } from '../../../resolvers/resolvers.interface';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../../step.interface-base';
+
+/**
+ * parameters used for initializing a FunctionStep
+ */
+export interface IFunctionStepParameters extends IBaseStepParameters {
+  /**
+   * the code executed within the function
+   */
+  code: string;
+
+  /**
+   * parameters passed to the function
+   */
+  parameters: KeyedSource[];
+
+  /**
+   * whether or not to retry on failure
+   */
+  retryOnFailure?: boolean;
+}
+
+/**
+ * parameters used to initialize a function step
+ */
+export interface IFunctionStepInit<
+  P extends Record<string, unknown> = Record<string, unknown>,
+> extends IBaseStepParameters {
+  /**
+   * the code executed within the function
+   * @param parameters variables passed to the function
+   * @param libraries npm libraries
+   * @returns
+   */
+  code: (
+    parameters: P,
+    libraries: Record<string, unknown>,
+  ) => any | Promise<any>;
+
+  /**
+   * parameters passed to the function
+   */
+  parameters: P;
+
+  /**
+   * whether or not to retry on failure
+   */
+  retryOnFailure?: boolean;
+}
+
+/**
+ * a step used for sending responses to HTTP requests
+ */
+export interface IFunctionStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.FUNCTION;
+
+  /**
+   * configuration for the function step
+   */
+  parameters: IFunctionStepParameters;
+}

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

@@ -0,0 +1,55 @@
+import { resolveParamsToSources } from '../../../resolvers/resolver.utils';
+import { Step } from '../../step';
+import { StepType } from '../../step.interface';
+import {
+  IFunctionStep,
+  IFunctionStepInit,
+  IFunctionStepParameters,
+} from './function.interface';
+
+/**
+ * a step used for executiong custom Node.js code
+ */
+export class FunctionStep<
+    P extends Record<string, unknown> = Record<string, unknown>,
+  >
+  extends Step<IFunctionStepInit<P>, IFunctionStepParameters>
+  implements IFunctionStep
+{
+  /**
+   * the step type
+   *
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.FUNCTION = StepType.FUNCTION;
+
+  /**
+   * configuration for the function step
+   */
+  parameters: IFunctionStepParameters;
+
+  /**
+   * initialization parameters
+   */
+  private _parameters: IFunctionStepInit<P>;
+
+  constructor(params: IFunctionStepInit<P>) {
+    super(params);
+    this._parameters = params;
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IFunctionStepParameters {
+    const functionParameters = this._parameters.parameters;
+
+    return {
+      ...this._parameters,
+      parameters: resolveParamsToSources(functionParameters),
+      code: this._parameters.code.toString(),
+    };
+  }
+}

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

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

package/src/steps/library/index.ts

@@ -0,0 +1,7 @@
+export * from './action/action.step';
+export * from './conditional/conditional.step';
+export * from './fanout/fanout.step';
+export * from './function/function.step';
+export * from './request/request.step';
+export * from './response/response.step';
+export * from './integrationRequest/integrationRequest.step';

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

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

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

@@ -0,0 +1,79 @@
+import {
+  DataType,
+  OrConditions,
+  TokenizedSource,
+} from '../../../resolvers/resolvers.interface';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../../step.interface-base';
+import { ConditionalInput } from '../conditional/conditional.interface';
+import {
+  HttpMethod,
+  IRequestStepParameters,
+} from '../request/request.interface';
+
+/**
+ * parameters for initializing request step
+ */
+export type IIntegrationRequestStepInit = IBaseStepParameters & {
+  path: string;
+  method: keyof typeof HttpMethod;
+  params?: Record<string, string>;
+  headers?: Record<string, string>;
+  pagination?: {
+    stopCondition: ConditionalInput;
+    outputPath: string;
+    pageToken: string;
+  };
+} & (
+    | {
+        /**
+         * Specify the kind of format that the `body` object should be transmitted in. Affects the
+         * Content-Type header, if it isn't already set.
+         */
+        bodyType?: 'json' | 'form-data' | 'x-www-form-urlencoded';
+        body?: Record<string, unknown>;
+      }
+    | {
+        bodyType?: 'xml' | 'raw';
+        body?: string;
+      }
+  );
+
+/**
+ * pagination options for integration
+ */
+export type PaginationOptions = Partial<{
+  enabled: boolean;
+  type: 'TOKEN';
+  output: TokenizedSource<DataType.STRING | DataType.ANY>;
+  pageToken: TokenizedSource<DataType.STRING>;
+  stopCondition: OrConditions;
+}>;
+
+/**
+ * parameters used for initializing a RequestStep
+ */
+export interface IIntegrationRequestStepParameters
+  extends IRequestStepParameters {
+  paginations?: PaginationOptions;
+
+  actionType: string;
+}
+
+/**
+ * a step used for making HTTP requests in integration
+ */
+export interface IIntegrationRequestStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.CUSTOM_INTEGRATION_REQUEST;
+
+  /**
+   * configuration for the request step
+   */
+  parameters: IIntegrationRequestStepParameters;
+}

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

@@ -0,0 +1,100 @@
+import {
+  resolveParamsToSources,
+  resolveToSource,
+} from '../../../resolvers/resolver.utils';
+import {
+  DataType,
+  OrConditions,
+  TokenizedSource,
+} from '../../../resolvers/resolvers.interface';
+import { Step } from '../../step';
+import { StepType } from '../../step.interface';
+import { HttpMethod, RequestBodyType } from '../request/request.interface';
+import {
+  IIntegrationRequestStepInit,
+  IIntegrationRequestStepParameters,
+  IIntegrationRequestStep,
+} from './integrationRequest.interface';
+
+/**
+ * a step used for making HTTP requests in integaration
+ */
+export class IntegrationRequestStep
+  extends Step
+  implements IIntegrationRequestStep
+{
+  /**
+   * the step type
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.CUSTOM_INTEGRATION_REQUEST =
+    StepType.CUSTOM_INTEGRATION_REQUEST;
+
+  /**
+   * initialization parameters
+   */
+  private _parameters: IIntegrationRequestStepInit;
+
+  /**
+   * configuraiton for the integration request step
+   */
+  parameters: IIntegrationRequestStepParameters;
+
+  constructor(params: IIntegrationRequestStepInit) {
+    super(params);
+    this._parameters = params;
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IIntegrationRequestStepParameters {
+    const initParams: IIntegrationRequestStepInit = this._parameters;
+
+    return {
+      actionType: 'pipedrive',
+      bodyType: initParams.bodyType as RequestBodyType,
+      httpMethod: initParams.method as HttpMethod,
+      url: resolveToSource(
+        initParams.url,
+        DataType.STRING,
+      ) as TokenizedSource<DataType.STRING>,
+      params: resolveParamsToSources(initParams.params || {}, DataType.STRING),
+      headers: resolveParamsToSources(
+        initParams.headers || {},
+        DataType.STRING,
+      ),
+      body:
+        typeof initParams.body === 'string'
+          ? []
+          : resolveParamsToSources(initParams.body || {}, DataType.STRING),
+      rawBody:
+        typeof initParams.body === 'string'
+          ? (resolveToSource(
+              initParams.body || '',
+              DataType.STRING,
+            ) as TokenizedSource<DataType.STRING>)
+          : undefined,
+      paginations: initParams.pagination
+        ? {
+            enabled: true,
+            type: 'TOKEN',
+            output: resolveToSource(
+              initParams.pagination.outputPath,
+              DataType.ANY,
+            ) as TokenizedSource<DataType.STRING | DataType.ANY>,
+            pageToken: resolveToSource(
+              initParams.pagination.pageToken,
+              DataType.ANY,
+            ) as TokenizedSource<DataType.STRING>,
+            stopCondition: resolveToSource(
+              initParams.pagination.stopCondition,
+              DataType.ANY,
+            )['condition'] as OrConditions,
+          }
+        : undefined,
+    };
+  }
+}

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

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

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

@@ -0,0 +1,159 @@
+import {
+  DataType,
+  KeyedSource,
+  TokenizedSource,
+} from '../../../resolvers/resolvers.interface';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../../step.interface-base';
+
+/**
+ * methods for HTTP requests
+ */
+export enum HttpMethod {
+  GET = 'GET',
+  POST = 'POST',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
+  DELETE = 'DELETE',
+}
+
+/**
+ * request body type
+ */
+export enum RequestBodyType {
+  JSON = 'json',
+  FORM_DATA = 'form-data',
+  X_WWW_FORM_URLENCODED = 'x-www-form-urlencoded',
+  XML = 'xml',
+  RAW = 'raw',
+}
+
+/**
+ * Specify the kind of request authorization that this request should use. Affects the
+ * Authorization header value.
+ */
+export enum RequestAuthorizationType {
+  NONE = 'none',
+  BEARER_TOKEN = 'bearer',
+  BASIC = 'basic',
+  QUERY_PARAMS = 'query_params',
+  AUTH_HEADER = 'auth_header',
+}
+
+type NoAuthorization = {
+  type: RequestAuthorizationType.NONE;
+};
+
+type BearerAuthorization = {
+  type: RequestAuthorizationType.BEARER_TOKEN;
+  token: TokenizedSource<DataType.STRING>;
+};
+
+type BasicAuthorization = {
+  type: RequestAuthorizationType.BASIC;
+  username: TokenizedSource<DataType.STRING>;
+  password: TokenizedSource<DataType.STRING>;
+};
+
+type QueryParamAuthorization = {
+  type: RequestAuthorizationType.QUERY_PARAMS;
+  params: KeyedSource<DataType.STRING>[];
+};
+
+type AuthHeaderAuthorization = {
+  type: RequestAuthorizationType.AUTH_HEADER;
+  headers: KeyedSource<DataType.STRING>[];
+};
+
+/**
+ * parameters for initializing request step
+ */
+export type IRequestStepInit = IBaseStepParameters & {
+  url: string;
+  method: keyof typeof HttpMethod;
+  params?: Record<string, string>;
+  headers?: Record<string, string>;
+  /**
+   * An object to represent Authorization options in a request step
+   */
+  authorization?:
+    | {
+        type: 'basic';
+        username: string;
+        password: string;
+      }
+    | {
+        type: 'bearer';
+        token: string;
+      };
+} & (
+    | {
+        /**
+         * Specify the kind of format that the `body` object should be transmitted in. Affects the
+         * Content-Type header, if it isn't already set.
+         */
+        bodyType?: 'json' | 'form-data' | 'x-www-form-urlencoded';
+        body?: Record<string, unknown>;
+      }
+    | {
+        bodyType?: 'xml' | 'raw';
+        body?: string;
+      }
+  );
+
+export type RequestAuthorization =
+  | NoAuthorization
+  | BearerAuthorization
+  | BasicAuthorization
+  | QueryParamAuthorization
+  | AuthHeaderAuthorization;
+
+/**
+ * parameters used for initializing a RequestStep
+ */
+export interface IRequestStepParameters extends IBaseStepParameters {
+  url: TokenizedSource<DataType.STRING>;
+  httpMethod: HttpMethod;
+  params: KeyedSource<DataType.STRING>[];
+  headers: KeyedSource<DataType.STRING>[];
+  body: KeyedSource[];
+
+  /**
+   * Specify the kind of format that the `body` object should be transmitted in. Affects the
+   * Content-Type header, if it isn't already set.
+   */
+  bodyType?: RequestBodyType;
+
+  /**
+   * If a bodyType is RequestBodyType.RAW, rawBody represents the raw contents to pass through
+   * to the body of the request.
+   * @since PARA-1969
+   */
+  rawBody?: TokenizedSource<DataType.STRING>;
+
+  /**
+   * An object to represent Authorization options in a request step.
+   * - For Basic-type auth, "username" and "password" keys should appear in
+   * this object.
+   * - For Bearer-type auth, a "token" key should appear in this object.
+   */
+  authorization?: RequestAuthorization;
+}
+
+/**
+ * a step used for making HTTP requests
+ */
+export interface IRequestStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.REQUEST;
+
+  /**
+   * configuration for the request step
+   */
+  parameters: IRequestStepParameters;
+}

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

@@ -0,0 +1,117 @@
+import {
+  resolveParamsToSources,
+  resolveToSource,
+} from '../../../resolvers/resolver.utils';
+import {
+  DataType,
+  TokenizedSource,
+} from '../../../resolvers/resolvers.interface';
+import { Step } from '../../step';
+import { StepType } from '../../step.interface';
+import {
+  HttpMethod,
+  IRequestStep,
+  IRequestStepInit,
+  IRequestStepParameters,
+  RequestAuthorization,
+  RequestAuthorizationType,
+  RequestBodyType,
+} from './request.interface';
+
+/**
+ * a step used for making HTTP requests
+ */
+export class RequestStep extends Step implements IRequestStep {
+  /**
+   * the step type
+   * @type {StepType}
+   * @memberof Step
+   */
+  type: StepType.REQUEST = StepType.REQUEST;
+
+  /**
+   * initialization parameters
+   * @type {IRequestStepInit}
+   * @memberof RequestStep
+   */
+  private _parameters: IRequestStepInit;
+
+  /**
+   * configuraiton for the request step
+   *
+   * @type {IRequestStepParameters}
+   * @memberof RequestStep
+   */
+  parameters: IRequestStepParameters;
+
+  constructor(params: IRequestStepInit) {
+    super(params);
+    this._parameters = params;
+    this.parameters = this.serializeParameters();
+  }
+
+  /**
+   * serialize parameters for storage
+   */
+  serializeParameters(): IRequestStepParameters {
+    const initParams: IRequestStepInit = this._parameters;
+
+    let authorization: RequestAuthorization | undefined;
+    if (initParams.authorization) {
+      switch (initParams.authorization.type) {
+        case 'basic':
+          authorization = {
+            type: RequestAuthorizationType.BASIC,
+            username: resolveToSource(
+              initParams.authorization.username,
+              DataType.STRING,
+            ) as TokenizedSource<DataType.STRING>,
+            password: resolveToSource(
+              initParams.authorization.password,
+              DataType.STRING,
+            ) as TokenizedSource<DataType.STRING>,
+          };
+          break;
+        case 'bearer':
+          authorization = {
+            type: RequestAuthorizationType.BEARER_TOKEN,
+            token: resolveToSource(
+              initParams.authorization.token,
+              DataType.STRING,
+            ) as TokenizedSource<DataType.STRING>,
+          };
+          break;
+        default:
+          throw new Error(
+            `unknown authorization type (${initParams.authorization['type']}) passed for request step.`,
+          );
+      }
+    }
+
+    return {
+      bodyType: initParams.bodyType as RequestBodyType,
+      httpMethod: initParams.method as HttpMethod,
+      url: resolveToSource(
+        initParams.url,
+        DataType.STRING,
+      ) as TokenizedSource<DataType.STRING>,
+      params: resolveParamsToSources(initParams.params || {}, DataType.STRING),
+      headers: resolveParamsToSources(
+        initParams.headers || {},
+        DataType.STRING,
+      ),
+      body:
+        typeof initParams.body === 'string'
+          ? []
+          : resolveParamsToSources(initParams.body || {}, DataType.STRING),
+      rawBody:
+        typeof initParams.body === 'string'
+          ? (resolveToSource(
+              initParams.body || '',
+              DataType.STRING,
+            ) as TokenizedSource<DataType.STRING>)
+          : undefined,
+      authorization,
+    };
+  }
+}

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

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

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

@@ -0,0 +1,50 @@
+import {
+  DataType,
+  TokenizedSource,
+  KeyedSource,
+} from '../../../resolvers/resolvers.interface';
+import {
+  IBaseStep,
+  IBaseStepParameters,
+  StepType,
+} from '../../step.interface-base';
+
+export enum ResponseTypeEnum {
+  JSON = 'JSON',
+  FILE = 'FILE',
+}
+
+/**
+ * parameters used for initializing a ResponseStep
+ */
+export type IResponseStepInit = IBaseStepParameters & {
+  statusCode: number;
+} & (
+    | { responseType: 'FILE'; body: unknown }
+    | { responseType: 'JSON'; body: Record<string, unknown> }
+  );
+
+/**
+ * parameters used for initializing a ResponseStep
+ */
+export interface IResponseStepParameters extends IBaseStepParameters {
+  statusCode: number;
+  responseType?: ResponseTypeEnum;
+  bodyData: KeyedSource[];
+  bodyFile?: TokenizedSource<DataType.FILE>;
+}
+
+/**
+ * a step used for sending responses to HTTP requests
+ */
+export interface IResponseStep extends IBaseStep {
+  /**
+   * the step type
+   */
+  type: StepType.RESPONSE;
+
+  /**
+   * configuration for the response step
+   */
+  parameters: IResponseStepParameters;
+}