ts2workflows 0.3.0 → 0.5.0

package/dist/transpiler/transformations.js

@@ -1,6 +1,6 @@
 import { AssignStepAST, CallStepAST, ForStepAST, RaiseStepAST, ReturnStepAST, SwitchStepAST, TryStepAST, } from '../ast/steps.js';
 import { InternalTranspilingError } from '../errors.js';
-import { isRecord } from '../utils.js';
+import { isRecord, mapRecordValues } from '../utils.js';
 import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, expressionToLiteralValueOrLiteralExpression, isExpression, isFullyQualifiedName, isLiteral, } from '../ast/expressions.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
 const Unmodified = Symbol();
@@ -23,8 +23,9 @@ function mergeAssignSteps(steps) {
         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));
+            prev.assignments.length < 50 &&
+            !prev.next) {
+            const merged = new AssignStepAST(prev.assignments.concat(current.assignments), current.next, prev.label ?? current.label);
             acc.pop();
             acc.push(merged);
         }
@@ -142,26 +143,29 @@ function parseRetryPolicyNumber(record, keyName) {
  *     next: target1
  */
 export function flattenPlainNextConditions(steps) {
-    /*
-    const res = steps.reduce((acc: WorkflowStepAST[], step: WorkflowStepAST) => {
-      if (acc.length > 0) {
-        if (step.tag === 'next') {
-          const prev = acc[-1]
-  
-          if (prev.tag === 'assign') {
-            
-          }
-  
+    return steps.reduce((acc, step) => {
+        if (acc.length > 0 && step.tag === 'next') {
+            // Merge a "next" to the previous "assign" step
+            const prev = acc[acc.length - 1];
+            if (prev.tag === 'assign' && !prev.next) {
+                acc.pop();
+                acc.push(prev.withNext(step.target));
+            }
+            else {
+                acc.push(step);
+            }
+        }
+        else if (step.tag === 'switch') {
+            // If the condition steps consists of a single "next", merge it with the condition
+            acc.push(flattenNextToCondition(step));
+        }
+        else {
+            acc.push(step);
         }
-      }
-  
-      return acc
-    }, [])
-  
-    */
-    return steps.map((step) => (step.tag === 'switch' ? flattenNext(step) : step));
-}
-function flattenNext(step) {
+        return acc;
+    }, []);
+}
+function flattenNextToCondition(step) {
     const transformedBranches = step.branches.map((cond) => {
         if (!cond.next && cond.steps.length === 1 && cond.steps[0].tag === 'next') {
             const nextStep = cond.steps[0];
@@ -287,7 +291,7 @@ function transformExpressionsAssign(step, transform) {
             newSteps.push(...steps2);
             return [name, ex2];
         });
-        newSteps.push(new AssignStepAST(newAssignments, step.label));
+        newSteps.push(new AssignStepAST(newAssignments, step.next, step.label));
         return newSteps;
     }
     else {
@@ -297,11 +301,11 @@ function transformExpressionsAssign(step, transform) {
 function transformExpressionsCall(step, transform) {
     if (step.args) {
         const newSteps = [];
-        const newArgs = Object.fromEntries(Object.entries(step.args).map(([name, ex]) => {
+        const newArgs = mapRecordValues(step.args, (ex) => {
             const [steps2, ex2] = transform(ex);
             newSteps.push(...steps2);
-            return [name, ex2];
-        }));
+            return ex2;
+        });
         newSteps.push(new CallStepAST(step.call, newArgs, step.result, step.label));
         return newSteps;
     }
@@ -353,8 +357,8 @@ function transformExpressionsSwitch(step, transform) {
     newSteps.push(new SwitchStepAST(newBranches, step.label));
     return newSteps;
 }
-function transformExpression(ex, transformer) {
-    const transformed = transformer(ex);
+function transformExpression(ex, transform) {
+    const transformed = transform(ex);
     if (transformed !== Unmodified) {
         // Use the transformed version of this term
         return transformed;
@@ -363,28 +367,76 @@ function transformExpression(ex, transformer) {
         // Otherwise, recurse into the nested expression
         switch (ex.expressionType) {
             case 'primitive':
-            case 'variableReference':
-                return ex;
+                if (isLiteral(ex)) {
+                    return ex;
+                }
+                else {
+                    const newPrimitive = transformPrimitive(ex.value, transform);
+                    return newPrimitive === ex.value
+                        ? ex
+                        : new PrimitiveExpression(newPrimitive);
+                }
             case 'binary':
-                return transformBinaryExpression(ex, transformer);
+                return transformBinaryExpression(ex, transform);
             case 'functionInvocation':
-                return transformFunctionInvocationExpression(ex, transformer);
+                return transformFunctionInvocationExpression(ex, transform);
             case 'member':
-                return new MemberExpression(transformExpression(ex.object, transformer), transformExpression(ex.property, transformer), ex.computed);
+                return transformMemberExpression(ex, transform);
             case 'unary':
-                return new UnaryExpression(ex.operator, transformExpression(ex.value, transformer));
+                return transformUnaryExpression(ex, transform);
+            case 'variableReference':
+                return ex;
         }
     }
 }
-function transformBinaryExpression(ex, transformer) {
+function transformPrimitive(val, transform) {
+    if (Array.isArray(val)) {
+        return val.map((x) => isExpression(x)
+            ? transformExpression(x, transform)
+            : transformPrimitive(x, transform));
+    }
+    else if (isRecord(val)) {
+        return mapRecordValues(val, (x) => isExpression(x)
+            ? transformExpression(x, transform)
+            : transformPrimitive(x, transform));
+    }
+    else {
+        return val;
+    }
+}
+function transformBinaryExpression(ex, transform) {
     // 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);
+    const newLeft = transformExpression(ex.left, transform);
+    const newRight = transformExpression(ex.right, transform);
+    if (newLeft === ex.left && newRight === ex.right) {
+        return ex;
+    }
+    else {
+        return new BinaryExpression(newLeft, ex.binaryOperator, newRight);
+    }
+}
+function transformFunctionInvocationExpression(ex, transform) {
+    const newArguments = ex.arguments.map((x) => transformExpression(x, transform));
+    if (newArguments.every((x, i) => x === ex.arguments[i])) {
+        return ex;
+    }
+    else {
+        return new FunctionInvocationExpression(ex.functionName, newArguments);
+    }
+}
+function transformMemberExpression(ex, transform) {
+    const newObject = transformExpression(ex.object, transform);
+    const newProperty = transformExpression(ex.property, transform);
+    if (newObject === ex.object && newProperty === ex.property) {
+        return ex;
+    }
+    else {
+        return new MemberExpression(newObject, newProperty, ex.computed);
+    }
 }
-function transformFunctionInvocationExpression(ex, transformer) {
-    const newArguments = ex.arguments.map((x) => transformExpression(x, transformer));
-    return new FunctionInvocationExpression(ex.functionName, newArguments);
+function transformUnaryExpression(ex, transform) {
+    const newValue = transformExpression(ex.value, transform);
+    return newValue === ex.value ? ex : new UnaryExpression(ex.operator, newValue);
 }
 /**
  * Search for map literals in expressions and replace them with assign step + variable.
@@ -406,89 +458,143 @@ function transformFunctionInvocationExpression(ex, transformer) {
  *     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' || current.tag === 'return') {
-            needsTransformation =
-                current.value !== undefined &&
-                    includesExtractableMapLiteral(current.value, true);
-        }
-        else if (current.tag === 'call') {
-            if (current.args) {
-                needsTransformation = Object.values(current.args).some((ex) => includesExtractableMapLiteral(ex, true));
-            }
-        }
-        if (needsTransformation) {
-            const transformedSteps = transformStepExpressions(current, transformer);
-            acc.push(...transformedSteps);
-        }
-        else {
-            acc.push(current);
-        }
-        return acc;
-    }, []);
+    return steps.flatMap((step) => transformStepExpressions(step, transformNestedMaps));
+}
+function transformNestedMaps(ex) {
+    const generateTemporaryVariableName = createTempVariableGenerator();
+    const { transformedExpression, tempVariables } = extractNestedMaps(ex, generateTemporaryVariableName, 0);
+    const assignments = tempVariables.length > 0 ? [new AssignStepAST(tempVariables)] : [];
+    return [assignments, transformedExpression];
 }
-// Return true if the string representation of ex would include {}
-function includesExtractableMapLiteral(ex, parentAllowsMaps) {
+function extractNestedMaps(ex, generateName, nestingLevel) {
     switch (ex.expressionType) {
         case 'primitive':
-            if (isRecord(ex.value)) {
-                return (!parentAllowsMaps ||
-                    Object.values(ex.value).some((x) => isExpression(x) &&
-                        includesExtractableMapLiteral(x, parentAllowsMaps)));
-            }
-            else if (Array.isArray(ex.value)) {
-                return ex.value.some((x) => isExpression(x) &&
-                    includesExtractableMapLiteral(x, parentAllowsMaps));
-            }
-            else {
-                return false;
-            }
+            return extractNestedMapPrimitive(ex.value, generateName, nestingLevel);
         case 'binary':
-            return (includesExtractableMapLiteral(ex.left, parentAllowsMaps) ||
-                includesExtractableMapLiteral(ex.right, parentAllowsMaps));
+            return extractNestedMapBinary(ex, generateName, nestingLevel);
         case 'variableReference':
-            return false;
-        case 'unary':
-            return includesExtractableMapLiteral(ex.value, parentAllowsMaps);
+            return { transformedExpression: ex, tempVariables: [] };
         case 'functionInvocation':
-            return ex.arguments.some((x) => includesExtractableMapLiteral(x, false));
+            return extractNestedMapFunctionInvocation(ex, generateName, nestingLevel);
         case 'member':
-            return (includesExtractableMapLiteral(ex.object, false) ||
-                includesExtractableMapLiteral(ex.property, false));
+            return extractNestedMapMember(ex, generateName, nestingLevel);
+        case 'unary':
+            return extractNestedMapUnary(ex, generateName, nestingLevel);
     }
 }
-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);
+function extractNestedMapPrimitive(primitiveEx, generateName, nestingLevel) {
+    const { transformed, tempVariables } = extractNestedMapPrimitiveRecursive(primitiveEx, generateName, nestingLevel);
+    const ex = isExpression(transformed)
+        ? transformed
+        : new PrimitiveExpression(transformed);
+    return {
+        transformedExpression: ex,
+        tempVariables,
+    };
+}
+function extractNestedMapPrimitiveRecursive(primitiveEx, generateName, nestingLevel) {
+    if (typeof primitiveEx === 'string' ||
+        typeof primitiveEx === 'number' ||
+        typeof primitiveEx === 'boolean' ||
+        primitiveEx === null) {
+        return {
+            transformed: primitiveEx,
+            tempVariables: [],
+        };
+    }
+    else if (Array.isArray(primitiveEx)) {
+        return extractMapsInList(primitiveEx, generateName, nestingLevel);
+    }
+    else {
+        return extractMapsInMap(primitiveEx, generateName, nestingLevel);
+    }
+}
+function extractMapsInList(primitiveEx, generateName, nestingLevel) {
+    const { tempVariables, elements } = primitiveEx.reduce((acc, val) => {
+        if (isExpression(val)) {
+            const { transformedExpression, tempVariables: temps } = extractNestedMaps(val, generateName, nestingLevel);
+            acc.tempVariables.push(...temps);
+            acc.elements.push(transformedExpression);
         }
         else {
-            return Unmodified;
+            const { transformed, tempVariables: temps } = extractNestedMapPrimitiveRecursive(val, generateName, nestingLevel);
+            acc.tempVariables.push(...temps);
+            acc.elements.push(transformed);
         }
+        return acc;
+    }, {
+        tempVariables: [],
+        elements: [],
+    });
+    return {
+        tempVariables,
+        transformed: elements,
+    };
+}
+function extractMapsInMap(primitiveEx, generateName, nestingLevel) {
+    const { tempVariables, properties } = Object.entries(primitiveEx).reduce((acc, [key, val]) => {
+        if (isExpression(val)) {
+            const { transformedExpression, tempVariables: temps } = extractNestedMaps(val, generateName, 0);
+            acc.tempVariables.push(...temps);
+            acc.properties[key] = transformedExpression;
+        }
+        else {
+            const { transformed, tempVariables: temps } = extractNestedMapPrimitiveRecursive(val, generateName, 0);
+            acc.tempVariables.push(...temps);
+            acc.properties[key] = transformed;
+        }
+        return acc;
+    }, {
+        tempVariables: [],
+        properties: {},
+    });
+    let newValue;
+    if (nestingLevel === 0) {
+        newValue = properties;
+    }
+    else {
+        const name = generateName();
+        tempVariables.push([name, new PrimitiveExpression(properties)]);
+        newValue = new VariableReferenceExpression(name);
     }
-    const assignSteps = [];
     return {
-        transformedExpression: transformExpression(expression, replace),
-        assignSteps,
+        transformed: newValue,
+        tempVariables,
+    };
+}
+function extractNestedMapFunctionInvocation(ex, generateName, nestingLevel) {
+    const { expressions, temps } = ex.arguments.reduce((acc, arg) => {
+        const { transformedExpression, tempVariables } = extractNestedMaps(arg, generateName, nestingLevel + 1);
+        acc.expressions.push(transformedExpression);
+        acc.temps.push(...tempVariables);
+        return acc;
+    }, { expressions: [], temps: [] });
+    return {
+        transformedExpression: new FunctionInvocationExpression(ex.functionName, expressions),
+        tempVariables: temps,
+    };
+}
+function extractNestedMapBinary(ex, generateName, nestingLevel) {
+    const left = extractNestedMaps(ex.left, generateName, nestingLevel + 1);
+    const right = extractNestedMaps(ex.right, generateName, nestingLevel + 1);
+    return {
+        transformedExpression: new BinaryExpression(left.transformedExpression, ex.binaryOperator, right.transformedExpression),
+        tempVariables: left.tempVariables.concat(right.tempVariables),
+    };
+}
+function extractNestedMapMember(ex, generateName, nestingLevel) {
+    const obj = extractNestedMaps(ex.object, generateName, nestingLevel + 1);
+    const pr = extractNestedMaps(ex.property, generateName, nestingLevel + 1);
+    return {
+        transformedExpression: new MemberExpression(obj.transformedExpression, pr.transformedExpression, ex.computed),
+        tempVariables: obj.tempVariables.concat(pr.tempVariables),
+    };
+}
+function extractNestedMapUnary(ex, generateName, nestingLevel) {
+    const { transformedExpression, tempVariables } = extractNestedMaps(ex.value, generateName, nestingLevel);
+    return {
+        transformedExpression: new UnaryExpression(ex.operator, transformedExpression),
+        tempVariables,
     };
 }
 /**

package/dist/utils.d.ts

@@ -1,2 +1,6 @@
 export declare function isRecord(object: unknown): object is Record<keyof never, unknown>;
+/**
+ * Apply f to values of obj and return the result
+ */
+export declare function mapRecordValues<T, U>(obj: Record<string, T>, f: (t: T) => U): Record<string, U>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +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"}
+{"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;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACb,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAEnB"}

package/dist/utils.js

@@ -1,3 +1,9 @@
 export function isRecord(object) {
     return object instanceof Object && object.constructor === Object;
 }
+/**
+ * Apply f to values of obj and return the result
+ */
+export function mapRecordValues(obj, f) {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, f(v)]));
+}

package/language_reference.md

@@ -40,6 +40,12 @@ It is not possible to construct a bytes object expect by calling a function that
 
 In addition to the literal `null`, the Typescript `undefined` value is also treated as `null` in Workflows YAML.
 
+### Implicit type conversions
+
+Expressions that combine variables with operators such as `+`, `>`, `==` perform implict type conversions according to the [rules listed on GCP Workflows documentation](https://cloud.google.com/workflows/docs/reference/syntax/datatypes#implicit-conversions). For example, applying `+` to a string and a number concatenates the values into a string.
+
+⚠️ Checking if a variable is null or not must be done by an explicit comparison: `if (var != null) {...}`. Relying in an implicit conversion, such as `if (var) {...}`, results in a TypeError at runtime.
+
 ## Expressions
 
 Most Typescript expressions work as expected.
@@ -56,7 +62,7 @@ name === 'Bean'
 sys.get_env('GOOGLE_CLOUD_PROJECT_ID')
 ```
 
-Operators:
+## Operators
 
 | Operator     | Description                                  |
 | ------------ | -------------------------------------------- |
@@ -71,11 +77,59 @@ Operators:
 | &&, \|\|, !  | logical operators                            |
 | in           | check if a property is present in an object  |
 | ??           | nullish coalescing                           |
+| ?.           | optional chaining                            |
+| ? :          | conditional operator                         |
 
 The [precendence order of operators](https://cloud.google.com/workflows/docs/reference/syntax/datatypes#order-operations) is the same as in GCP Workflows.
 
 See [expression in GCP Workflows](https://cloud.google.com/workflows/docs/reference/syntax/expressions) for more information.
 
+### Conditional (ternary) operator
+
+The expression
+
+```javascript
+x > 0 ? 'positive' : 'not positive'
+```
+
+is converted to an [if() expression](https://cloud.google.com/workflows/docs/reference/stdlib/expression-helpers#conditional_functions):
+
+```yaml
+${if(x > 0, "positive", "not positive")}
+```
+
+⚠️ Note that Workflows always evaluates both expression branches unlike Typescript which evaluates only the branch that gets executed.
+
+### Nullish coalescing operator
+
+The expression
+
+```javascript
+x ?? 'default value'
+```
+
+is converted to a [default() expression](https://cloud.google.com/workflows/docs/reference/stdlib/expression-helpers#conditional_functions):
+
+```yaml
+${default(x, "default value")}
+```
+
+⚠️ Note that Workflows always evaluates the right-hand side expression unlike Typescript which evaluates the right-hand side only if the left-hand side is `null` or `undefined`.
+
+### Optional chaining
+
+The optional chaining expression
+
+```javascript
+data.user?.name
+```
+
+is converted to a [map.get() expression](https://cloud.google.com/workflows/docs/reference/stdlib/map/get):
+
+```yaml
+${map.get(data, ["user", "name"])}
+```
+
 ## Template literals
 
 Template literals are strings that support string interpolation. For example, `Hello ${name}`.
@@ -307,38 +361,6 @@ steps:
       return: ${b}
 ```
 
-## Conditional (ternary) operator
-
-The expression
-
-```javascript
-x > 0 ? 'positive' : 'not positive'
-```
-
-is converted to an [if() expression](https://cloud.google.com/workflows/docs/reference/stdlib/expression-helpers#conditional_functions):
-
-```yaml
-${if(x > 0, "positive", "not positive")}
-```
-
-⚠️ Note that Workflows always evaluates both expression branches unlike Typescript which evaluates only the branch that gets executed.
-
-## Nullish coalescing operator
-
-The expression
-
-```javascript
-x ?? 'default value'
-```
-
-is converted to an [default() expression](https://cloud.google.com/workflows/docs/reference/stdlib/expression-helpers#conditional_functions):
-
-```yaml
-${default(x, "default value")}
-```
-
-⚠️ Note that Workflows always evaluates the right-hand side expression unlike Typescript which evaluates the right-hand side only if the left-hand side is `null` or `undefined`.
-
 ## Loops
 
 The fragment

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts2workflows",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Transpile Typescript code to GCP Workflows programs",
   "homepage": "https://github.com/aajanki/ts2workflows",
   "repository": {
@@ -23,7 +23,15 @@
     "prepare": "husky"
   },
   "lint-staged": {
-    "*.ts": [
+    "src/**/*.ts": [
+      "prettier --write",
+      "eslint"
+    ],
+    "test/**/*.ts": [
+      "prettier --write",
+      "eslint"
+    ],
+    "scripts/**/*.ts": [
       "prettier --write",
       "eslint"
     ],
@@ -49,7 +57,7 @@
   ],
   "devDependencies": {
     "@eslint/js": "^9.10.0",
-    "@types/chai": "^4.3.16",
+    "@types/chai": "^5.0.1",
     "@types/mocha": "^10.0.6",
     "@types/node": "^18",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -66,7 +74,6 @@
   },
   "dependencies": {
     "@typescript-eslint/typescript-estree": "^8.0.0",
-    "@typescript-eslint/utils": "^8.0.0",
     "commander": "^12.1.0",
     "typescript": "^5.0.0",
     "yaml": "^2.4.2"