@useparagon/cli 0.0.1-canary.1

package/src/codegen/codegens/source.codegen.ts

@@ -0,0 +1,193 @@
+import {
+  ConditionWrapper,
+  DataType,
+  KeyedSource,
+  OperatorCondition,
+  Source,
+  TokenizedSource,
+} from '@useparagon/core/resolvers';
+
+import { conditionToCode } from './condition.codegen';
+
+export const EMPTY_TOKENIZED_SOURCE: TokenizedSource<DataType.STRING> = {
+  type: 'TOKENIZED',
+  parts: [
+    {
+      dataType: DataType.STRING,
+      type: 'VALUE',
+      value: '',
+    },
+  ],
+};
+
+/**
+ * convert source to ts code
+ * @param source
+ * @param stepIdToVariableMap
+ * @returns
+ */
+export const convertSourceToCode = (
+  source: Source,
+  stepIdToVariableMap: Record<string, string>,
+  isTokenizedPart: boolean = false,
+): string => {
+  let value = '';
+
+  switch (source.type) {
+    case 'VALUE':
+      value = '"' + source.value + '"';
+      break;
+    case 'TOKENIZED':
+      value = source.parts.reduce((acc: string, currentSource: Source) => {
+        return `${acc}${convertSourceToCode(
+          currentSource,
+          stepIdToVariableMap,
+          true,
+        )}`;
+      }, '');
+
+      value = '`' + value + '`';
+      break;
+    case 'VARIABLE':
+      const sanitizedPaths: string[] = source.path.filter((path) =>
+        Boolean(path),
+      );
+
+      value = `context.getOutput(${stepIdToVariableMap[source.stepId]})${
+        sanitizedPaths.length ? `?.${sanitizedPaths.join('?.')}` : ''
+      }`;
+
+      if (isTokenizedPart) {
+        value = '${' + value + '}';
+      }
+      break;
+    case 'CONDITION':
+      const conditionWrapper: ConditionWrapper = source.condition;
+
+      // in paragon cloud top condition is `OR`
+      if (conditionWrapper.type !== 'JOIN' || conditionWrapper.join !== 'OR') {
+        return 'undefined';
+      }
+
+      const conditions: Array<OperatorCondition[]> = conditionWrapper.conditions
+        .map((condition) => {
+          if (condition.type === 'JOIN' && condition.join === 'AND') {
+            const andConditions: OperatorCondition[] =
+              condition.conditions as unknown as OperatorCondition[];
+            return andConditions;
+          }
+          return [];
+        })
+        .filter((conditions: OperatorCondition[]) => conditions.length);
+
+      /**
+       * convert conditions to code
+       * @param conditions
+       * @returns
+       */
+      const convertAndConditionsToCode = (
+        conditions: OperatorCondition[],
+        stepIdToVariableMap: Record<string, string>,
+      ) => {
+        return conditions.reduce(
+          (
+            accumulator: string,
+            condition: OperatorCondition,
+            index: number,
+          ) => {
+            const conditionCode: string = conditionToCode(
+              condition,
+              stepIdToVariableMap,
+            );
+            if (index === conditions.length - 1) {
+              return `${accumulator}${conditionCode}]`;
+            }
+            return `${accumulator}${conditionCode},`;
+          },
+          '[',
+        );
+      };
+
+      if (conditions.length === 1 && conditions[0].length === 1) {
+        // only add code for only one Condition
+        const condition: OperatorCondition = conditions[0][0];
+        value = conditionToCode(condition, stepIdToVariableMap);
+      } else if (conditions.length === 1) {
+        // add code for AND(...operators) condition type
+        const andConditions: OperatorCondition[] = conditions[0];
+        value = convertAndConditionsToCode(andConditions, stepIdToVariableMap);
+      } else {
+        // add code for OR(AND(...operators)) condition type
+        const orConditions: OperatorCondition[][] = conditions;
+        value = orConditions.reduce(
+          (
+            accumulator: string,
+            andConditions: OperatorCondition[],
+            index: number,
+          ) => {
+            const andConditionCode: string = convertAndConditionsToCode(
+              andConditions,
+              stepIdToVariableMap,
+            );
+            if (index === orConditions.length - 1) {
+              return `${accumulator}${andConditionCode}]`;
+            }
+            return `${accumulator}${andConditionCode},`;
+          },
+          '[',
+        );
+      }
+
+      break;
+    default:
+      throw new Error(`source type ${source.type} not implemented.`);
+  }
+  return value;
+};
+
+/**
+ * convert keyed source to code
+ * @param source
+ * @param stepIdToVariableMap
+ * @returns
+ */
+export const convertKeyedSourceToCode = (
+  source: KeyedSource,
+  stepIdToVariableMap: Record<string, string>,
+): [string, string] => {
+  return [source.key, convertSourceToCode(source.source, stepIdToVariableMap)];
+};
+
+/**
+ * convert keyed sources to their respective source code
+ * @param parameters
+ * @param stepIdToVariableMap
+ * @returns
+ */
+export const covertKeyedSourceParamsToCode = (
+  parameters: KeyedSource<DataType>[],
+  stepIdToVariableMap: Record<string, string>,
+): string => {
+  if (!parameters.length) {
+    return '{}';
+  }
+  const value: string = parameters.reduce(
+    (accumulator: string, keyedSource: KeyedSource, index: number) => {
+      const [key, value]: [string, string] = convertKeyedSourceToCode(
+        keyedSource,
+        stepIdToVariableMap,
+      );
+      if (index > 0) {
+        accumulator += ',';
+      }
+
+      if (index === parameters.length - 1) {
+        return `${accumulator}${key} : ${value}}`;
+      }
+      return `${accumulator}${key} : ${value}`;
+    },
+    '{',
+  );
+
+  return value;
+};

