ts2workflows 0.8.0 → 0.10.0

package/dist/errors.js

@@ -1,3 +1,5 @@
+// WorkflowSyntaxError is thrown when the input contains a syntax error.
+// The error is in user's input.
 export class WorkflowSyntaxError extends Error {
     location;
     constructor(message, location) {
@@ -5,6 +7,8 @@ export class WorkflowSyntaxError extends Error {
         this.location = location;
     }
 }
+// InternalTranspilingError is thrown when ts2workflow ends up in an unexpected state.
+// The error is in ts2workflow.
 export class InternalTranspilingError extends Error {
     constructor(message) {
         super(`Internal error: ${message}`);

package/dist/transpiler/expressions.d.ts

@@ -1,11 +1,11 @@
 import { TSESTree } from '@typescript-eslint/typescript-estree';
-import { Expression, Primitive } from '../ast/expressions.js';
+import { Expression, MemberExpression, Primitive, VariableReferenceExpression } from '../ast/expressions.js';
 export declare function convertExpression(instance: TSESTree.Expression): Expression;
 export declare function convertObjectExpression(node: TSESTree.ObjectExpression): Record<string, Primitive | Expression>;
 export declare function convertObjectAsExpressionValues(node: TSESTree.ObjectExpression): Record<string, Expression>;
 export declare function convertMemberExpression(node: TSESTree.MemberExpression): Expression;
-export declare function isMagicFunction(calleeName: string): boolean;
-export declare function isMagicFunctionStatmentOnly(calleeName: string): boolean;
+export declare function isIntrinsic(calleeName: string): boolean;
+export declare function isIntrinsicStatment(calleeName: string): boolean;
 export declare function throwIfSpread<T extends TSESTree.Expression | TSESTree.Property | TSESTree.SpreadElement | null>(nodes: T[]): Exclude<T, TSESTree.SpreadElement>[];
-export declare function asExpression(x: Primitive | Expression): Expression;
+export declare function convertVariableNameExpression(instance: TSESTree.Expression): VariableReferenceExpression | MemberExpression;
 //# sourceMappingURL=expressions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/transpiler/expressions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAkB,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAGL,UAAU,EAGV,SAAS,EAMV,MAAM,uBAAuB,CAAA;AAI9B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,GAAG,UAAU,CAO3E;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAAC,CAgCxC;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAG5B;AAmOD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,UAAU,CAcZ;AA0JD,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG3D;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGvE;AAoDD,wBAAgB,aAAa,CAC3B,CAAC,SACG,QAAQ,CAAC,UAAU,GACnB,QAAQ,CAAC,QAAQ,GACjB,QAAQ,CAAC,aAAa,GACtB,IAAI,EACR,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAgBlD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,CAElE"}
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/transpiler/expressions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAkB,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAGL,UAAU,EAEV,gBAAgB,EAChB,SAAS,EAGT,2BAA2B,EAI5B,MAAM,uBAAuB,CAAA;AAG9B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,GAAG,UAAU,CAiE3E;AAcD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAAC,CAgCxC;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAG5B;AAwJD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,UAAU,CAcZ;AA0JD,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGvD;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG/D;AAoDD,wBAAgB,aAAa,CAC3B,CAAC,SACG,QAAQ,CAAC,UAAU,GACnB,QAAQ,CAAC,QAAQ,GACjB,QAAQ,CAAC,aAAa,GACtB,IAAI,EACR,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAgBlD;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,QAAQ,CAAC,UAAU,GAC5B,2BAA2B,GAAG,gBAAgB,CAchD"}

package/dist/transpiler/expressions.js

@@ -1,69 +1,26 @@
+import * as R from 'ramda';
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
-import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, isExpression, isFullyQualifiedName, } from '../ast/expressions.js';
+import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, asExpression, isFullyQualifiedName, nullEx, } from '../ast/expressions.js';
 import { InternalTranspilingError, WorkflowSyntaxError } from '../errors.js';
-import { mapRecordValues } from '../utils.js';
 export function convertExpression(instance) {
-    const expOrPrimitive = convertExpressionOrPrimitive(instance);
-    if (isExpression(expOrPrimitive)) {
-        return expOrPrimitive;
-    }
-    else {
-        return new PrimitiveExpression(expOrPrimitive);
-    }
-}
-export function convertObjectExpression(node) {
-    return Object.fromEntries(throwIfSpread(node.properties).map(({ key, value }) => {
-        let keyPrimitive;
-        if (key.type === AST_NODE_TYPES.Identifier) {
-            keyPrimitive = key.name;
-        }
-        else if (key.type === AST_NODE_TYPES.Literal) {
-            if (typeof key.value === 'string') {
-                keyPrimitive = key.value;
-            }
-            else {
-                throw new WorkflowSyntaxError(`Map keys must be identifiers or strings, encountered: ${typeof key.value}`, key.loc);
-            }
-        }
-        else {
-            throw new WorkflowSyntaxError(`Not implemented object key type: ${key.type}`, key.loc);
-        }
-        if (value.type === AST_NODE_TYPES.AssignmentPattern ||
-            value.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
-            throw new WorkflowSyntaxError('Value not supported', value.loc);
-        }
-        return [keyPrimitive, convertExpressionOrPrimitive(value)];
-    }));
-}
-export function convertObjectAsExpressionValues(node) {
-    // Convert Primitive values to PrimitiveExpressions
-    return mapRecordValues(convertObjectExpression(node), asExpression);
-}
-function convertExpressionOrPrimitive(instance) {
     switch (instance.type) {
         case AST_NODE_TYPES.ArrayExpression:
-            return convertArrayExpression(instance);
+            return asExpression(convertArrayExpression(instance));
         case AST_NODE_TYPES.ObjectExpression:
-            return convertObjectExpression(instance);
+            return asExpression(convertObjectExpression(instance));
         case AST_NODE_TYPES.Literal:
             if (instance.value instanceof RegExp) {
                 throw new WorkflowSyntaxError('RegExp is not supported', instance.loc);
             }
             if (typeof instance.value === 'bigint') {
-                throw new WorkflowSyntaxError('BigInt in not supported', instance.loc);
+                throw new WorkflowSyntaxError('BigInt is not supported', instance.loc);
             }
-            return instance.value;
+            return new PrimitiveExpression(instance.value);
         case AST_NODE_TYPES.TemplateLiteral:
             return convertTemplateLiteralToExpression(instance);
         case AST_NODE_TYPES.Identifier:
             if (instance.name === 'null' || instance.name === 'undefined') {
-                return null;
-            }
-            else if (instance.name === 'True' || instance.name === 'TRUE') {
-                return true;
-            }
-            else if (instance.name === 'False' || instance.name === 'FALSE') {
-                return false;
+                return nullEx;
             }
             else {
                 return new VariableReferenceExpression(instance.name);
@@ -82,24 +39,59 @@ function convertExpressionOrPrimitive(instance) {
         case AST_NODE_TYPES.ConditionalExpression:
             return convertConditionalExpression(instance);
         case AST_NODE_TYPES.TSAsExpression:
-            return convertExpressionOrPrimitive(instance.expression);
+            return convertExpression(instance.expression);
         case AST_NODE_TYPES.TSNonNullExpression:
-            return convertExpressionOrPrimitive(instance.expression);
+            return convertExpression(instance.expression);
         case AST_NODE_TYPES.AwaitExpression:
-            return convertExpressionOrPrimitive(instance.argument);
+            return convertExpression(instance.argument);
         case AST_NODE_TYPES.TSInstantiationExpression:
-            return convertExpressionOrPrimitive(instance.expression);
+            return convertExpression(instance.expression);
         default:
             throw new WorkflowSyntaxError(`Not implemented expression type: ${instance.type}`, instance.loc);
     }
 }
+function convertExpressionOrPrimitive(instance) {
+    const ex = convertExpression(instance);
+    if (ex.expressionType === 'primitive') {
+        return ex.value;
+    }
+    else {
+        return ex;
+    }
+}
+export function convertObjectExpression(node) {
+    return Object.fromEntries(throwIfSpread(node.properties).map(({ key, value }) => {
+        let keyPrimitive;
+        if (key.type === AST_NODE_TYPES.Identifier) {
+            keyPrimitive = key.name;
+        }
+        else if (key.type === AST_NODE_TYPES.Literal) {
+            if (typeof key.value === 'string') {
+                keyPrimitive = key.value;
+            }
+            else {
+                throw new WorkflowSyntaxError(`Map keys must be identifiers or strings, encountered: ${typeof key.value}`, key.loc);
+            }
+        }
+        else {
+            throw new WorkflowSyntaxError(`Not implemented object key type: ${key.type}`, key.loc);
+        }
+        if (value.type === AST_NODE_TYPES.AssignmentPattern ||
+            value.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
+            throw new WorkflowSyntaxError('Value not supported', value.loc);
+        }
+        return [keyPrimitive, convertExpressionOrPrimitive(value)];
+    }));
+}
+export function convertObjectAsExpressionValues(node) {
+    // Convert Primitive values to PrimitiveExpressions
+    return R.map(asExpression, convertObjectExpression(node));
+}
 function convertArrayExpression(instance) {
-    return throwIfSpread(instance.elements).map((e) => e === null
-        ? new PrimitiveExpression(null)
-        : convertExpressionOrPrimitive(e));
+    return throwIfSpread(instance.elements).map((e) => e === null ? nullEx : convertExpressionOrPrimitive(e));
 }
 function convertBinaryExpression(instance) {
-    // Special case for nullish coalescing becuase the result is a function call
+    // Special case for nullish coalescing because the result is a function call
     // expression, not a binary expression
     if (instance.operator === '??') {
         return nullishCoalescingExpression(instance.left, instance.right);
@@ -189,7 +181,7 @@ function convertUnaryExpression(instance) {
     }
 }
 function convertTypeOfExpression(value) {
-    // Note for future rectoring: evalute value only once (in case it has side effects)
+    // Note for future refactoring: evalute value only once (in case it has side effects)
     return new FunctionInvocationExpression('text.replace_all_regex', [
         new FunctionInvocationExpression('text.replace_all_regex', [
             new FunctionInvocationExpression('get_type', [value]),
@@ -209,7 +201,7 @@ export function convertMemberExpression(node) {
 }
 function convertChainExpression(node) {
     const properties = chainExpressionToFlatArray(node.expression);
-    const args = optinalChainToMapGetArguments(properties);
+    const args = optionalChainToMapGetArguments(properties);
     return new FunctionInvocationExpression('map.get', args);
 }
 function chainExpressionToFlatArray(node) {
@@ -234,7 +226,7 @@ function chainExpressionToFlatArray(node) {
         ];
     }
 }
-function optinalChainToMapGetArguments(properties) {
+function optionalChainToMapGetArguments(properties) {
     if (properties.length <= 0) {
         // this shouldn't happen
         return [];
@@ -298,7 +290,7 @@ function convertCallExpression(node) {
     const calleeExpression = convertExpression(node.callee);
     if (isFullyQualifiedName(calleeExpression)) {
         const calleeName = calleeExpression.toString();
-        if (isMagicFunction(calleeName)) {
+        if (isIntrinsic(calleeName)) {
             let msg;
             if (calleeName === 'call_step') {
                 msg =
@@ -316,11 +308,11 @@ function convertCallExpression(node) {
         throw new WorkflowSyntaxError('Callee should be a qualified name', node.loc);
     }
 }
-export function isMagicFunction(calleeName) {
-    const magicFunctions = ['parallel', 'retry_policy', 'call_step'];
-    return magicFunctions.includes(calleeName);
+export function isIntrinsic(calleeName) {
+    const intrinsics = ['parallel', 'retry_policy', 'call_step'];
+    return intrinsics.includes(calleeName);
 }
-export function isMagicFunctionStatmentOnly(calleeName) {
+export function isIntrinsicStatment(calleeName) {
     const statementNames = ['parallel', 'retry_policy'];
     return statementNames.includes(calleeName);
 }
@@ -368,6 +360,11 @@ export function throwIfSpread(nodes) {
     const argumentExpressions = nodes.filter((x) => x?.type !== AST_NODE_TYPES.SpreadElement);
     return argumentExpressions;
 }
-export function asExpression(x) {
-    return isExpression(x) ? x : new PrimitiveExpression(x);
+export function convertVariableNameExpression(instance) {
+    const ex = convertExpression(instance);
+    if (ex.expressionType !== 'variableReference' &&
+        ex.expressionType !== 'member') {
+        throw new WorkflowSyntaxError('The left-hand side of an assignment must be a variable or member expression', instance.loc);
+    }
+    return ex;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transpiler/index.ts"],"names":[],"mappings":"AAaA,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAkBR"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transpiler/index.ts"],"names":[],"mappings":"AAcA,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAkBR"}

package/dist/transpiler/index.js

@@ -4,6 +4,7 @@ import { SubworkflowAST } from '../ast/steps.js';
 import { WorkflowSyntaxError } from '../errors.js';
 import { generateStepNames } from '../ast/stepnames.js';
 import { parseStatement } from './statements.js';
+import { transformAST } from './transformations.js';
 export function transpile(code, inputFile, tsconfigPath) {
     const parserOptions = {
         jsDocParsingMode: 'none',
@@ -51,8 +52,15 @@ function parseTopLevelStatement(node) {
     }
 }
 function parseSubworkflows(node) {
-    const nodeParams = node.params;
-    const workflowParams = nodeParams.map((param) => {
+    const workflowParams = parseWorkflowParams(node.params);
+    const steps = transformAST(parseStatement(node.body, {}));
+    if (steps.length === 0) {
+        throw new WorkflowSyntaxError('Empty subworkflow body is not allowed on GCP Workflows', node.body.loc);
+    }
+    return new SubworkflowAST(node.id.name, steps, workflowParams);
+}
+function parseWorkflowParams(nodeParams) {
+    return nodeParams.map((param) => {
         switch (param.type) {
             case AST_NODE_TYPES.Identifier:
                 if (param.optional) {
@@ -67,8 +75,6 @@ function parseSubworkflows(node) {
                 throw new WorkflowSyntaxError('Function parameter must be an identifier or an assignment', param.loc);
         }
     });
-    const steps = parseStatement(node.body, {});
-    return new SubworkflowAST(node.id.name, steps, workflowParams);
 }
 function parseSubworkflowDefaultArgument(param) {
     if (param.left.type !== AST_NODE_TYPES.Identifier) {

package/dist/transpiler/statements.d.ts

@@ -1,9 +1,10 @@
 import { TSESTree } from '@typescript-eslint/typescript-estree';
 import { StepName, WorkflowStepAST } from '../ast/steps.js';
 export interface ParsingContext {
-    breakTarget?: StepName;
-    continueTarget?: StepName;
+    readonly breakTarget?: StepName;
+    readonly continueTarget?: StepName;
+    readonly parallelNestingLevel?: number;
     finalizerTargets?: StepName[];
 }
-export declare function parseStatement(node: TSESTree.Statement, ctx: ParsingContext, postSteps?: WorkflowStepAST[]): WorkflowStepAST[];
+export declare function parseStatement(node: TSESTree.Statement, ctx: ParsingContext): WorkflowStepAST[];
 //# sourceMappingURL=statements.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../src/transpiler/statements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,QAAQ,EAAE,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAUL,QAAQ,EAMR,eAAe,EAChB,MAAM,iBAAiB,CAAA;AA6BxB,MAAM,WAAW,cAAc;IAE7B,WAAW,CAAC,EAAE,QAAQ,CAAA;IAEtB,cAAc,CAAC,EAAE,QAAQ,CAAA;IAKzB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,CAAA;CAC9B;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,GAAG,EAAE,cAAc,EACnB,SAAS,CAAC,EAAE,eAAe,EAAE,GAC5B,eAAe,EAAE,CAGnB"}
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../src/transpiler/statements.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,QAAQ,EAAE,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAWL,QAAQ,EAOR,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAkCxB,MAAM,WAAW,cAAc;IAE7B,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAA;IAE/B,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAA;IAGlC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAKtC,gBAAgB,CAAC,EAAE,QAAQ,EAAE,CAAA;CAC9B;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,GAAG,EAAE,cAAc,GAClB,eAAe,EAAE,CAEnB"}