ts2workflows 0.1.0

package/dist/transpiler/transformations.js

@@ -0,0 +1,461 @@
+import { AssignStepAST, CallStepAST, ForStepAST, RaiseStepAST, ReturnStepAST, SwitchStepAST, TryStepAST, } from '../ast/steps.js';
+import { InternalTranspilingError } from '../errors.js';
+import { isRecord } from '../utils.js';
+import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, expressionToLiteralValueOrLiteralExpression, isExpression, isFullyQualifiedName, isLiteral, } from '../ast/expressions.js';
+import { blockingFunctions } from './generated/functionMetadata.js';
+/**
+ * Performs various transformations on the AST.
+ *
+ * This flat list of steps and does not recurse into nested steps. This gets
+ * called on each nesting level separately.
+ */
+export function transformAST(steps) {
+    return blockingCallsAsCallSteps(flattenPlainNextConditions(combineRetryBlocksToTry(mergeAssignSteps(mapLiteralsAsAssignSteps(steps)))));
+}
+/**
+ * Merge consecutive assign steps into one assign step
+ *
+ * An assign step can contain up to 50 assignments.
+ */
+function mergeAssignSteps(steps) {
+    return steps.reduce((acc, current) => {
+        const prev = acc.length > 0 ? acc[acc.length - 1] : null;
+        if (current.tag === 'assign' &&
+            prev?.tag === 'assign' &&
+            prev.assignments.length < 50) {
+            const merged = new AssignStepAST(prev.assignments.concat(current.assignments));
+            acc.pop();
+            acc.push(merged);
+        }
+        else {
+            acc.push(current);
+        }
+        return acc;
+    }, []);
+}
+/**
+ * Transform a retry_policy call step to a retry block in a preceeding try step
+ */
+function combineRetryBlocksToTry(steps) {
+    return steps.reduce((acc, current) => {
+        const prev = acc.length > 0 ? acc[acc.length - 1] : null;
+        if (current.tag === 'call' && current.call === 'retry_policy') {
+            if (prev?.tag === 'try') {
+                if (prev.retryPolicy) {
+                    throw new InternalTranspilingError('Retry policy already assigned!');
+                }
+                let retryPolicy = undefined;
+                const retryParameters = current.args;
+                if (retryParameters) {
+                    const retryPolicyEx = retryParameters.policy;
+                    if (retryPolicyEx && isFullyQualifiedName(retryPolicyEx)) {
+                        retryPolicy = retryPolicyEx.toString();
+                    }
+                    if (!retryPolicy) {
+                        let predicate = '';
+                        const predicateEx = retryParameters.predicate;
+                        if (predicateEx) {
+                            if (isFullyQualifiedName(predicateEx)) {
+                                predicate = predicateEx.toString();
+                            }
+                            else {
+                                throw new InternalTranspilingError('"predicate" must be a function name');
+                            }
+                        }
+                        const maxRetries = parseRetryPolicyNumber(retryParameters, 'max_retries');
+                        let initialDelay = 1;
+                        let maxDelay = 1;
+                        let multiplier = 1;
+                        const backoffEx = retryParameters.backoff;
+                        if (backoffEx &&
+                            isLiteral(backoffEx) &&
+                            backoffEx.expressionType === 'primitive') {
+                            const backoffLit = backoffEx.value;
+                            if (isRecord(backoffLit)) {
+                                initialDelay = parseRetryPolicyNumber(backoffLit, 'initial_delay');
+                                maxDelay = parseRetryPolicyNumber(backoffLit, 'max_delay');
+                                multiplier = parseRetryPolicyNumber(backoffLit, 'multiplier');
+                            }
+                        }
+                        retryPolicy = {
+                            predicate,
+                            maxRetries,
+                            backoff: {
+                                initialDelay,
+                                maxDelay,
+                                multiplier,
+                            },
+                        };
+                    }
+                }
+                const tryWithRetry = new TryStepAST(prev.trySteps, prev.exceptSteps, retryPolicy, prev.errorMap);
+                acc.pop();
+                acc.push(tryWithRetry);
+            }
+            // If prev is not a try step, "retry_policy" is ignored. Should print a warning.
+        }
+        else {
+            acc.push(current);
+        }
+        return acc;
+    }, []);
+}
+function parseRetryPolicyNumber(record, keyName) {
+    let primitiveValue;
+    const primitiveOrExpression = record[keyName];
+    if (primitiveOrExpression && isExpression(primitiveOrExpression)) {
+        if (isLiteral(primitiveOrExpression)) {
+            primitiveValue = expressionToLiteralValueOrLiteralExpression(primitiveOrExpression);
+        }
+        else {
+            throw new InternalTranspilingError(`Support for non-literal "${keyName}" values not yet implemented`);
+        }
+    }
+    else if (primitiveOrExpression) {
+        primitiveValue = primitiveOrExpression;
+    }
+    else {
+        throw new InternalTranspilingError(`"${keyName}" expected`);
+    }
+    if (typeof primitiveValue !== 'number') {
+        throw new InternalTranspilingError(`"${keyName}" must be a number`);
+    }
+    return primitiveValue;
+}
+/**
+ * Flatten switch conditions that contain a single next step.
+ *
+ * For example, transforms this:
+ *
+ * switch:
+ *   - condition: ${x > 0}
+ *     steps:
+ *       - next1:
+ *           steps:
+ *             next: target1
+ *
+ * into this:
+ *
+ * switch:
+ *   - condition: ${x > 0}
+ *     next: target1
+ */
+export function flattenPlainNextConditions(steps) {
+    return steps.map((step) => (step.tag === 'switch' ? flattenNext(step) : step));
+}
+function flattenNext(step) {
+    const transformedBranches = step.branches.map((cond) => {
+        if (!cond.next && cond.steps.length === 1 && cond.steps[0].tag === 'next') {
+            const nextStep = cond.steps[0];
+            return {
+                condition: cond.condition,
+                steps: [],
+                next: nextStep.target,
+            };
+        }
+        else {
+            return cond;
+        }
+    });
+    return new SwitchStepAST(transformedBranches);
+}
+/**
+ * Search for blocking calls in expressions and replace them with call step + variable.
+ *
+ * The Workflows runtime requires that blocking calls must be executed by call steps.
+ *
+ * For example, transforms this:
+ *
+ * - return1:
+ *     return: ${http.get("https://example.com")}
+ *
+ * into this:
+ *
+ * - call_http_get_1:
+ *     call: http.get
+ *     args:
+ *       url: https://example.com
+ *     result: __temp0
+ * - return1:
+ *     return: ${__temp0}
+ */
+function blockingCallsAsCallSteps(steps) {
+    const transformer = (ex) => {
+        const generateTemporaryVariableName = createTempVariableGenerator();
+        const { transformedExpression, callSteps } = replaceBlockingCalls(ex, generateTemporaryVariableName);
+        return [callSteps, transformedExpression];
+    };
+    return steps.reduce((acc, current) => {
+        const transformedSteps = transformStepExpressions(current, transformer);
+        acc.push(...transformedSteps);
+        return acc;
+    }, []);
+}
+function createTempVariableGenerator() {
+    let i = 0;
+    const generator = () => `__temp${i++}`;
+    return generator;
+}
+const Unmodified = Symbol();
+function replaceBlockingCalls(expression, generateName) {
+    function replaceBlockingFunctionInvocations(ex) {
+        if (ex.expressionType === 'functionInvocation') {
+            const callStepsForArguments = [];
+            const replacedArguments = ex.arguments.map((ex) => {
+                const replaced = replaceBlockingCalls(ex, generateName);
+                callStepsForArguments.push(...replaced.callSteps);
+                return replaced.transformedExpression;
+            });
+            const blockingCallArgumentNames = blockingFunctions.get(ex.functionName);
+            if (blockingCallArgumentNames) {
+                if (replacedArguments.length > blockingCallArgumentNames.length) {
+                    throw new InternalTranspilingError('FunctionInvocationTerm has more arguments than metadata allows!');
+                }
+                const nameAndValue = replacedArguments.map((val, i) => [blockingCallArgumentNames[i], val]);
+                const args = Object.fromEntries(nameAndValue);
+                const tempCallResultVariable = generateName();
+                callSteps.push(...callStepsForArguments);
+                callSteps.push(new CallStepAST(ex.functionName, args, tempCallResultVariable));
+                // replace function invocation with a reference to the temporary variable
+                return new VariableReferenceExpression(tempCallResultVariable);
+            }
+            else {
+                return Unmodified;
+            }
+        }
+        else {
+            return Unmodified;
+        }
+    }
+    const callSteps = [];
+    return {
+        transformedExpression: transformExpression(expression, replaceBlockingFunctionInvocations),
+        callSteps,
+    };
+}
+/**
+ * Transform expressions in a step by applying transform.
+ *
+ * Returns an array of steps. The array includes the transformed step and possibly
+ * additional steps constructed during the transformation. For example, a
+ * transformation might extract blocking call expressions into call steps.
+ */
+function transformStepExpressions(step, transform) {
+    switch (step.tag) {
+        case 'assign':
+            return transformExpressionsAssign(step, transform);
+        case 'call':
+            return transformExpressionsCall(step, transform);
+        case 'for':
+            return transformExpressionsFor(step, transform);
+        case 'raise':
+            return transformExpressionsRaise(step, transform);
+        case 'return':
+            return transformExpressionsReturn(step, transform);
+        case 'switch':
+            return transformExpressionsSwitch(step, transform);
+        case 'next':
+        case 'parallel':
+        case 'steps':
+        case 'try':
+        case 'jumptarget':
+            return [step];
+    }
+}
+function transformExpressionsAssign(step, transform) {
+    if (step.assignments) {
+        const newSteps = [];
+        const newAssignments = step.assignments.map(([name, ex]) => {
+            const [steps2, ex2] = transform(ex);
+            newSteps.push(...steps2);
+            return [name, ex2];
+        });
+        newSteps.push(new AssignStepAST(newAssignments, step.label));
+        return newSteps;
+    }
+    else {
+        return [step];
+    }
+}
+function transformExpressionsCall(step, transform) {
+    if (step.args) {
+        const newSteps = [];
+        const newArgs = Object.fromEntries(Object.entries(step.args).map(([name, ex]) => {
+            const [steps2, ex2] = transform(ex);
+            newSteps.push(...steps2);
+            return [name, ex2];
+        }));
+        newSteps.push(new CallStepAST(step.call, newArgs, step.result, step.label));
+        return newSteps;
+    }
+    else {
+        return [step];
+    }
+}
+function transformExpressionsFor(step, transform) {
+    if (step.listExpression) {
+        const [newSteps, newListExpression] = transform(step.listExpression);
+        newSteps.push(new ForStepAST(step.steps, step.loopVariableName, newListExpression, step.indexVariableName, step.rangeStart, step.rangeEnd, step.label));
+        return newSteps;
+    }
+    else {
+        return [step];
+    }
+}
+function transformExpressionsRaise(step, transform) {
+    if (step.value) {
+        const [newSteps, newEx] = transform(step.value);
+        newSteps.push(new RaiseStepAST(newEx, step.label));
+        return newSteps;
+    }
+    else {
+        return [step];
+    }
+}
+function transformExpressionsReturn(step, transform) {
+    if (step.value) {
+        const [newSteps, newEx] = transform(step.value);
+        newSteps.push(new ReturnStepAST(newEx, step.label));
+        return newSteps;
+    }
+    else {
+        return [step];
+    }
+}
+function transformExpressionsSwitch(step, transform) {
+    const newSteps = [];
+    const newBranches = step.branches.map((cond) => {
+        const [steps2, ex2] = transform(cond.condition);
+        newSteps.push(...steps2);
+        return {
+            condition: ex2,
+            steps: cond.steps,
+            next: cond.next,
+        };
+    });
+    newSteps.push(new SwitchStepAST(newBranches, step.label));
+    return newSteps;
+}
+function transformExpression(ex, transformer) {
+    const transformed = transformer(ex);
+    if (transformed !== Unmodified) {
+        // Use the transformed version of this term
+        return transformed;
+    }
+    else {
+        // Otherwise, recurse into the nested expression
+        switch (ex.expressionType) {
+            case 'primitive':
+            case 'variableReference':
+                return ex;
+            case 'binary':
+                return transformBinaryExpression(ex, transformer);
+            case 'functionInvocation':
+                return transformFunctionInvocationExpression(ex, transformer);
+            case 'member':
+                return new MemberExpression(transformExpression(ex.object, transformer), transformExpression(ex.property, transformer), ex.computed);
+            case 'unary':
+                return new UnaryExpression(ex.operator, transformExpression(ex.value, transformer));
+        }
+    }
+}
+function transformBinaryExpression(ex, transformer) {
+    // Transform left first to keep the correct order of execution of sub-expressions
+    const newLeft = transformExpression(ex.left, transformer);
+    const newRight = transformExpression(ex.right, transformer);
+    return new BinaryExpression(newLeft, ex.binaryOperator, newRight);
+}
+function transformFunctionInvocationExpression(ex, transformer) {
+    const newArguments = ex.arguments.map((x) => transformExpression(x, transformer));
+    return new FunctionInvocationExpression(ex.functionName, newArguments);
+}
+/**
+ * Search for map literals in expressions and replace them with assign step + variable.
+ *
+ * Workflows does not support a map literal in expressions.
+ *
+ * For example, transforms this:
+ *
+ * - return1:
+ *     return: ${ {value: 5}.value }
+ *
+ * into this:
+ *
+ * - assign1:
+ *     assign:
+ *       - __temp0:
+ *         value: 5
+ * - return1:
+ *     return: ${__temp0.value}
+ */
+function mapLiteralsAsAssignSteps(steps) {
+    function transformer(ex) {
+        const generateTemporaryVariableName = createTempVariableGenerator();
+        const { transformedExpression, assignSteps } = replaceMapLiterals(ex, generateTemporaryVariableName);
+        return [assignSteps, transformedExpression];
+    }
+    return steps.reduce((acc, current) => {
+        let needsTransformation = true;
+        // These steps are allowed to contain map literals if the map is the
+        // main expression
+        if (current.tag === 'assign') {
+            // This does the transformation a bit too eagerly: If any of the
+            // assignments need the map literal extraction, it is done on all of
+            // the variables.
+            needsTransformation = !current.assignments.every(([, value]) => {
+                return value.expressionType === 'primitive';
+            });
+        }
+        else if (current.tag === 'raise') {
+            needsTransformation =
+                !isLiteral(current.value) && includesMapLiteral(current.value);
+        }
+        else if (current.tag === 'call') {
+            if (current.args) {
+                needsTransformation = Object.values(current.args).some((ex) => !isLiteral(ex) && includesMapLiteral(ex));
+            }
+        }
+        if (needsTransformation) {
+            const transformedSteps = transformStepExpressions(current, transformer);
+            acc.push(...transformedSteps);
+        }
+        else {
+            acc.push(current);
+        }
+        return acc;
+    }, []);
+}
+function includesMapLiteral(ex) {
+    switch (ex.expressionType) {
+        case 'primitive':
+            return isRecord(ex.value);
+        case 'binary':
+            return includesMapLiteral(ex.left) || includesMapLiteral(ex.right);
+        case 'variableReference':
+            return false;
+        case 'unary':
+            return includesMapLiteral(ex.value);
+        case 'functionInvocation':
+            return ex.arguments.some(includesMapLiteral);
+        case 'member':
+            return includesMapLiteral(ex.object) || includesMapLiteral(ex.property);
+    }
+}
+function replaceMapLiterals(expression, generateName) {
+    function replace(ex) {
+        if (ex.expressionType === 'primitive' && isRecord(ex.value)) {
+            const tempVariable = generateName();
+            assignSteps.push(new AssignStepAST([[tempVariable, new PrimitiveExpression(ex.value)]]));
+            // replace the map literal with a reference to the temporary variable
+            return new VariableReferenceExpression(tempVariable);
+        }
+        else {
+            return Unmodified;
+        }
+    }
+    const assignSteps = [];
+    return {
+        transformedExpression: transformExpression(expression, replace),
+        assignSteps,
+    };
+}

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isRecord(object: unknown): object is Record<keyof never, unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CACtB,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,CAExC"}

package/dist/utils.js

@@ -0,0 +1,3 @@
+export function isRecord(object) {
+    return object instanceof Object && object.constructor === Object;
+}