package/src/codegen/codegens/workflow.codegen.ts

@@ -0,0 +1,495 @@
+import { IStep, StepType } from '@useparagon/core';
+import { ConditionWrapper } from '@useparagon/core/resolvers';
+import { getCronOptions } from '@useparagon/core/triggers/cron';
+
+import { WorkflowOutput } from '../../compilers/compiler.types';
+import { stringifyObject } from '../../helpers/json';
+import logger from '../../logger';
+import { WorkflowDependencies } from '../codegen.types';
+import {
+  convertSourceToCode,
+  covertKeyedSourceParamsToCode,
+  EMPTY_TOKENIZED_SOURCE,
+} from './source.codegen';
+
+type StepParse = {
+  imports: string[];
+  varDeclarations: string[];
+  stepChains: string;
+};
+
+/**
+ * get source code for workflow
+ * @param event
+ * @returns
+ */
+export const workflowToCode = (
+  workflowBuild: WorkflowOutput,
+  dependencies: WorkflowDependencies,
+): string => {
+  const { id: workflowId, name: workflowName, stateMachine } = workflowBuild;
+  const startStepId: string | undefined =
+    stateMachine.sequenceMap[stateMachine.start].start;
+  if (!startStepId) {
+    logger.fatal(`Workflow ${workflowName} with no start step id.`);
+    return '';
+  }
+
+  const stepIdToVariableMap: Record<string, string> = {};
+  const imports: string[] = [
+    'import { IContext} from "@useparagon/core/execution";',
+    'import { Workflow, ActionStep, CronStep, DelayStep, EventStep, FunctionStep, ConditionalStep, FanOutStep, ResponseStep, RequestStep, IntegrationEnabledStep} from "@useparagon/core";',
+    'import * as Operators from "@useparagon/core/operator";',
+  ];
+
+  const statements: string[] = [];
+
+  const stepCode: StepParse = getStepCodeParts(
+    startStepId,
+    stateMachine.stepMap,
+    stepIdToVariableMap,
+    dependencies,
+  );
+
+  // removing duplicate imports as well
+  imports.push(...new Set(stepCode.imports));
+  statements.push(...stepCode.varDeclarations);
+
+  const sourceCode: string = `
+    ${imports.join('\n')}
+
+    /**
+    *  ${workflowName} Workflow impolementation
+    */
+    export default class extends Workflow<any> {
+        /**
+         * This property is maintained by Paragon. Do not edit this property.
+         */
+        readonly id: '${workflowId}'     
+
+        /**
+         * defines the workflow
+         * @param integration
+         * @param context
+         * @param user
+         */
+        define(_integration: any, context: IContext) {
+
+        /**
+         * declare all steps here
+         */
+        ${statements.join('\n')}
+
+        /**
+         * chain steps correctly here
+         */
+        ${stepCode.stepChains}
+
+        /**
+         * pass all steps here so that paragon can keep track of changes
+         */
+        return this.register({ ${Object.values(stepIdToVariableMap).join(
+          ', ',
+        )} });
+        }
+    }
+`;
+
+  return sourceCode;
+};
+
+/**
+ * get code parts for steps
+ * @param startStepId
+ * @param stepMap
+ * @param stepIdToVariableMap
+ * @returns
+ */
+const getStepCodeParts = (
+  startStepId: string,
+  stepMap: Record<string, IStep>,
+  stepIdToVariableMap: Record<string, string>,
+  dependencies: WorkflowDependencies,
+): StepParse => {
+  const imports: string[] = [];
+  const varDeclarations: string[] = [];
+
+  let stepChains: string = '';
+
+  let currentStep: IStep | undefined = stepMap[startStepId];
+
+  let stepCount: number = 1;
+
+  const totalKeys: number = Object.values(stepIdToVariableMap).length;
+  const prefix: string = totalKeys ? `${totalKeys}_` : '';
+
+  const variableChains: string[] = [];
+
+  while (currentStep != undefined) {
+    const variableName: string = (currentStep._migrations?.['name'] ||
+      `step${prefix}${stepCount}`) as string;
+
+    stepIdToVariableMap[currentStep!.id] = variableName;
+
+    const stepCode = getStepCodePart(
+      currentStep!,
+      stepIdToVariableMap,
+      stepMap,
+      dependencies,
+    );
+
+    imports.push(...stepCode.imports);
+    varDeclarations.push(...stepCode.varDeclarations);
+
+    if (stepCode.stepChains.trim()) {
+      variableChains.push(`
+              ${variableName}.${stepCode.stepChains}
+            `);
+    } else {
+      variableChains.push(variableName);
+    }
+
+    const nextStepId = currentStep.next;
+    currentStep = undefined;
+
+    if (nextStepId) {
+      currentStep = stepMap[nextStepId];
+    }
+    stepCount += 1;
+  }
+
+  if (variableChains.length) {
+    stepChains = `
+            ${variableChains
+              .map((currentName: string, index: number) => {
+                if (index > 0) {
+                  return `${currentName})`;
+                }
+                return currentName;
+              })
+              .join('.nextStep(')}
+            
+          `;
+  }
+
+  return {
+    imports,
+    varDeclarations,
+    stepChains,
+  };
+};
+
+/**
+ * get statemenets and imorts statements for particular step
+ * @param step
+ * @returns
+ */
+const getStepCodePart = (
+  step: IStep,
+  stepIdToVariableMap: Record<string, string>,
+  stepMap: Record<string, IStep>,
+  dependencies: WorkflowDependencies,
+): StepParse => {
+  const varDeclarations: string[] = [];
+  const imports: string[] = [];
+
+  let stepChains: string = '';
+
+  switch (step.type) {
+    case StepType.ACTION:
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }:ActionStep = new ActionStep({
+                actionType : ${step.parameters.actionType},
+                intent : ${step.parameters.intent},
+                parameters : ${covertKeyedSourceParamsToCode(
+                  step.parameters.actionParameters,
+                  stepIdToVariableMap,
+                )}
+              });
+            `);
+
+      break;
+    // case StepType.ACTION_TRIGGER:
+    //   break;
+    case StepType.CRON:
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }:CronStep = new CronStep(${stringifyObject(
+        getCronOptions(step.parameters.schedule),
+      )});
+            `);
+      break;
+    case StepType.CUSTOM_INTEGRATION_REQUEST:
+      const requestBodyType: string = step.parameters.bodyType ?? 'json';
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }: RequestStep = new RequestStep({
+                path: ${convertSourceToCode(
+                  step.parameters.url,
+                  stepIdToVariableMap,
+                )},
+                params:${covertKeyedSourceParamsToCode(
+                  step.parameters.params,
+                  stepIdToVariableMap,
+                )},
+                headers:${covertKeyedSourceParamsToCode(
+                  step.parameters.params,
+                  stepIdToVariableMap,
+                )},
+                body:${
+                  ['xml', 'raw'].includes(requestBodyType)
+                    ? convertSourceToCode(
+                        step.parameters.rawBody || EMPTY_TOKENIZED_SOURCE,
+                        stepIdToVariableMap,
+                      )
+                    : covertKeyedSourceParamsToCode(
+                        step.parameters.body,
+                        stepIdToVariableMap,
+                      )
+                },
+                ${step.parameters.pagination ? '' : ''}
+              });
+            `);
+      break;
+    case StepType.DELAY:
+      varDeclarations.push(`
+              const ${stepIdToVariableMap[step.id]}:DelayStep = new DelayStep({
+        unit: '${step.parameters.unit}',
+        value: ${convertSourceToCode(
+          step.parameters.value,
+          stepIdToVariableMap,
+        )},
+      });
+            `);
+      break;
+    case StepType.ENDPOINT:
+      varDeclarations.push(`
+        const ${stepIdToVariableMap[step.id]}:EndpointStep = new EndpointStep({
+          allowArbitraryPayload : ${step.parameters.allowArbitraryPayload},
+          ${
+            step.parameters.allowArbitraryPayload
+              ? ''
+              : `
+            paramValidations:${stringifyObject(
+              step.parameters.paramValidations,
+            )},
+            headerValidations:${stringifyObject(
+              step.parameters.headerValidations,
+            )},
+            bodyValidations:${stringifyObject(step.parameters.bodyValidations)}
+          `
+          }
+        });
+      `);
+      break;
+    case StepType.EVENT:
+      const eventName: string =
+        dependencies.events[step.parameters.eventId].name;
+
+      imports.push(...[`import event from '../../../events/${eventName}';`]);
+
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }:EventStep = new EventStep(event);
+            `);
+      break;
+    case StepType.FUNCTION:
+      const paramsCode: string = covertKeyedSourceParamsToCode(
+        step.parameters.parameters,
+        stepIdToVariableMap,
+      );
+
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }:FunctionStep = new FunctionStep({
+                code: ${step.parameters.code},
+                parameters: ${paramsCode}
+              });
+            `);
+      break;
+    case StepType.IFELSE:
+      const ifStepId: string | null | undefined = step.parameters.choices.find(
+        (choice) => choice.label === 'Yes',
+      )?.next;
+      const elseStepId: string | null | undefined =
+        step.parameters.choices.find((choice) => choice.label === 'No')?.next;
+
+      if (ifStepId) {
+        const {
+          imports: nextIterateImports,
+          varDeclarations: nextIterateVarDeclartions,
+          stepChains: nextIterationStepChains,
+        }: StepParse = getStepCodeParts(
+          ifStepId,
+          stepMap,
+          stepIdToVariableMap,
+          dependencies,
+        );
+
+        imports.push(...nextIterateImports);
+        varDeclarations.push(...nextIterateVarDeclartions);
+        stepChains += `whenTrue(${nextIterationStepChains})`;
+      }
+
+      if (elseStepId) {
+        const {
+          imports: nextIterateImports,
+          varDeclarations: nextIterateVarDeclartions,
+          stepChains: nextIterationStepChains,
+        }: StepParse = getStepCodeParts(
+          elseStepId,
+          stepMap,
+          stepIdToVariableMap,
+          dependencies,
+        );
+
+        imports.push(...nextIterateImports);
+        varDeclarations.push(...nextIterateVarDeclartions);
+
+        stepChains += ifStepId
+          ? `.whenFalse(${nextIterationStepChains})`
+          : `whenFalse(${nextIterationStepChains})`;
+      }
+
+      const ifCondition: ConditionWrapper | undefined =
+        step.parameters.choices.find(
+          (choice) => choice.label === 'Yes',
+        )?.conditionWrapper;
+
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }:ConditionalStep = new ConditionalStep({
+                if : ${
+                  !ifCondition
+                    ? 'undefined'
+                    : convertSourceToCode(
+                        {
+                          type: 'CONDITION',
+                          condition: ifCondition,
+                        },
+                        stepIdToVariableMap,
+                      )
+                }
+              });
+            `);
+      break;
+    case StepType.INTEGRATION_ENABLED:
+      varDeclarations.push(`
+      const ${
+        stepIdToVariableMap[step.id]
+      }:IntegrationEnabledStep = new IntegrationEnabledStep({});
+      `);
+      break;
+    case StepType.MAP:
+      let nextStepId: string | null | undefined = step.parameters.nextToIterate;
+
+      if (nextStepId) {
+        const {
+          imports: nextIterateImports,
+          varDeclarations: nextIterateVarDeclartions,
+          stepChains: nextIterationStepChains,
+        }: StepParse = getStepCodeParts(
+          nextStepId,
+          stepMap,
+          stepIdToVariableMap,
+          dependencies,
+        );
+
+        imports.push(...nextIterateImports);
+        varDeclarations.push(...nextIterateVarDeclartions);
+
+        stepChains = `branch(${nextIterationStepChains})`;
+      }
+
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }:FanOutStep = new FanOutStep({
+                iterator : ${convertSourceToCode(
+                  step.parameters.iterator,
+                  stepIdToVariableMap,
+                )},
+              });
+            `);
+      break;
+    case StepType.RESPONSE:
+      const responseType: string = step.parameters.responseType ?? 'JSON';
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }: ResponseStep = new ResponseStep({
+                statusCode:${step.parameters.statusCode},
+                responseType:"${responseType}",
+                body: ${
+                  responseType === 'FILE'
+                    ? step.parameters.bodyFile
+                      ? convertSourceToCode(
+                          step.parameters.bodyFile || EMPTY_TOKENIZED_SOURCE,
+                          stepIdToVariableMap,
+                        )
+                      : '""'
+                    : covertKeyedSourceParamsToCode(
+                        step.parameters.bodyData,
+                        stepIdToVariableMap,
+                      )
+                }
+              });
+            `);
+      break;
+    case StepType.REQUEST:
+      const bodyType: string = step.parameters.bodyType ?? 'json';
+      varDeclarations.push(`
+              const ${
+                stepIdToVariableMap[step.id]
+              }: RequestStep = new RequestStep({
+                url: ${convertSourceToCode(
+                  step.parameters.url,
+                  stepIdToVariableMap,
+                )},
+                method:"${step.parameters.httpMethod}",
+                params:${covertKeyedSourceParamsToCode(
+                  step.parameters.params,
+                  stepIdToVariableMap,
+                )},
+                headers:${covertKeyedSourceParamsToCode(
+                  step.parameters.params,
+                  stepIdToVariableMap,
+                )},
+                ${
+                  step.parameters.httpMethod === 'GET'
+                    ? ''
+                    : `
+                body:${
+                  ['xml', 'raw'].includes(bodyType)
+                    ? convertSourceToCode(
+                        step.parameters.rawBody || EMPTY_TOKENIZED_SOURCE,
+                        stepIdToVariableMap,
+                      )
+                    : covertKeyedSourceParamsToCode(
+                        step.parameters.body,
+                        stepIdToVariableMap,
+                      )
+                }`
+                }
+              });
+            `);
+      break;
+    // case StepType.UNSELECTED_TRIGGER:
+    //   break;
+    default:
+      logger.fatal(`Invalid step type "${step['type']}`);
+  }
+
+  return {
+    imports,
+    varDeclarations,
+    stepChains,
+  };
+};