ts2workflows 0.7.0 → 0.9.0

package/dist/cli.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { program } from 'commander';
 import { transpile } from './transpiler/index.js';
 import { WorkflowSyntaxError } from './errors.js';
@@ -7,11 +9,16 @@ import { TSError } from '@typescript-eslint/typescript-estree';
 function parseArgs() {
     program
         .name('ts2workflow')
-        .version('0.1.0')
+        .version(versionFromPackageJson())
         .description('Transpile a Typescript program into GCP Workflows YAML syntax.')
-        .argument('[FILES]', 'Path to source file(s) to compile. If not given, reads from stdin.');
-    program.parse();
+        .option('--project <path>', 'Path to TSConfig for the Typescript sources files.')
+        .option('--outdir <path>', 'Specify an output directory for where transpilation result are written.')
+        .option('--generated-file-comment', 'Include a comment stating that the result is a generated file', true)
+        .option('--no-generated-file-comment', "Don't include a comment about file being generated")
+        .argument('[FILES...]', 'Path to source file(s) to compile. If not given, reads from stdin.')
+        .parse();
     return {
+        ...program.opts(),
         sourceFiles: program.args,
     };
 }
@@ -25,32 +32,27 @@ function cliMain() {
         files = args.sourceFiles;
     }
     files.forEach((inputFile) => {
-        const inp = inputFile === '-' ? process.stdin.fd : inputFile;
-        let sourceCode = '';
         try {
-            sourceCode = fs.readFileSync(inp, 'utf8');
-            console.log(transpile(sourceCode));
-        }
-        catch (err) {
-            if (isIoError(err, 'ENOENT')) {
-                console.error(`Error: "${inp}" not found`);
-                process.exit(1);
-            }
-            else if (isIoError(err, 'EISDIR')) {
-                console.error(`Error: "${inp}" is a directory`);
+            const transpiled = generateTranspiledText(inputFile, args.generatedFileComment, args.project);
+            if (transpiled === undefined) {
                 process.exit(1);
             }
-            else if (isIoError(err, 'EAGAIN') && inp === process.stdin.fd) {
-                // Reading from stdin if there's no input causes error. This is a bug in node
-                console.error('Error: Failed to read from stdin');
-                process.exit(1);
-            }
-            else if (err instanceof WorkflowSyntaxError) {
-                prettyPrintSyntaxError(err, inputFile, sourceCode);
-                process.exit(1);
-            }
-            else if (err instanceof TSError) {
-                prettyPrintSyntaxError(err, inputFile, sourceCode);
+            writeOutput(transpiled, inputFile, args.outdir);
+        }
+        catch (err) {
+            if (isIoError(err)) {
+                let message;
+                if ('code' in err && err.code === 'EAGAIN' && inputFile === '-') {
+                    // Reading from stdin if there's no input causes error. This is a bug in node
+                    message = 'Error: Failed to read from stdin';
+                }
+                else if ('code' in err && err.code === 'EISDIR') {
+                    message = `Error: "${inputFile}" is a directory`;
+                }
+                else {
+                    message = err.message;
+                }
+                console.error(message);
                 process.exit(1);
             }
             else {
@@ -59,8 +61,56 @@ function cliMain() {
         }
     });
 }
-function isIoError(err, errorCode) {
-    return err instanceof Error && 'code' in err && err.code == errorCode;
+function generateTranspiledText(inputFile, addGeneratedFileComment, project) {
+    const inputIsStdIn = inputFile === '-';
+    const inp = inputIsStdIn ? process.stdin.fd : inputFile;
+    const sourceCode = fs.readFileSync(inp, 'utf8');
+    try {
+        const needsHeader = addGeneratedFileComment && !inputIsStdIn;
+        const header = needsHeader ? generatedFileComment(inputFile) : '';
+        const transpiled = transpile(sourceCode, inputFile, project);
+        return `${header}${transpiled}`;
+    }
+    catch (err) {
+        if (err instanceof WorkflowSyntaxError) {
+            prettyPrintSyntaxError(err, inputFile, sourceCode);
+            return undefined;
+        }
+        else if (err instanceof TSError) {
+            prettyPrintSyntaxError(err, inputFile, sourceCode);
+            return undefined;
+        }
+        else {
+            throw err;
+        }
+    }
+}
+function writeOutput(transpiled, inputFile, outdir) {
+    if (outdir !== undefined) {
+        if (!fs.existsSync(outdir)) {
+            fs.mkdirSync(outdir, { recursive: true });
+        }
+        const outputFile = createOutputFilename(inputFile, outdir);
+        fs.writeFileSync(outputFile, transpiled);
+    }
+    else {
+        process.stdout.write(transpiled);
+    }
+}
+function createOutputFilename(inputFile, outdir) {
+    const parsedInput = path.parse(inputFile);
+    return path.format({
+        dir: outdir,
+        name: parsedInput.name,
+        ext: '.yaml',
+    });
+}
+function generatedFileComment(inputFile) {
+    return (`# This file has been generated by "ts2workflows ${inputFile}"\n` +
+        '# Do not edit!\n\n');
+}
+function isIoError(err) {
+    return err instanceof Error && 'code' in err;
 }
 function prettyPrintSyntaxError(exception, inputFile, sourceCode) {
     console.error(errorDisplay(inputFile, sourceCode, exception.location));
@@ -108,6 +158,13 @@ function highlightedSourceCodeLine(sourceCode, lineNumber, start, end) {
     const markerLine = `${' '.repeat(start)}${'^'.repeat(markerLength)}`;
     return `${sourceLine}\n${markerLine}`;
 }
+function versionFromPackageJson() {
+    const currentFile = fileURLToPath(import.meta.url);
+    const currentDir = path.dirname(currentFile);
+    const packagePath = path.join(currentDir, '..', 'package.json');
+    const pjson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+    return pjson.version ?? '???';
+}
 if (import.meta.url.endsWith(process.argv[1]) ||
     process.argv[1].endsWith('/ts2workflows')) {
     cliMain();

package/dist/transpiler/expressions.d.ts

@@ -7,5 +7,4 @@ export declare function convertMemberExpression(node: TSESTree.MemberExpression)
 export declare function isMagicFunction(calleeName: string): boolean;
 export declare function isMagicFunctionStatmentOnly(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;
 //# 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;AAgOD,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,EAGV,SAAS,EAOV,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,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"}

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,22 +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 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);
@@ -187,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]),
@@ -366,6 +360,3 @@ 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);
-}

package/dist/transpiler/index.d.ts

@@ -1,2 +1,2 @@
-export declare function transpile(code: string): string;
+export declare function transpile(code: string, inputFile?: string, tsconfigPath?: string): string;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transpiler/index.ts"],"names":[],"mappings":"AAYA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW9C"}
+{"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

@@ -1,16 +1,23 @@
-import { parse, AST_NODE_TYPES, } from '@typescript-eslint/typescript-estree';
+import { AST_NODE_TYPES, parseAndGenerateServices, } from '@typescript-eslint/typescript-estree';
 import * as YAML from 'yaml';
 import { SubworkflowAST } from '../ast/steps.js';
 import { WorkflowSyntaxError } from '../errors.js';
 import { generateStepNames } from '../ast/stepnames.js';
 import { parseStatement } from './statements.js';
-export function transpile(code) {
+import { transformAST } from './transformations.js';
+export function transpile(code, inputFile, tsconfigPath) {
     const parserOptions = {
         jsDocParsingMode: 'none',
         loc: true,
         range: false,
     };
-    const ast = parse(code, parserOptions);
+    if (tsconfigPath && inputFile && inputFile != '-') {
+        parserOptions.filePath = inputFile;
+        parserOptions.projectService = {
+            defaultProject: tsconfigPath,
+        };
+    }
+    const { ast } = parseAndGenerateServices(code, parserOptions);
     const workflowAst = { subworkflows: ast.body.flatMap(parseTopLevelStatement) };
     const workflow = generateStepNames(workflowAst);
     return YAML.stringify(workflow.render(), { lineWidth: 100 });
@@ -45,8 +52,12 @@ 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, {}));
+    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) {
@@ -61,8 +72,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;AAiCxB,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"}