ts2workflows 0.1.0 → 0.2.0

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transpiler/index.ts"],"names":[],"mappings":"AAyBA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAa9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transpiler/index.ts"],"names":[],"mappings":"AA0BA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAa9C"}

package/dist/transpiler/index.js

@@ -7,7 +7,7 @@ import { WorkflowSyntaxError } from '../errors.js';
 import { generateStepNames } from '../ast/stepnames.js';
 import { assertType } from './asserts.js';
 import { parseBlockStatement } from './statements.js';
-const { AssignmentPattern, ExportNamedDeclaration, FunctionDeclaration, Identifier, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, Literal, Program, TSTypeAliasDeclaration, TSInterfaceDeclaration, } = AST_NODE_TYPES;
+const { AssignmentPattern, ExportNamedDeclaration, FunctionDeclaration, Identifier, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, Literal, Program, TSDeclareFunction, TSTypeAliasDeclaration, TSInterfaceDeclaration, } = AST_NODE_TYPES;
 export function transpile(code) {
     const parserOptions = {
         jsDocParsingMode: 'none',
@@ -40,10 +40,11 @@ function parseTopLevelStatement(node) {
             }
         case TSInterfaceDeclaration:
         case TSTypeAliasDeclaration:
-            // Ignore "type" and "interface" declarations at the top-level
+        case TSDeclareFunction:
+            // Ignore "type", "interface" and "declare function" at the top-level
             return [];
         default:
-            throw new WorkflowSyntaxError(`Only function declarations, imports and type aliases allowed at the top level, encountered ${node?.type}`, node?.loc);
+            throw new WorkflowSyntaxError(`Only function definitions, imports and type aliases allowed at the top level, encountered ${node?.type}`, node?.loc);
     }
 }
 function parseSubworkflows(node) {

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

@@ -1 +1 @@
-{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../src/transpiler/statements.ts"],"names":[],"mappings":"AAEA,OAAO,EASL,QAAQ,EAOR,eAAe,EAEhB,MAAM,iBAAiB,CAAA;AAwDxB,MAAM,WAAW,cAAc;IAE7B,WAAW,CAAC,EAAE,QAAQ,CAAA;IAEtB,cAAc,CAAC,EAAE,QAAQ,CAAA;CAC1B;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,GAAG,EACT,GAAG,EAAE,cAAc,GAClB,eAAe,EAAE,CAKnB"}
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../src/transpiler/statements.ts"],"names":[],"mappings":"AAEA,OAAO,EASL,QAAQ,EAOR,eAAe,EAEhB,MAAM,iBAAiB,CAAA;AAyDxB,MAAM,WAAW,cAAc;IAE7B,WAAW,CAAC,EAAE,QAAQ,CAAA;IAEtB,cAAc,CAAC,EAAE,QAAQ,CAAA;CAC1B;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,GAAG,EACT,GAAG,EAAE,cAAc,GAClB,eAAe,EAAE,CAKnB"}

package/dist/transpiler/statements.js

@@ -8,7 +8,7 @@ import { transformAST } from './transformations.js';
 import { assertType } from './asserts.js';
 import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, } from './expressions.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
-const { ArrayExpression, ArrowFunctionExpression, AssignmentExpression, BlockStatement, BreakStatement, CallExpression, ContinueStatement, DoWhileStatement, EmptyStatement, ExpressionStatement, ForInStatement, ForOfStatement, FunctionDeclaration, Identifier, IfStatement, LabeledStatement, MemberExpression, ObjectExpression, ReturnStatement, SwitchCase, SwitchStatement, ThrowStatement, TryStatement, TSTypeAliasDeclaration, TSInterfaceDeclaration, VariableDeclaration, VariableDeclarator, WhileStatement, } = AST_NODE_TYPES;
+const { ArrayExpression, ArrowFunctionExpression, AssignmentExpression, BlockStatement, BreakStatement, CallExpression, ContinueStatement, DoWhileStatement, EmptyStatement, ExpressionStatement, ForInStatement, ForOfStatement, FunctionDeclaration, Identifier, IfStatement, LabeledStatement, MemberExpression, ObjectExpression, ReturnStatement, SwitchCase, SwitchStatement, ThrowStatement, TryStatement, TSDeclareFunction, TSTypeAliasDeclaration, TSInterfaceDeclaration, VariableDeclaration, VariableDeclarator, WhileStatement, } = AST_NODE_TYPES;
 export function parseBlockStatement(node, ctx) {
     assertType(node, BlockStatement);
     const body = node.body;
@@ -58,7 +58,8 @@ function parseStep(node, ctx) {
             throw new WorkflowSyntaxError('Functions must be defined at the top level of a source file', node.loc);
         case TSInterfaceDeclaration:
         case TSTypeAliasDeclaration:
-            // Ignore "type" and "interface" declarations
+        case TSDeclareFunction:
+            // Ignore "type", "interface" and "declare function"
             return [];
         default:
             throw new WorkflowSyntaxError(`TODO: encountered unsupported type: ${node.type}`, node.loc);

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;AAoBxB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAQxE;AA0JD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAEnB"}
+{"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;AA0JD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAEnB"}

package/dist/transpiler/transformations.js

@@ -3,6 +3,7 @@ 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';
+const Unmodified = Symbol();
 /**
  * Performs various transformations on the AST.
  *
@@ -10,7 +11,7 @@ import { blockingFunctions } from './generated/functionMetadata.js';
  * called on each nesting level separately.
  */
 export function transformAST(steps) {
-    return blockingCallsAsCallSteps(flattenPlainNextConditions(combineRetryBlocksToTry(mergeAssignSteps(mapLiteralsAsAssignSteps(steps)))));
+    return blockingCallsAsCallSteps(runtimeFunctionImplementation(flattenPlainNextConditions(combineRetryBlocksToTry(mergeAssignSteps(mapLiteralsAsAssignSteps(steps))))));
 }
 /**
  * Merge consecutive assign steps into one assign step
@@ -196,7 +197,6 @@ function createTempVariableGenerator() {
     const generator = () => `__temp${i++}`;
     return generator;
 }
-const Unmodified = Symbol();
 function replaceBlockingCalls(expression, generateName) {
     function replaceBlockingFunctionInvocations(ex) {
         if (ex.expressionType === 'functionInvocation') {
@@ -406,13 +406,14 @@ function mapLiteralsAsAssignSteps(steps) {
                 return value.expressionType === 'primitive';
             });
         }
-        else if (current.tag === 'raise') {
+        else if (current.tag === 'raise' || current.tag === 'return') {
             needsTransformation =
-                !isLiteral(current.value) && includesMapLiteral(current.value);
+                current.value !== undefined &&
+                    includesExtractableMapLiteral(current.value, true);
         }
         else if (current.tag === 'call') {
             if (current.args) {
-                needsTransformation = Object.values(current.args).some((ex) => !isLiteral(ex) && includesMapLiteral(ex));
+                needsTransformation = Object.values(current.args).some((ex) => includesExtractableMapLiteral(ex, true));
             }
         }
         if (needsTransformation) {
@@ -425,20 +426,34 @@ function mapLiteralsAsAssignSteps(steps) {
         return acc;
     }, []);
 }
-function includesMapLiteral(ex) {
+// Return true if the string representation of ex would include {}
+function includesExtractableMapLiteral(ex, parentAllowsMaps) {
     switch (ex.expressionType) {
         case 'primitive':
-            return isRecord(ex.value);
+            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;
+            }
         case 'binary':
-            return includesMapLiteral(ex.left) || includesMapLiteral(ex.right);
+            return (includesExtractableMapLiteral(ex.left, parentAllowsMaps) ||
+                includesExtractableMapLiteral(ex.right, parentAllowsMaps));
         case 'variableReference':
             return false;
         case 'unary':
-            return includesMapLiteral(ex.value);
+            return includesExtractableMapLiteral(ex.value, parentAllowsMaps);
         case 'functionInvocation':
-            return ex.arguments.some(includesMapLiteral);
+            return ex.arguments.some((x) => includesExtractableMapLiteral(x, false));
         case 'member':
-            return includesMapLiteral(ex.object) || includesMapLiteral(ex.property);
+            return (includesExtractableMapLiteral(ex.object, false) ||
+                includesExtractableMapLiteral(ex.property, false));
     }
 }
 function replaceMapLiterals(expression, generateName) {
@@ -459,3 +474,25 @@ function replaceMapLiterals(expression, generateName) {
         assignSteps,
     };
 }
+/**
+ * Replace `Array.isArray(x)` with `get_type(x) == "list"`
+ */
+function runtimeFunctionImplementation(steps) {
+    return steps.reduce((acc, current) => {
+        const transformedSteps = transformStepExpressions(current, (ex) => [
+            [],
+            transformExpression(ex, replaceIsArray),
+        ]);
+        acc.push(...transformedSteps);
+        return acc;
+    }, []);
+}
+function replaceIsArray(ex) {
+    if (ex.expressionType === 'functionInvocation' &&
+        ex.functionName === 'Array.isArray') {
+        return new BinaryExpression(new FunctionInvocationExpression('get_type', ex.arguments), '==', new PrimitiveExpression('list'));
+    }
+    else {
+        return Unmodified;
+    }
+}

package/language_reference.md

@@ -2,7 +2,7 @@
 
 ts2workflow converts Typescript source code to GCP Workflows YAML syntax. Only a subset of Typescript language features are supported. This page documents supported Typescript features and shows examples of the generted Workflows YAML output.
 
-Functions provided by a Javascript runtime (`console.log`, `setInterval`, etc) are not available.
+Most functions provided by a Javascript runtime (`console.log()`, `setInterval()`, etc) are not available.
 
 Type annotations are allowed. Type checking is done by the compiler but the types dont't affect the generated Workflows code.
 
@@ -22,7 +22,7 @@ Semicolon can be used as optional statement delimitter.
 
 ### Array type
 
-⚠️ Arrays are not objects. In particular, methods like `array.map()` and `array.concat()` are not available.
+⚠️ Arrays are not objects. In particular, methods like `[].map()` and `[].concat()` are not available.
 
 ⚠️ Accessing out-of-bounds index will cause an IndexError at runtime unlike in Typescript where out-of-bounds access would return `undefined`.
 
@@ -689,7 +689,19 @@ function read_from_env() {
 
 At the moment, type annotations are provided for some [connectors](https://cloud.google.com/workflows/docs/reference/googleapis) but not for all of them.
 
-## Special run-time functions
+### Runtime functions
+
+This section describes the few standard Javascript runtime functions that are available. Most are not.
+
+### Array.isArray()
+
+```typescript
+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()` allows the type inference to learn if `arg` is array or not.
+
+## Language extension functions
 
 ts2workflows provides some special functions for implementing features that are not directly supported by Typescript language features. The type annotations for these functions can be imported from ts2workflows/types/workflowslib:
 
@@ -701,15 +713,18 @@ import {
 } from 'ts2workflows/types/workflowslib'
 ```
 
-### call_step
+### call_step()
 
 ```typescript
-function call_step(func: Function, args: Record<string, unknown>): unknown
+function call_step<T, A extends any[]>(
+  func: (...args: A) => T,
+  arguments: Record<string, unknown>,
+): T
 ```
 
 The `call_step` function outputs a [call step](https://cloud.google.com/workflows/docs/reference/syntax/calls).
 
-### parallel
+### parallel()
 
 ```typescript
 function parallel(
@@ -724,7 +739,7 @@ function parallel(
 
 The `parallel` function executes code blocks in parallel (using [parallel step](https://cloud.google.com/workflows/docs/reference/syntax/parallel-steps)). See the previous sections covering parallel branches and iteration.
 
-### retry_policy
+### retry_policy()
 
 ```typescript
 function retry_policy(
@@ -760,9 +775,9 @@ const var1 = 1 // This is a comment
 
 ts2workflows supports only a subset of all Typescript language features. Some examples that are not (yet) supported by ts2workflows:
 
-- Functions provided by a Javascript runtime (`console.log`, `setInterval`, etc) are not available. Only the [GCP Workflows standard library functions](https://cloud.google.com/workflows/docs/reference/stdlib/overview) and [connectors](https://cloud.google.com/workflows/docs/reference/googleapis) are available.
+- Most functions provided by a Javascript runtime (`console.log()`, `setInterval()`, etc) are not available. Only the [GCP Workflows standard library functions](https://cloud.google.com/workflows/docs/reference/stdlib/overview) and [connectors](https://cloud.google.com/workflows/docs/reference/googleapis) are available.
 - Classes (`class`) are not supported
-- Arrays and maps are not objects. In particular, arrays don't have methods such as `array.push()`, `array.map()`, etc.
+- Arrays and maps are not objects. In particular, arrays don't have methods such as `[].push()`, `[].map()`, etc.
 - Functions (subworkflows) are not first-class objects. Functions can not be assigned to a variable or passed to other functions
 - Update expressions (`x++` and similar) are not supported
 - Destructuring (`[a, b] = func()`) is not supported

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts2workflows",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Transpile Typescript code to GCP Workflows programs",
   "homepage": "https://github.com/aajanki/ts2workflows",
   "repository": {

package/types/workflowslib.d.ts

@@ -188,16 +188,19 @@ export declare namespace list {
 }
 
 export declare namespace map {
-  function _delete<T1>(map: Record<string, T1>, key: string): Record<string, T1>
-  export function get<T2>(map: Record<string, T2>, keys: string | string[]): T2
-  export function merge<S1, S2>(
-    first: Record<string, S1>,
-    second: Record<string, S2>,
-  ): Record<string, S1 | S2>
-  export function merge_nested<S3, S4>(
-    first: Record<string, S3>,
-    second: Record<string, S4>,
-  ): Record<string, S3 | S4>
+  function _delete<T>(map: Record<string, T>, key: string): Record<string, T>
+  export function get<T, K extends string | string[]>(
+    map: Record<string, T>,
+    keys: K,
+  ): K extends string ? T : unknown
+  export function merge<T, U>(
+    first: Record<string, T>,
+    second: Record<string, U>,
+  ): Record<string, T | U>
+  export function merge_nested<T, U>(
+    first: Record<string, T>,
+    second: Record<string, U>,
+  ): Record<string, T | U>
   export { _delete as delete }
 }
 
@@ -708,7 +711,7 @@ export declare function retry_policy(
       },
 ): void
 
-export declare function call_step(
-  func: Function,
+export declare function call_step<T, A extends any[]>(
+  func: (...args: A) => T,
   arguments: Record<string, unknown>,
-): unknown
+): T