ts2workflows 0.13.0 → 0.15.0

package/dist/transpiler/index.js

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import { AST_NODE_TYPES, parseAndGenerateServices, } from '@typescript-eslint/typescript-estree';
 import ts from 'typescript';
 import * as YAML from 'yaml';
-import { InternalTranspilingError, IOError, WorkflowSyntaxError, } from '../errors.js';
+import { InternalTranspilingError, IOError, syntaxErrorWithText, WorkflowSyntaxError, } from '../errors.js';
 import { SubworkflowStatements, WorkflowApp, } from '../ast/workflows.js';
 import { parseStatement } from './parsestatement.js';
 import { transformAST } from './transformations.js';
@@ -12,11 +12,14 @@ import { isPrimitive, nullEx } from '../ast/expressions.js';
 import { convertExpression } from './parseexpressions.js';
 import { generateStepNames } from './stepnames.js';
 const workflowCache = new Map();
-export function transpile(input, tsconfigPath, linkSubworkflows) {
-    const { ast, services } = parseMainFile(input, tsconfigPath);
-    const inputWorkflow = generateStepNames(ast.body.flatMap(parseTopLevelStatement));
-    if (linkSubworkflows && tsconfigPath && services.program && input.filename) {
-        const canonicalInput = path.join(process.cwd(), input.filename);
+export function transpile(filename, sourceCode, tsconfigPath, linkSubworkflows) {
+    const { ast, services } = parseMainFile(filename, sourceCode, tsconfigPath);
+    const inputWorkflow = esProgramToWorkflowAppEnrichErrors(ast, filename, sourceCode);
+    if (linkSubworkflows &&
+        tsconfigPath &&
+        services.program !== null &&
+        filename) {
+        const canonicalInput = path.join(process.cwd(), filename);
         workflowCache.set(canonicalInput, inputWorkflow);
         const subworkflows = generateLinkedOutput(canonicalInput, tsconfigPath, services.program);
         const combinedWorkflow = new WorkflowApp(subworkflows);
@@ -29,24 +32,40 @@ export function transpile(input, tsconfigPath, linkSubworkflows) {
 export function transpileText(sourceCode) {
     const parserOptions = eslintParserOptions();
     const { ast } = parseAndGenerateServices(sourceCode, parserOptions);
-    const workflow = generateStepNames(ast.body.flatMap(parseTopLevelStatement));
+    const workflow = esProgramToWorkflowAppEnrichErrors(ast, '<stdin>', sourceCode);
     return toYAMLString(workflow);
 }
-function parseMainFile(input, tsconfigPath) {
-    const parserOptions = eslintParserOptions(input.filename, tsconfigPath);
-    if (tsconfigPath && input.filename) {
+function esProgramToWorkflowAppEnrichErrors(program, filename, sourceCode) {
+    try {
+        return esProgramToWorkflowApp(program);
+    }
+    catch (error) {
+        if (error instanceof WorkflowSyntaxError) {
+            throw syntaxErrorWithText(error, filename, sourceCode);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+function esProgramToWorkflowApp(program) {
+    return generateStepNames(program.body.flatMap(parseTopLevelStatement));
+}
+function parseMainFile(filename, sourceCode, tsconfigPath) {
+    const parserOptions = eslintParserOptions(filename, tsconfigPath);
+    if (tsconfigPath) {
         const cwd = process.cwd();
         const configJSON = JSON.parse(fs.readFileSync(path.join(cwd, tsconfigPath), 'utf-8'));
         const { options } = ts.parseJsonConfigFileContent(configJSON, ts.sys, cwd);
-        const program = ts.createProgram([input.filename], options);
-        const mainSourceFile = program.getSourceFile(input.filename);
+        const program = ts.createProgram([filename], options);
+        const mainSourceFile = program.getSourceFile(filename);
         if (mainSourceFile === undefined) {
-            throw new IOError(`Source file ${input.filename} not found`, 'ENOENT');
+            throw new IOError(`Source file ${filename} not found`, 'ENOENT');
         }
         return parseAndGenerateServices(mainSourceFile, parserOptions);
     }
     else {
-        return parseAndGenerateServices(input.read(), parserOptions);
+        return parseAndGenerateServices(sourceCode, parserOptions);
     }
 }
 function eslintParserOptions(inputFile, tsconfigPath) {
@@ -110,7 +129,7 @@ function getCachedWorkflow(filename, tsconfigPath) {
         const parserOptions = eslintParserOptions(filename, tsconfigPath);
         const code = fs.readFileSync(filename, 'utf8');
         const { ast } = parseAndGenerateServices(code, parserOptions);
-        const workflow = generateStepNames(ast.body.flatMap(parseTopLevelStatement));
+        const workflow = esProgramToWorkflowAppEnrichErrors(ast, filename, code);
         workflowCache.set(filename, workflow);
         return workflow;
     }

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

@@ -1 +1 @@
-{"version":3,"file":"parseexpressions.d.ts","sourceRoot":"","sources":["../../src/transpiler/parseexpressions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAkB,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAGL,UAAU,EAGV,aAAa,EACb,gBAAgB,EAChB,2BAA2B,EAc5B,MAAM,uBAAuB,CAAA;AAG9B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,GAAG,UAAU,CAmE3E;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,aAAa,CA8Bf;AAmJD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,gBAAgB,CAOlB;AA8JD,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGvD;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGhE;AA8CD,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,wBAAwB,CACtC,IAAI,EAAE,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,iBAAiB,GACrD,QAAQ,CAAC,UAAU,CAMrB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,UAAU,GACxB,2BAA2B,GAAG,gBAAgB,CAWhD"}
+{"version":3,"file":"parseexpressions.d.ts","sourceRoot":"","sources":["../../src/transpiler/parseexpressions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAkB,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAGL,UAAU,EAGV,aAAa,EACb,gBAAgB,EAChB,2BAA2B,EAc5B,MAAM,uBAAuB,CAAA;AAG9B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,GAAG,UAAU,CAmE3E;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,aAAa,CAmCf;AAmJD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,gBAAgB,GAC9B,gBAAgB,CAOlB;AA2KD,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGvD;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAGhE;AA8CD,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,wBAAwB,CACtC,IAAI,EAAE,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,iBAAiB,GACrD,QAAQ,CAAC,UAAU,CAMrB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,UAAU,GACxB,2BAA2B,GAAG,gBAAgB,CAWhD"}

package/dist/transpiler/parseexpressions.js

@@ -69,6 +69,10 @@ export function convertObjectExpression(node) {
             typeof key.value === 'string') {
             keyPrimitive = key.value;
         }
+        else if (key.type === AST_NODE_TYPES.Literal &&
+            typeof key.value === 'number') {
+            keyPrimitive = key.value.toString();
+        }
         else {
             throw new WorkflowSyntaxError(`Map keys must be identifiers or strings, encountered: ${key.type}`, key.loc);
         }
@@ -286,13 +290,22 @@ function convertCallExpression(node) {
             }
             throw new WorkflowSyntaxError(msg, node.callee.loc);
         }
-        const argumentExpressions = throwIfSpread(node.arguments).map(convertExpression);
+        const argumentExpressions = throwIfSpread(node.arguments).map(convertExpressionOrUndefined);
         return functionInvocationEx(calleeName, argumentExpressions);
     }
     else {
         throw new WorkflowSyntaxError('Callee should be a qualified name', node.loc);
     }
 }
+function convertExpressionOrUndefined(instance) {
+    if (instance.type === TSESTree.AST_NODE_TYPES.Identifier &&
+        instance.name === 'undefined') {
+        return undefined;
+    }
+    else {
+        return convertExpression(instance);
+    }
+}
 export function isIntrinsic(calleeName) {
     const intrinsics = ['parallel', 'retry_policy', 'call_step'];
     return intrinsics.includes(calleeName);
@@ -310,7 +323,7 @@ function convertConditionalExpression(node) {
 function convertTemplateLiteralToExpression(node) {
     const stringTerms = node.quasis
         .map((x) => x.value.cooked)
-        .map((x) => stringEx(x));
+        .map((x) => stringEx(x ?? ''));
     const templateTerms = node.expressions
         .map(convertExpression)
         .map((ex) => functionInvocationEx('default', [ex, stringEx('null')]));

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

@@ -1 +1 @@
-{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AAmBA,OAAO,EAcL,iBAAiB,EAClB,MAAM,sBAAsB,CAAA;AAG7B;;GAEG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,iBAAiB,EAAE,GAC9B,iBAAiB,EAAE,CAUrB"}
+{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AAoBA,OAAO,EAcL,iBAAiB,EAClB,MAAM,sBAAsB,CAAA;AAG7B;;GAEG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,iBAAiB,EAAE,GAC9B,iBAAiB,EAAE,CAUrB"}

package/dist/transpiler/transformations.js

@@ -1,6 +1,6 @@
 import * as R from 'ramda';
 import { InternalTranspilingError } from '../errors.js';
-import { binaryEx, functionInvocationEx, listEx, mapEx, memberEx, stringEx, unaryEx, variableReferenceEx, } from '../ast/expressions.js';
+import { binaryEx, functionInvocationEx, listEx, mapEx, memberEx, nullEx, stringEx, unaryEx, variableReferenceEx, } from '../ast/expressions.js';
 import { applyNested, AssignStatement, FunctionInvocationStatement, IfStatement, LabelledStatement, } from '../ast/statements.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
 /**
@@ -8,7 +8,7 @@ import { blockingFunctions } from './generated/functionMetadata.js';
  */
 export function transformAST(statements) {
     const tempGen = createTempVariableGenerator();
-    const transform = R.pipe(R.chain(mapLiteralsAsAssigns(tempGen)), mergeAssigns, R.chain(intrinsicFunctionImplementation), R.chain(blockingCallsAsFunctionCalls(tempGen)));
+    const transform = R.pipe(R.chain(mapLiteralsAsAssigns(tempGen)), R.chain(intrinsicFunctionImplementation), R.chain(blockingCallsAsFunctionCalls(tempGen)), mergeAssigns);
     return transform(statements.map((s) => applyNested(transformAST, s)));
 }
 /**
@@ -206,7 +206,7 @@ function replaceBlockingCalls(generateName, expression) {
         }
         const blockingCallArgumentNames = blockingFunctions.get(ex.functionName);
         if (blockingCallArgumentNames) {
-            const nameAndValue = R.zip(blockingCallArgumentNames, ex.arguments);
+            const nameAndValue = R.zip(blockingCallArgumentNames, ex.arguments).filter(isDefinedArgument);
             const callArgs = R.fromPairs(nameAndValue);
             const tempCallResultVariable = generateName();
             callStatements.push(new FunctionInvocationStatement(ex.functionName, callArgs, tempCallResultVariable));
@@ -223,6 +223,9 @@ function replaceBlockingCalls(generateName, expression) {
         transformExpression(replaceBlockingFunctionInvocations, expression),
     ];
 }
+function isDefinedArgument(x) {
+    return x[1] !== undefined;
+}
 /**
  * Search for blocking calls in expressions and replace them with a call + variable.
  *
@@ -258,6 +261,7 @@ function blockingCallsAsFunctionCalls(generateTempName) {
  */
 function transformExpression(transform, ex) {
     const nestedTr = (y) => transformExpression(transform, y);
+    const nestedTr2 = R.ifElse((R.isNil), () => undefined, nestedTr);
     switch (ex.tag) {
         case 'string':
         case 'number':
@@ -272,7 +276,7 @@ function transformExpression(transform, ex) {
         case 'binary':
             return transform(binaryEx(nestedTr(ex.left), ex.binaryOperator, nestedTr(ex.right)));
         case 'functionInvocation':
-            return transform(functionInvocationEx(ex.functionName, ex.arguments.map(nestedTr)));
+            return transform(functionInvocationEx(ex.functionName, ex.arguments.map(nestedTr2)));
         case 'member':
             return transform(memberEx(nestedTr(ex.object), nestedTr(ex.property), ex.computed));
         case 'unary':
@@ -375,11 +379,19 @@ function extractMapsInMap(map, generateName, nestingLevel) {
 }
 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);
+        if (arg === undefined) {
+            acc.expressions.push(undefined);
+        }
+        else {
+            const { transformedExpression, tempVariables } = extractNestedMaps(arg, generateName, nestingLevel + 1);
+            acc.expressions.push(transformedExpression);
+            acc.temps.push(...tempVariables);
+        }
         return acc;
-    }, { expressions: [], temps: [] });
+    }, {
+        expressions: [],
+        temps: [],
+    });
     return {
         transformedExpression: functionInvocationEx(ex.functionName, expressions),
         tempVariables: temps,
@@ -408,13 +420,13 @@ function extractNestedMapUnary(ex, generateName, nestingLevel) {
         tempVariables,
     };
 }
-/**
- * Replace `Array.isArray(x)` with `get_type(x) == "list"`
- */
 const intrinsicFunctionImplementation = expandExpressionToStatements((ex) => [
     [],
-    transformExpression(replaceIsArray, ex),
+    transformExpression(R.pipe(replaceIsArray, replaceArrayIncludes), ex),
 ]);
+/**
+ * Replace `Array.isArray(x)` with `get_type(x) == "list"`
+ */
 function replaceIsArray(ex) {
     if (ex.tag === 'functionInvocation' && ex.functionName === 'Array.isArray') {
         return binaryEx(functionInvocationEx('get_type', ex.arguments), '==', stringEx('list'));
@@ -423,3 +435,16 @@ function replaceIsArray(ex) {
         return ex;
     }
 }
+/**
+ * Replace `Array.includes(arr, x)` with `x in arr`
+ */
+function replaceArrayIncludes(ex) {
+    if (ex.tag === 'functionInvocation' && ex.functionName === 'Array.includes') {
+        const arrayEx = ex.arguments[0] ?? nullEx;
+        const valueEx = ex.arguments[1] ?? nullEx;
+        return binaryEx(valueEx, 'in', arrayEx);
+    }
+    else {
+        return ex;
+    }
+}

package/language_reference.md

@@ -72,6 +72,23 @@ name === 'Bean'
 sys.get_env('GOOGLE_CLOUD_PROJECT_ID')
 ```
 
+### Member expression
+
+To get a value in an array, use the following code:
+
+```javasript
+const val = arr[2];
+```
+
+To get a value in a map, use either of following:
+
+```javasript
+const val = obj.name;
+const val2 = obj["name"];
+```
+
+⚠️ Numeric keys in maps are not cast to strings like in Typescript. It's best not to use numeric keys because GCP Workflows throws errors on numeric keys.
+
 ## Operators
 
 | Operator     | Description                                        |
@@ -880,7 +897,15 @@ This section describes the few standard Javascript runtime functions that are av
 Array.isArray(arg: any): arg is any[]
 ```
 
-Gets converted to the comparison `get_type(arg) == "list"`. Unlike a direct call to `get_type()`, `Array.isArray()` acts a type guard and allows narrowing the `arg` type to an array.
+Returns true, if arg is an array, and false otherwise. `Array.isArray` gets converted to the following comparison on Workflows code: `get_type(arg) == "list"`. Unlike a direct call to `get_type()`, `Array.isArray()` acts a type guard in Typescript and allows narrowing the type of `arg` to an array.
+
+### Array.includes()
+
+```typescript
+Array.includes<T>(arr: Array<T>, x: T): boolean
+```
+
+Returns true, if the array `arr` contains the value `x`, and false otherwise. This static Array method should be used instead of `arr.includes()`, which won't work in Workflows, because arrays in Workflows don't have methods. `Array.includes()` is converted to `x in arr` in the outputted Workflows code.
 
 ## Compiler intrinsics
 
@@ -925,19 +950,7 @@ The `parallel` function executes code blocks in parallel using a [parallel step]
 ### retry_policy()
 
 ```typescript
-function retry_policy(
-  params:
-    | ((errormap: Record<string, any>) => void)
-    | {
-        predicate: (errormap: Record<string, any>) => boolean
-        max_retries: number
-        backoff: {
-          initial_delay: number
-          max_delay: number
-          multiplier: number
-        }
-      },
-): void
+function retry_policy(params: RetryPolicy): void
 ```
 
 A retry policy can be attached to a `try`-`catch` block by calling `retry_policy` inside the `try` block. ts2workflows ignores `retry_policy` everywhere else.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts2workflows",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Transpile Typescript code to GCP Workflows programs",
   "homepage": "https://github.com/aajanki/ts2workflows",
   "repository": {
@@ -20,7 +20,7 @@
     "lint": "eslint src test scripts",
     "format": "prettier . --write",
     "test": "mocha",
-    "test-coverage": "nyc --reporter=text --reporter=html mocha",
+    "test:coverage": "nyc --reporter=text --reporter=html mocha",
     "prepare": "husky && npm run build"
   },
   "lint-staged": {
@@ -73,7 +73,7 @@
     "husky": "^9.1.6",
     "lint-staged": "^16.1.2",
     "mocha": "^11.1.0",
-    "nyc": "^17.1.0",
+    "nyc": "^18.0.0",
     "prettier": "^3.2.5",
     "rimraf": "^6.0.1",
     "source-map-support": "^0.5.21",

package/types/global.d.ts

@@ -38,6 +38,7 @@ declare global {
 
   interface ArrayConstructor {
     isArray(arg: any): arg is any[]
+    includes<T>(arr: Array<T>, x: T): boolean
   }
 
   var Array: ArrayConstructor