ts2workflows 0.4.0 → 0.6.0

package/dist/transpiler/statements.js

@@ -2,18 +2,18 @@ import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import { AssignStepAST, CallStepAST, ForStepAST, JumpTargetAST, NextStepAST, ParallelStepAST, RaiseStepAST, ReturnStepAST, StepsStepAST, SwitchStepAST, TryStepAST, } from '../ast/steps.js';
 import { BinaryExpression, FunctionInvocationExpression, PrimitiveExpression, VariableReferenceExpression, isExpression, isFullyQualifiedName, isLiteral, } from '../ast/expressions.js';
 import { InternalTranspilingError, WorkflowSyntaxError } from '../errors.js';
-import { isRecord } from '../utils.js';
+import { flatMapPair, isRecord, mapRecordValues } from '../utils.js';
 import { transformAST } from './transformations.js';
-import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, isMagicFunction, throwIfSpread, } from './expressions.js';
+import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, isMagicFunction, throwIfSpread, isMagicFunctionStatmentOnly, asExpression, } from './expressions.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
 export function parseStatement(node, ctx, postSteps) {
-    const steps = parseStatementRecursively(node, ctx);
+    const steps = parseStatementRecursively(node, undefined, ctx);
     return transformAST(steps.concat(postSteps ?? []));
 }
