ts2workflows 0.1.0 → 0.3.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,EAMR,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);
@@ -178,10 +179,12 @@ function callExpressionToStep(node, ctx) {
 }
 function callExpressionAssignStep(functionName, argumentsNode) {
     const argumentExpressions = argumentsNode.map(convertExpression);
-    const assignments = [
-        ['', new FunctionInvocationExpression(functionName, argumentExpressions)],
-    ];
-    return new AssignStepAST(assignments);
+    return new AssignStepAST([
+        [
+            '__temp',
+            new FunctionInvocationExpression(functionName, argumentExpressions),
+        ],
+    ]);
 }
 function callExpressionToCallStep(functionName, argumentsNode) {
     if (argumentsNode.length < 1 || argumentsNode[0].type !== ObjectExpression) {
@@ -324,7 +327,7 @@ function parseParallelOptions(node) {
     };
 }
 function generalExpressionToAssignStep(node) {
-    return new AssignStepAST([['', convertExpression(node)]]);
+    return new AssignStepAST([['__temp', convertExpression(node)]]);
 }
 function returnStatementToReturnStep(node) {
     assertType(node, ReturnStatement);

package/dist/transpiler/transformations.d.ts

@@ -7,7 +7,7 @@ import { WorkflowStepAST } from '../ast/steps.js';
  */
 export declare function transformAST(steps: WorkflowStepAST[]): WorkflowStepAST[];
 /**
- * Flatten switch conditions that contain a single next step.
+ * Merge a next step to the previous step.
  *
  * For example, transforms this:
  *

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,CAoBnB"}

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
@@ -123,7 +124,7 @@ function parseRetryPolicyNumber(record, keyName) {
     return primitiveValue;
 }
 /**
- * Flatten switch conditions that contain a single next step.
+ * Merge a next step to the previous step.
  *
  * For example, transforms this:
  *
@@ -141,6 +142,23 @@ 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 acc
+    }, [])
+  
+    */
     return steps.map((step) => (step.tag === 'switch' ? flattenNext(step) : step));
 }
 function flattenNext(step) {
@@ -196,7 +214,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 +423,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 +443,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 +491,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`.
 
@@ -145,7 +145,7 @@ is converted to an [assign step](https://cloud.google.com/workflows/docs/referen
       - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
 ```
 
-This syntax can be used to call [standard library functions](https://cloud.google.com/workflows/docs/reference/stdlib/overview), subworkflows or connectors.
+This syntax can be used to call [standard library functions](https://cloud.google.com/workflows/docs/reference/stdlib/overview), subworkflows or connectors. Note that Javascript runtime functions (such as `fetch()`, `console.error()` or `new XMLHttpRequest()`) are not available on Workflows.
 
 GCP Workflows language has two ways of calling functions and subworkflows: as expression in an [assign step](https://cloud.google.com/workflows/docs/reference/syntax/variables#assign-step) or as [call step](https://cloud.google.com/workflows/docs/reference/syntax/calls). They can mostly be used interchangeably. However, [blocking calls](https://cloud.google.com/workflows/docs/reference/syntax/expressions#blocking-calls) must be made as call steps. The transpiler tries to automatically output a call step when necessary.
 
@@ -175,7 +175,7 @@ main:
           severity: INFO
 ```
 
-Some Workflows standard library functions have names that are reserved keywords in Typescript. Those functions must be called with alternative names in ts2workflows source code:
+Some Workflows standard library functions have names that are reserved keywords in Typescript. Those functions must be called with alternative syntax in ts2workflows source code:
 
 - To generate a call to `default()` in Workflows code, use the nullish coalescing operator `??`.
 - To generete a call to `if()` in Workflows code, use the ternary operator `a ? b : c`.
@@ -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.3.0",
   "description": "Transpile Typescript code to GCP Workflows programs",
   "homepage": "https://github.com/aajanki/ts2workflows",
   "repository": {
@@ -19,7 +19,17 @@
     "build:functionmetadata": "tsx scripts/generateBlockingFunctionMetadata.ts",
     "lint": "eslint src test scripts",
     "format": "prettier . --write",
-    "test": "mocha"
+    "test": "mocha",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "prettier --write",
+      "eslint"
+    ],
+    "*.md": [
+      "prettier --write"
+    ]
   },
   "bin": "./dist/cli.js",
   "files": [
@@ -46,6 +56,8 @@
     "@typescript-eslint/parser": "^8.0.0",
     "chai": "^5.1.1",
     "eslint": "^9.10.0",
+    "husky": "^9.1.6",
+    "lint-staged": "^15.2.10",
     "mocha": "^10.4.0",
     "prettier": "^3.2.5",
     "rimraf": "^5.0.10",

package/types/workflowslib.d.ts

@@ -161,9 +161,15 @@ export declare namespace http {
 }
 
 export declare namespace json {
-  function decode(data: bytes | string): object
+  function decode(data: bytes | string): unknown
   function encode(
-    data: string | number | boolean | unknown[] | Record<string, unknown>,
+    data:
+      | string
+      | number
+      | boolean
+      | unknown[]
+      | Record<string, unknown>
+      | null,
     indent?:
       | boolean
       | {
@@ -172,7 +178,13 @@ export declare namespace json {
         },
   ): bytes
   function encode_to_string(
-    data: string | number | boolean | unknown[] | Record<string, unknown>,
+    data:
+      | string
+      | number
+      | boolean
+      | unknown[]
+      | Record<string, unknown>
+      | null,
     indent?:
       | boolean
       | {
@@ -188,16 +200,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 | null : 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 }
 }
 
@@ -242,7 +257,7 @@ export declare namespace text {
     index: number
     match: string
   }[]
-  function match_regexp(source: string, regexp: string): boolean
+  function match_regex(source: string, regexp: string): boolean
   function replace_all(source: string, substr: string, repl: string): string
   function replace_all_regex(
     source: string,
@@ -708,7 +723,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