ts2workflows 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -0,0 +1,117 @@
+# ts2workflows changelog
+
+## Version 0.13.0 - 2025-10-12
+
+Fixes:
+
+- function identifiers (e.g. in call_step and parallel) are included in the `--link` output
+- Improve type annotations of map.\* functions
+
+## Version 0.12.0 - 2025-08-30
+
+New features:
+
+- New command line option `--link` generates self-contained YAML files (all needed subworkflows in one file)
+- Accepts Typescript's `satisfies` expression and `debugger` statement. They do not affect the YAML output.
+
+Fixes:
+
+- Empty body in an `if` statements generated invalid code
+- In certain cases nested map literals generated invalid code
+- Some expressions with many extractable sub-expressions (map literals, blocking calls) generated invalid code because a temporary variable was re-used incorrectly
+- Empty statements are accepted at the top level
+- Ignore extra arguments in blocking function calls in all cases. Previously, extra arguments were ignored in some cases but threw errors in other cases.
+- Call expressions in optional chaining (`data?.getPerson()?.name`) now result in error. Previously, they were incorrectly treated as non-optional in the generated code.
+- Fixed code generation for an object rest element nested in an array pattern: `const [{...rest}] = data`
+
+## Version 0.11.0 - 2025-06-28
+
+Breaking changes:
+
+- Requires Node 20 or newer and Typescript 5.4.0 or newer
+- retry_policy() must be called inside a try block, not after
+- Variable declarations with `var` are not supported, only `let` and `const`
+- Step name numbering starts from 1 at the start of each subworkflow
+
+Fixes:
+
+- Type annotation fixes in workflowslib
+
+## Version 0.10.0 - 2025-04-28
+
+- Accept binary expressions as properties in assignments: `a[i + 4] = 1` (regression in 0.9.0)
+- Evaluate side-effects only once on the left-hand side in compound assignments: `x[f()] += 1`
+- Fix calling `call_step()` on the right-hand side of a compound assignment: `x += call_step(sum, {a: 10, b: 11})`
+- Output an error if a subworkflow is empty because empty body is not allowed on GCP
+
+## Version 0.9.0 - 2025-04-23
+
+Breaking changes:
+
+- `True`, `TRUE`, `False` and `FALSE` no longer are synonyms for `true` and `false`
+
+New features:
+
+- Array and object destructuring: `const [a, b] = getArray()`
+
+Fixes:
+
+- Fix a deployment error caused by the same temp variable name being used inside and outside of a parallel branch
+
+## Version 0.8.0 - 2025-03-03
+
+- Multiple input files can be given on the command line
+- Argument `--outdir` sets the output directory
+- Argument `--project` defines the TSConfig location for the source files
+- `--(no-)generated-file-comment`: optionally include a comment about the output file being generated
+- `--version` prints the correct version number
+- Accept instantiation expressions `func<TYPE>`
+
+## Version 0.7.0 - 2025-02-02
+
+- `typeof` operator
+- `null` is allowed as interpolated value in template literal `${null}`
+- Accept `undefined` as a function argument default argument: `func(a: number | undefined = undefined)`
+- Optional function arguments: `func(a?: number)`
+
+## Version 0.6.0 - 2025-01-09
+
+Breaking changes:
+
+- retry_policy() takes a plain policy function name instead of a {policy: ...} object
+
+Fixes:
+
+- The try statement supports a finally block
+- Support empty body in a catch block
+- retry_policy() parameter values can now be expressions in addition to number literals
+- 0, "", false and null can now be used as subworkflow parameter default values
+- Type annotation fixes
+
+## Version 0.5.0 - 2024-11-09
+
+- Move nested map expressions to assign steps where necessary
+- Array.isArray() is transformed correcly in nested expressions
+
+## Version 0.4.0 - 2024-11-05
+
+- Optional chaining a?.b is converted to map.get(a, "b")
+- Non-null assertions person!.name is accepted but ignored to the transpiler
+- Merge a next step to a preceeding assign step
+- Accept a single-statement body (body without braces {}) in if, while, etc
+- Assign the result of call_step() to a member variable: obj.property = call_step()
+- parallel() and retry_policy() special functions can only be used as statements
+- Better error messages on RegExp, BigInt, spread syntax and other non-supported Javascript features
+
+## Version 0.3.0 - 2024-10-19
+
+- Function invocations no longer generate invalid empty variable names
+- Include more utility types: ReturnType, Partial, Required, etc.
+- Type annotation fixes
+
+## Version 0.2.0 - 2024-10-09
+
+- Reduce cases where maps are needlessly split off into assign statements
+- Accept (but ignore) "declare function"
+- Implemented Array.isArray()
+- Fixes to type annotations