-function parseStatementRecursively(node, ctx) {
+function parseStatementRecursively(node, nextNode, ctx) {
     switch (node.type) {
         case AST_NODE_TYPES.BlockStatement:
-            return node.body.flatMap((statement) => parseStatementRecursively(statement, ctx));
+            return flatMapPair(node.body, (statement, nextStatement) => parseStatementRecursively(statement, nextStatement, ctx));
         case AST_NODE_TYPES.VariableDeclaration:
             return convertVariableDeclarations(node.declarations, ctx);
         case AST_NODE_TYPES.ExpressionStatement:
@@ -21,13 +21,13 @@ function parseStatementRecursively(node, ctx) {
                 return assignmentExpressionToSteps(node.expression, ctx);
             }
             else if (node.expression.type === AST_NODE_TYPES.CallExpression) {
-                return [callExpressionToStep(node.expression, undefined, ctx)];
+                return callExpressionToStep(node.expression, undefined, ctx);
             }
             else {
                 return [generalExpressionToAssignStep(node.expression)];
             }
         case AST_NODE_TYPES.ReturnStatement:
-            return [returnStatementToReturnStep(node)];
+            return [returnStatementToReturnStep(node, ctx)];
         case AST_NODE_TYPES.ThrowStatement:
             return [throwStatementToRaiseStep(node)];
         case AST_NODE_TYPES.IfStatement:
@@ -46,8 +46,14 @@ function parseStatementRecursively(node, ctx) {
             return [breakStatementToNextStep(node, ctx)];
         case AST_NODE_TYPES.ContinueStatement:
             return [continueStatementToNextStep(node, ctx)];
-        case AST_NODE_TYPES.TryStatement:
-            return [tryStatementToTryStep(node, ctx)];
+        case AST_NODE_TYPES.TryStatement: {
+            let retryPolicy = undefined;
+            if (nextNode?.type === AST_NODE_TYPES.ExpressionStatement &&
+                nextNode.expression.type === AST_NODE_TYPES.CallExpression) {
+                retryPolicy = parseRetryPolicy(nextNode.expression);
+            }
+            return tryStatementToTrySteps(node, retryPolicy, ctx);
+        }
         case AST_NODE_TYPES.LabeledStatement:
             return labeledStep(node, ctx);
         case AST_NODE_TYPES.EmptyStatement:
@@ -64,22 +70,25 @@ function parseStatementRecursively(node, ctx) {
     }
 }
 function convertVariableDeclarations(declarations, ctx) {
-    return declarations.map((decl) => {
-        if (decl.type !== AST_NODE_TYPES.VariableDeclarator) {
-            throw new WorkflowSyntaxError('Not a VariableDeclarator', decl.loc);
-        }
+    return declarations.flatMap((decl) => {
         if (decl.id.type !== AST_NODE_TYPES.Identifier) {
             throw new WorkflowSyntaxError('Expected Identifier', decl.loc);
         }
         const targetName = decl.id.name;
         if (decl.init?.type === AST_NODE_TYPES.CallExpression) {
+            const calleeName = decl.init.callee.type === AST_NODE_TYPES.Identifier
+                ? decl.init.callee.name
+                : undefined;
+            if (calleeName && isMagicFunctionStatmentOnly(calleeName)) {
+                throw new WorkflowSyntaxError(`"${calleeName}" can't be called as part of an expression`, decl.init.callee.loc);
+            }
             return callExpressionToStep(decl.init, targetName, ctx);
         }
         else {
             const value = decl.init == null
                 ? new PrimitiveExpression(null)
                 : convertExpression(decl.init);
-            return new AssignStepAST([[targetName, value]]);
+            return [new AssignStepAST([[targetName, value]])];
         }
     });
 }
@@ -123,10 +132,14 @@ function assignmentExpressionToSteps(node, ctx) {
     if (node.right.type === AST_NODE_TYPES.CallExpression &&
         node.right.callee.type === AST_NODE_TYPES.Identifier &&
         isMagicFunction(node.right.callee.name)) {
+        const calleeName = node.right.callee.name;
+        if (isMagicFunctionStatmentOnly(calleeName)) {
+            throw new WorkflowSyntaxError(`"${calleeName}" can't be called as part of an expression`, node.right.callee.loc);
+        }
         const needsTempVariable = compoundOperator === undefined ||
             node.left.type !== AST_NODE_TYPES.Identifier;
         const resultVariable = needsTempVariable ? '__temp' : targetName;
-        steps.push(callExpressionToStep(node.right, resultVariable, ctx));
+        steps.push(...callExpressionToStep(node.right, resultVariable, ctx));
         if (!needsTempVariable) {
             return steps;
         }
@@ -147,20 +160,25 @@ function callExpressionToStep(node, resultVariable, ctx) {
         const calleeName = calleeExpression.toString();
         if (calleeName === 'parallel') {
             // A custom implementation for "parallel"
-            return callExpressionToParallelStep(node, ctx);
+            return [callExpressionToParallelStep(node, ctx)];
         }
         else if (calleeName === 'retry_policy') {
-            return callExpressionToCallStep(calleeName, node.arguments, resultVariable);
+            // retry_policy() is handled by AST_NODE_TYPES.TryStatement and therefore ignored here
+            return [];
         }
         else if (calleeName === 'call_step') {
-            return createCallStep(node.arguments, resultVariable);
+            return [createCallStep(node, node.arguments, resultVariable)];
         }
         else if (blockingFunctions.has(calleeName)) {
             const argumentNames = blockingFunctions.get(calleeName) ?? [];
-            return blockingFunctionCallStep(calleeName, argumentNames, node.arguments, resultVariable);
+            return [
+                blockingFunctionCallStep(calleeName, argumentNames, node.arguments, resultVariable),
+            ];
         }
         else {
-            return callExpressionAssignStep(calleeName, node.arguments, resultVariable);
+            return [
+                callExpressionAssignStep(calleeName, node.arguments, resultVariable),
+            ];
         }
     }
     else {
@@ -176,17 +194,9 @@ function callExpressionAssignStep(functionName, argumentsNode, resultVariable) {
         ],
     ]);
 }
-function callExpressionToCallStep(functionName, argumentsNode, resultVariable) {
-    if (argumentsNode.length < 1 ||
-        argumentsNode[0].type !== AST_NODE_TYPES.ObjectExpression) {
-        throw new WorkflowSyntaxError('Expected one object parameter', argumentsNode[0].loc);
-    }
-    const workflowArguments = convertObjectAsExpressionValues(argumentsNode[0]);
-    return new CallStepAST(functionName, workflowArguments, resultVariable);
-}
-function createCallStep(argumentsNode, resultVariable) {
+function createCallStep(node, argumentsNode, resultVariable) {
     if (argumentsNode.length < 1) {
-        throw new WorkflowSyntaxError('The first argument must be a Function', argumentsNode[0].loc);
+        throw new WorkflowSyntaxError('The first argument must be a Function', node.loc);
     }
     let functionName;
     if (argumentsNode[0].type === AST_NODE_TYPES.Identifier) {
@@ -320,8 +330,13 @@ function parseParallelOptions(node) {
 function generalExpressionToAssignStep(node) {
     return new AssignStepAST([['__temp', convertExpression(node)]]);
 }
-function returnStatementToReturnStep(node) {
+function returnStatementToReturnStep(node, ctx) {
     const value = node.argument ? convertExpression(node.argument) : undefined;
+    if (ctx.finalizerTargets && ctx.finalizerTargets.length > 0) {
+        // If we are in try statement with a finally block, return statements are
+        // replaced by a jump to finally back with a captured return value.
+        return delayedReturnAndJumpToFinalizer(value, ctx);
+    }
     return new ReturnStepAST(value);
 }
 function throwStatementToRaiseStep(node) {
@@ -457,6 +472,11 @@ function doWhileStatementSteps(node, ctx) {
     return steps;
 }
 function breakStatementToNextStep(node, ctx) {
+    if (ctx.finalizerTargets) {
+        // TODO: would need to detect if this breaks out of the try or catch block,
+        // execute the finally block first and then do the break.
+        throw new WorkflowSyntaxError('break is not supported inside a try-finally block', node.loc);
+    }
     let target;
     if (node.label) {
         target = node.label.name;
@@ -470,6 +490,11 @@ function breakStatementToNextStep(node, ctx) {
     return new NextStepAST(target);
 }
 function continueStatementToNextStep(node, ctx) {
+    if (ctx.finalizerTargets) {
+        // TODO: would need to detect if continue breaks out of the try or catch block,
+        // execute the finally block first and then do the continue.
+        throw new WorkflowSyntaxError('continue is not supported inside a try-finally block', node.loc);
+    }
     let target;
     if (node.label) {
         target = node.label.name;
@@ -482,25 +507,129 @@ function continueStatementToNextStep(node, ctx) {
     }
     return new NextStepAST(target);
 }
-function tryStatementToTryStep(node, ctx) {
-    const steps = parseStatement(node.block, ctx);
-    let exceptSteps = [];
+function tryStatementToTrySteps(node, retryPolicy, ctx) {
+    if (!node.finalizer) {
+        // Basic try-catch without a finally block
+        const baseTryStep = parseTryCatchRetry(node, ctx, retryPolicy);
+        return [baseTryStep];
+    }
+    else {
+        // Try-finally is translated to two nested try blocks. The innermost try is
+        // the actual try body with control flow statements (return, in the future
+        // also break/continue) replaced by jumps to the finally block.
+        //
+        // The outer try's catch block saved the exception and continues to the
+        // finally block.
+        //
+        // The nested try blocks are followed by the finally block and a swith for
+        // checking if we need to perform a delayed return/raise.
+        const startOfFinalizer = new JumpTargetAST();
+        const targets = ctx.finalizerTargets ?? [];
+        targets.push(startOfFinalizer.label);
+        ctx = Object.assign({}, ctx, { finalizerTargets: targets });
+        const [conditionVariable, valueVariable] = finalizerVariables(ctx);
+        const innerTry = parseTryCatchRetry(node, ctx, retryPolicy);
+        const outerTry = new TryStepAST([innerTry], finalizerDelayedException('__fin_exc', conditionVariable, valueVariable), undefined, '__fin_exc');
+        // Reset ctx before parsing the finally block because we don't want to
+        // transform returns in finally block in to delayed returns
+        if (ctx.finalizerTargets && ctx.finalizerTargets.length <= 1) {
+            delete ctx.finalizerTargets;
+        }
+        else {
+            ctx.finalizerTargets?.pop();
+        }
+        const finallyBlock = parseStatement(node.finalizer, ctx);
+        return [
+            finalizerInitializer(conditionVariable, valueVariable),
+            outerTry,
+            startOfFinalizer,
+            ...finallyBlock,
+            finalizerFooter(conditionVariable, valueVariable),
+        ];
+    }
+}
+function finalizerVariables(ctx) {
+    const targets = ctx.finalizerTargets ?? [];
+    const nestingLevel = targets.length > 0 ? `${targets.length}` : '';
+    const conditionVariable = `__t2w_finally_condition${nestingLevel}`;
+    const valueVariable = `__t2w_finally_value${nestingLevel}`;
+    return [conditionVariable, valueVariable];
+}
+function parseTryCatchRetry(node, ctx, retryPolicy) {
+    const trySteps = parseStatement(node.block, ctx);
+    let exceptSteps = undefined;
     let errorVariable = undefined;
     if (node.handler) {
         exceptSteps = parseStatement(node.handler.body, ctx);
-        const handlerParam = node.handler.param;
-        if (handlerParam) {
-            if (handlerParam.type !== AST_NODE_TYPES.Identifier) {
-                throw new WorkflowSyntaxError('The error variable must be an identifier', handlerParam.loc);
-            }
-            errorVariable = handlerParam.name;
-        }
+        errorVariable = extractErrorVariableName(node.handler.param);
     }
-    if (node.finalizer !== null) {
-        // TODO
-        throw new WorkflowSyntaxError('finally block not yet supported', node.finalizer.loc);
+    const baseTryStep = new TryStepAST(trySteps, exceptSteps, retryPolicy, errorVariable);
+    return baseTryStep;
+}
+function extractErrorVariableName(param) {
+    if (!param) {
+        return undefined;
+    }
+    if (param.type !== AST_NODE_TYPES.Identifier) {
+        throw new WorkflowSyntaxError('The error variable must be an identifier', param.loc);
     }
-    return new TryStepAST(steps, exceptSteps, undefined, errorVariable);
+    return param.name;
+}
+/**
+ * The shared header for try-finally for initializing the temp variables
+ */
+function finalizerInitializer(conditionVariable, valueVariable) {
+    return new AssignStepAST([
+        [conditionVariable, new PrimitiveExpression(null)],
+        [valueVariable, new PrimitiveExpression(null)],
+    ]);
+}
+/**
+ * The shared footer of a finally block that re-throws the exception or
+ * returns the value returned by the try body.
+ *
+ * The footer code in TypeScript:
+ *
+ * if (__t2w_finally_condition == "return") {
+ *   return __t2w_finally_value
+ * } elseif (__t2w_finally_condition == "raise") {
+ *   throw __t2w_finally_value
+ * }
+ */
+function finalizerFooter(conditionVariable, valueVariable) {
+    return new SwitchStepAST([
+        {
+            condition: new BinaryExpression(new VariableReferenceExpression(conditionVariable), '==', new PrimitiveExpression('return')),
+            steps: [
+                new ReturnStepAST(new VariableReferenceExpression(valueVariable)),
+            ],
+        },
+        {
+            condition: new BinaryExpression(new VariableReferenceExpression(conditionVariable), '==', new PrimitiveExpression('raise')),
+            steps: [new RaiseStepAST(new VariableReferenceExpression(valueVariable))],
+        },
+    ]);
+}
+function finalizerDelayedException(exceptionVariableName, conditionVariableName, valueVariableName) {
+    return [
+        new AssignStepAST([
+            [conditionVariableName, new PrimitiveExpression('raise')],
+            [
+                valueVariableName,
+                new VariableReferenceExpression(exceptionVariableName),
+            ],
+        ]),
+    ];
+}
+function delayedReturnAndJumpToFinalizer(value, ctx) {
+    const finalizerTarget = ctx.finalizerTargets && ctx.finalizerTargets.length > 0
+        ? ctx.finalizerTargets[ctx.finalizerTargets.length - 1]
+        : undefined;
+    const [conditionVariable, valueVariable] = finalizerVariables(ctx);
+    return new AssignStepAST([
+        [conditionVariable, new PrimitiveExpression('return')],
+        [valueVariable, value ?? new PrimitiveExpression(null)],
+    ], finalizerTarget);
 }
 function labeledStep(node, ctx) {
     const steps = parseStatement(node.body, ctx);
@@ -509,3 +638,66 @@ function labeledStep(node, ctx) {
     }
     return steps;
 }
+function parseRetryPolicy(node) {
+    const callee = node.callee;
+    if (callee.type !== AST_NODE_TYPES.Identifier ||
+        callee.name !== 'retry_policy') {
+        // Ignore everything else besides retry_policy()
+        return undefined;
+    }
+    if (node.arguments.length < 1) {
+        throw new WorkflowSyntaxError('Required argument missing', node.loc);
+    }
+    const arg0 = throwIfSpread(node.arguments).map(convertExpression)[0];
+    const argsLoc = node.arguments[0].loc;
+    if (isFullyQualifiedName(arg0)) {
+        return arg0.toString();
+    }
+    else if (arg0.expressionType === 'primitive' && isRecord(arg0.value)) {
+        return retryPolicyFromParams(arg0.value, argsLoc);
+    }
+    else {
+        throw new WorkflowSyntaxError('Unexpected type', argsLoc);
+    }
+}
+function retryPolicyFromParams(paramsObject, argsLoc) {
+    const params = mapRecordValues(paramsObject, asExpression);
+    if ('backoff' in params) {
+        let predicate = '';
+        const predicateEx = params.predicate;
+        if (predicateEx === undefined) {
+            predicate = undefined;
+        }
+        else if (isFullyQualifiedName(predicateEx)) {
+            predicate = predicateEx.toString();
+        }
+        else {
+            throw new WorkflowSyntaxError('"predicate" must be a function name', argsLoc);
+        }
+        const backoffEx = params.backoff;
+        if (backoffEx.expressionType === 'primitive' && isRecord(backoffEx.value)) {
+            const backoffLit = backoffEx.value;
+            return {
+                predicate,
+                maxRetries: params.max_retries,
+                backoff: {
+                    initialDelay: backoffLit.initial_delay
+                        ? asExpression(backoffLit.initial_delay)
+                        : undefined,
+                    maxDelay: backoffLit.max_delay
+                        ? asExpression(backoffLit.max_delay)
+                        : undefined,
+                    multiplier: backoffLit.multiplier
+                        ? asExpression(backoffLit.multiplier)
+                        : undefined,
+                },
+            };
+        }
+        else {
+            throw new WorkflowSyntaxError('Expected an object literal', argsLoc);
+        }
+    }
+    else {
+        throw new WorkflowSyntaxError('Some required retry policy parameters are missing', argsLoc);
+    }
+}

package/dist/transpiler/transformations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AAAA,OAAO,EAUL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAuBxB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAUxE;AA4JD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAqBnB"}
+{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAqBxB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAQxE;AAiCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAqBnB"}