package/dist/transpiler/linker.js

@@ -27,15 +27,19 @@ function findFunctionsRecursively(seen, typeChecker, node) {
 function findNestedFunctions(typeChecker, node) {
     const functionDeclarations = [];
     function visit(node) {
-        if (ts.isCallExpression(node)) {
-            const sig = typeChecker.getResolvedSignature(node);
-            const decl = sig?.getDeclaration();
-            if (decl && ts.isFunctionDeclaration(decl)) {
-                functionDeclarations.push(decl);
-            }
+        // isImportOrExportSpecifier() check ignores foo in "import { foo } from ..."
+        if (ts.isIdentifier(node) && !ts.isImportOrExportSpecifier(node.parent)) {
+            functionDeclarations.push(...functionDeclarationsForIdentifier(typeChecker, node));
         }
         ts.forEachChild(node, visit);
     }
     visit(node);
     return functionDeclarations;
 }
+function functionDeclarationsForIdentifier(typeChecker, node) {
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    const isAliased = symbol && symbol.flags & ts.SymbolFlags.Alias;
+    const symbol2 = isAliased ? typeChecker.getAliasedSymbol(symbol) : symbol;
+    const declarations = symbol2?.getDeclarations() ?? [];
+    return declarations.filter(ts.isFunctionDeclaration);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts2workflows",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Transpile Typescript code to GCP Workflows programs",
   "homepage": "https://github.com/aajanki/ts2workflows",
   "repository": {
@@ -48,6 +48,7 @@
     "types",
     "README.md",
     "language_reference.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "author": "Antti Ajanki",
@@ -77,13 +78,16 @@
     "rimraf": "^6.0.1",
     "source-map-support": "^0.5.21",
     "tsx": "^4.20.5",
+    "typescript": "^5.5.4",
     "typescript-eslint": "^8.0.0"
   },
+  "peerDependencies": {
+    "typescript": ">=5.5.4 <6.0.0"
+  },
   "dependencies": {
     "@typescript-eslint/typescript-estree": "^8.0.0",
     "commander": "^14.0.0",
-    "ramda": "^0.31.3",
-    "typescript": "^5.5.4",
+    "ramda": "^0.32.0",
     "yaml": "^2.4.2"
   }
 }

package/types/workflowslib.d.ts

@@ -210,20 +210,33 @@ export declare namespace list {
   function prepend<T, U>(objs: T[], val: U): (T | U)[]
 }
 
+// Typescript `object` is actually too liberal as it includes arrays. Workflows
+// will throw an error if the input is an array.
 export declare namespace map {
-  function _delete<T>(map: Record<string, T>, key: string): Record<string, T>
-  // map.get() with a string key, returns a property value or null
-  export function get<T>(map: Record<string, T>, keys: string): T | null
-  // map.get() with string[] key or non-object lookup, the return type is unknown
-  export function get(map: any, keys: string | string[]): WorkflowsValue
-  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>
+  // If K is a literal key of T, return the exact type.
+  // Otherwise the best we can do is to return a Record with
+  // any of T property values.
+  function _delete<T extends object, K extends string>(
+    map: T,
+    key: K,
+  ): K extends keyof T ? Omit<T, K> : Record<string, T[keyof T]>
+  // map.get() with a string key.
+  // If K is a literal key of T, this returns the exact type T[K].
+  // Otherwise returns less exact union of all T property types or null.
+  export function get<T extends object, K extends string>(
+    map: T,
+    keys: K,
+  ): K extends keyof T ? T[K] : T[keyof T] | null
+  // map.get() with string[] key, the return type is not inferred
+  export function get(map: object, keys: string[]): WorkflowsValue
+  export function merge<T extends object, U extends object>(
+    first: T,
+    second: U,
+  ): T & U
+  export function merge_nested<T extends object, U extends object>(
+    first: T,
+    second: U,
+  ): T & U
   export { _delete as delete }
 }