ts2workflows 0.3.0 → 0.5.0

package/dist/transpiler/expressions.js

@@ -1,9 +1,7 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, isExpression, isFullyQualifiedName, } from '../ast/expressions.js';
-import { WorkflowSyntaxError } from '../errors.js';
-import { assertOneOfManyTypes, assertType } from './asserts.js';
-const { ArrayExpression, AwaitExpression, CallExpression, ConditionalExpression, Identifier, Literal, LogicalExpression, ObjectExpression, TemplateLiteral, TSAsExpression, } = AST_NODE_TYPES;
+import { InternalTranspilingError, WorkflowSyntaxError } from '../errors.js';
+import { mapRecordValues } from '../utils.js';
 export function convertExpression(instance) {
     const expOrPrimitive = convertExpressionOrPrimitive(instance);
     if (isExpression(expOrPrimitive)) {
@@ -14,14 +12,12 @@ export function convertExpression(instance) {
     }
 }
 export function convertObjectExpression(node) {
-    assertType(node, ObjectExpression);
-    const properties = node.properties;
-    return Object.fromEntries(properties.map(({ key, value }) => {
+    return Object.fromEntries(throwIfSpread(node.properties).map(({ key, value }) => {
         let keyPrimitive;
-        if (key.type === Identifier) {
+        if (key.type === AST_NODE_TYPES.Identifier) {
             keyPrimitive = key.name;
         }
-        else if (key.type === Literal) {
+        else if (key.type === AST_NODE_TYPES.Literal) {
             if (typeof key.value === 'string') {
                 keyPrimitive = key.value;
             }
@@ -32,28 +28,34 @@ export function convertObjectExpression(node) {
         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) {
-    const primitiveOrExpArguments = convertObjectExpression(node);
     // Convert Primitive values to PrimitiveExpressions
-    return Object.fromEntries(Object.entries(primitiveOrExpArguments).map(([key, val]) => {
-        const valEx = isExpression(val) ? val : new PrimitiveExpression(val);
-        return [key, valEx];
-    }));
+    return mapRecordValues(convertObjectExpression(node), (val) => isExpression(val) ? val : new PrimitiveExpression(val));
 }
 function convertExpressionOrPrimitive(instance) {
     switch (instance.type) {
-        case ArrayExpression:
-            return instance.elements.map(convertExpressionOrPrimitive);
-        case ObjectExpression:
+        case AST_NODE_TYPES.ArrayExpression:
+            return convertArrayExpression(instance);
+        case AST_NODE_TYPES.ObjectExpression:
             return convertObjectExpression(instance);
-        case Literal:
+        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);
+            }
             return instance.value;
-        case TemplateLiteral:
+        case AST_NODE_TYPES.TemplateLiteral:
             return convertTemplateLiteralToExpression(instance);
-        case Identifier:
+        case AST_NODE_TYPES.Identifier:
             if (instance.name === 'null' || instance.name === 'undefined') {
                 return null;
             }
@@ -69,27 +71,32 @@ function convertExpressionOrPrimitive(instance) {
         case AST_NODE_TYPES.UnaryExpression:
             return convertUnaryExpression(instance);
         case AST_NODE_TYPES.BinaryExpression:
-        case LogicalExpression:
+        case AST_NODE_TYPES.LogicalExpression:
             return convertBinaryExpression(instance);
         case AST_NODE_TYPES.MemberExpression:
             return convertMemberExpression(instance);
-        case CallExpression:
+        case AST_NODE_TYPES.ChainExpression:
+            return convertChainExpression(instance);
+        case AST_NODE_TYPES.CallExpression:
             return convertCallExpression(instance);
-        case ConditionalExpression:
+        case AST_NODE_TYPES.ConditionalExpression:
             return convertConditionalExpression(instance);
-        case TSAsExpression:
+        case AST_NODE_TYPES.TSAsExpression:
+            return convertExpressionOrPrimitive(instance.expression);
+        case AST_NODE_TYPES.TSNonNullExpression:
             return convertExpressionOrPrimitive(instance.expression);
-        case AwaitExpression:
+        case AST_NODE_TYPES.AwaitExpression:
             return convertExpressionOrPrimitive(instance.argument);
         default:
             throw new WorkflowSyntaxError(`Not implemented expression type: ${instance.type}`, instance.loc);
     }
 }
+function convertArrayExpression(instance) {
+    return throwIfSpread(instance.elements).map((e) => e === null
+        ? new PrimitiveExpression(null)
+        : convertExpressionOrPrimitive(e));
+}
 function convertBinaryExpression(instance) {
-    assertOneOfManyTypes(instance, [
-        AST_NODE_TYPES.BinaryExpression,
-        LogicalExpression,
-    ]);
     // Special case for nullish coalescing becuase the result is a function call
     // expression, not a binary expression
     if (instance.operator === '??') {
@@ -126,6 +133,9 @@ function convertBinaryExpression(instance) {
         default:
             throw new WorkflowSyntaxError(`Unsupported binary operator: ${instance.operator}`, instance.loc);
     }
+    if (instance.left.type === AST_NODE_TYPES.PrivateIdentifier) {
+        throw new WorkflowSyntaxError('Private identifier not supported', instance.left.loc);
+    }
     return new BinaryExpression(convertExpression(instance.left), op, convertExpression(instance.right));
 }
 function nullishCoalescingExpression(left, right) {
@@ -135,7 +145,6 @@ function nullishCoalescingExpression(left, right) {
     ]);
 }
 function convertUnaryExpression(instance) {
-    assertType(instance, AST_NODE_TYPES.UnaryExpression);
     if (instance.prefix === false) {
         throw new WorkflowSyntaxError('only prefix unary operators are supported', instance.loc);
     }
@@ -165,37 +174,140 @@ function convertUnaryExpression(instance) {
     return op ? new UnaryExpression(op, ex) : ex;
 }
 export function convertMemberExpression(node) {
-    assertType(node, AST_NODE_TYPES.MemberExpression);
+    if (node.property.type === AST_NODE_TYPES.PrivateIdentifier) {
+        throw new WorkflowSyntaxError('Private identifier not supported', node.property.loc);
+    }
     const object = convertExpression(node.object);
     return new MemberExpression(object, convertExpression(node.property), node.computed);
 }
+function convertChainExpression(node) {
+    const properties = chainExpressionToFlatArray(node.expression);
+    const args = optinalChainToMapGetArguments(properties);
+    return new FunctionInvocationExpression('map.get', args);
+}
+function chainExpressionToFlatArray(node) {
+    if (node.type === AST_NODE_TYPES.MemberExpression) {
+        if (node.property.type === AST_NODE_TYPES.PrivateIdentifier) {
+            throw new WorkflowSyntaxError('Private identifier not supported', node.property.loc);
+        }
+        const data = {
+            property: node.property,
+            optional: node.optional,
+            computed: node.computed,
+        };
+        return chainExpressionToFlatArray(node.object).concat([data]);
+    }
+    else {
+        return [
+            {
+                property: node,
+                optional: false,
+                computed: false,
+            },
+        ];
+    }
+}
+function optinalChainToMapGetArguments(properties) {
+    if (properties.length <= 0) {
+        // this shouldn't happen
+        return [];
+    }
+    let base;
+    let optionalSliceStart;
+    const firstOptional = properties.findIndex((p) => p.optional);
+    if (firstOptional > 2) {
+        const baseProperties = properties.slice(0, firstOptional - 1);
+        base = memberExpressionFromList(baseProperties);
+        optionalSliceStart = firstOptional - 1;
+    }
+    else if (firstOptional >= 0) {
+        base = convertExpression(properties[0].property);
+        optionalSliceStart = 1;
+    }
+    else {
+        // firstOptional < 0, this shouldn't happen
+        base = memberExpressionFromList(properties);
+        optionalSliceStart = properties.length;
+    }
+    const optionals = properties.slice(optionalSliceStart).map((opt) => {
+        const propertyExp = convertExpression(opt.property);
+        if (opt.computed) {
+            return propertyExp;
+        }
+        else if (isFullyQualifiedName(propertyExp)) {
+            return new PrimitiveExpression(propertyExp.toString());
+        }
+        else {
+            throw new WorkflowSyntaxError('Unexpected property in an optional chain', opt.property.loc);
+        }
+    });
+    const args = [base];
+    if (optionals.length > 1) {
+        args.push(new PrimitiveExpression(optionals));
+    }
+    else if (optionals.length === 1) {
+        args.push(optionals[0]);
+    }
+    return args;
+}
+function memberExpressionFromList(properties) {
+    if (properties.length >= 2) {
+        const base = new MemberExpression(convertExpression(properties[0].property), convertExpression(properties[1].property), properties[1].computed);
+        return properties
+            .slice(2)
+            .reduce((exp, current) => new MemberExpression(exp, convertExpression(current.property), current.computed), base);
+    }
+    else if (properties.length === 1) {
+        return convertExpression(properties[0].property);
+    }
+    else {
+        throw new InternalTranspilingError('Empty array in memberExpressionFromList()');
+    }
+}
 function convertCallExpression(node) {
-    assertType(node, CallExpression);
+    if (node.optional) {
+        throw new WorkflowSyntaxError('Optional call expressions are not supported', node.loc);
+    }
     const calleeExpression = convertExpression(node.callee);
     if (isFullyQualifiedName(calleeExpression)) {
-        const nodeArguments = node.arguments;
-        const argumentExpressions = nodeArguments.map(convertExpression);
-        return new FunctionInvocationExpression(calleeExpression.toString(), argumentExpressions);
+        const calleeName = calleeExpression.toString();
+        if (isMagicFunction(calleeName)) {
+            let msg;
+            if (calleeName === 'call_step') {
+                msg =
+                    'Calling call_step as part of an expression is not yet implemented';
+            }
+            else {
+                msg = `"${calleeName}" can't be called as part of an expression`;
+            }
+            throw new WorkflowSyntaxError(msg, node.callee.loc);
+        }
+        const argumentExpressions = throwIfSpread(node.arguments).map(convertExpression);
+        return new FunctionInvocationExpression(calleeName, argumentExpressions);
     }
     else {
         throw new WorkflowSyntaxError('Callee should be a qualified name', node.loc);
     }
 }
+export function isMagicFunction(calleeName) {
+    const magicFunctions = ['parallel', 'retry_policy', 'call_step'];
+    return magicFunctions.includes(calleeName);
+}
+export function isMagicFunctionStatmentOnly(calleeName) {
+    const statementNames = ['parallel', 'retry_policy'];
+    return statementNames.includes(calleeName);
+}
 function convertConditionalExpression(node) {
-    assertType(node, ConditionalExpression);
     const test = convertExpression(node.test);
     const consequent = convertExpression(node.consequent);
     const alternate = convertExpression(node.alternate);
     return new FunctionInvocationExpression('if', [test, consequent, alternate]);
 }
 function convertTemplateLiteralToExpression(node) {
-    assertType(node, TemplateLiteral);
-    const elements = node.quasis;
-    const stringTerms = elements
+    const stringTerms = node.quasis
         .map((x) => x.value.cooked)
         .map((x) => new PrimitiveExpression(x));
-    const expressionNodes = node.expressions;
-    const templateTerms = expressionNodes.map(convertExpression);
+    const templateTerms = node.expressions.map(convertExpression);
     // interleave string parts and the expression parts starting with strings
     const interleavedTerms = stringTerms
         .slice(0, stringTerms.length - 1)
@@ -221,3 +333,11 @@ function convertTemplateLiteralToExpression(node) {
         });
     }
 }
+export function throwIfSpread(nodes) {
+    const unsupported = nodes.find((x) => x?.type === AST_NODE_TYPES.SpreadElement);
+    if (unsupported) {
+        throw new WorkflowSyntaxError('The spread syntax is not supported', unsupported.loc);
+    }
+    const argumentExpressions = nodes.filter((x) => x?.type !== AST_NODE_TYPES.SpreadElement);
+    return argumentExpressions;
+}

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

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

package/dist/transpiler/index.js

@@ -1,67 +1,68 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */
-import * as parser from '@typescript-eslint/typescript-estree';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { parse, AST_NODE_TYPES, } 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 { assertType } from './asserts.js';
-import { parseBlockStatement } from './statements.js';
-const { AssignmentPattern, ExportNamedDeclaration, FunctionDeclaration, Identifier, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, Literal, Program, TSDeclareFunction, TSTypeAliasDeclaration, TSInterfaceDeclaration, } = AST_NODE_TYPES;
+import { parseStatement } from './statements.js';
 export function transpile(code) {
     const parserOptions = {
         jsDocParsingMode: 'none',
         loc: true,
         range: false,
     };
-    const ast = parser.parse(code, parserOptions);
-    assertType(ast, Program);
+    const ast = parse(code, parserOptions);
     const workflowAst = { subworkflows: ast.body.flatMap(parseTopLevelStatement) };
     const workflow = generateStepNames(workflowAst);
     return YAML.stringify(workflow.render(), { lineWidth: 100 });
 }
 function parseTopLevelStatement(node) {
-    switch (node?.type) {
-        case FunctionDeclaration:
+    switch (node.type) {
+        case AST_NODE_TYPES.FunctionDeclaration:
             return [parseSubworkflows(node)];
-        case ImportDeclaration:
-            if (node.specifiers.some((spec) => spec.type === ImportNamespaceSpecifier ||
-                spec.type === ImportDefaultSpecifier)) {
+        case AST_NODE_TYPES.ImportDeclaration:
+            if (node.specifiers.some((spec) => spec.type === AST_NODE_TYPES.ImportNamespaceSpecifier ||
+                spec.type === AST_NODE_TYPES.ImportDefaultSpecifier)) {
                 throw new WorkflowSyntaxError('Only named imports are allowed', node.loc);
             }
             return [];
-        case ExportNamedDeclaration:
+        case AST_NODE_TYPES.ExportNamedDeclaration:
             // "export" keyword is ignored, but a possible function declaration is transpiled.
-            if (node?.declaration) {
+            if (node.declaration?.type === AST_NODE_TYPES.FunctionDeclaration &&
+                node.declaration.id?.type === AST_NODE_TYPES.Identifier) {
+                // Why is "as" needed here?
                 return parseTopLevelStatement(node.declaration);
             }
             else {
                 return [];
             }
-        case TSInterfaceDeclaration:
-        case TSTypeAliasDeclaration:
-        case TSDeclareFunction:
+        case AST_NODE_TYPES.TSInterfaceDeclaration:
+        case AST_NODE_TYPES.TSTypeAliasDeclaration:
+        case AST_NODE_TYPES.TSDeclareFunction:
             // Ignore "type", "interface" and "declare function" at the top-level
             return [];
         default:
-            throw new WorkflowSyntaxError(`Only function definitions, 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) {
-    assertType(node, FunctionDeclaration);
-    if (node.id.type !== Identifier) {
-        throw new WorkflowSyntaxError('Expected Identifier as a function name', node.id.loc);
-    }
     const nodeParams = node.params;
     const workflowParams = nodeParams.map((param) => {
         switch (param.type) {
-            case Identifier:
+            case AST_NODE_TYPES.Identifier:
                 return { name: param.name };
-            case AssignmentPattern:
-                assertType(param.left, Identifier);
-                if (param.right.type !== Literal) {
+            case AST_NODE_TYPES.AssignmentPattern:
+                if (param.left.type !== AST_NODE_TYPES.Identifier) {
+                    throw new WorkflowSyntaxError('The default value must be an identifier', param.left.loc);
+                }
+                if (param.right.type !== AST_NODE_TYPES.Literal) {
                     throw new WorkflowSyntaxError('The default value must be a literal', param.right.loc);
                 }
+                if (!(typeof param.right.value === 'string' ||
+                    typeof param.right.value === 'number' ||
+                    typeof param.right.value === 'boolean' ||
+                    param.right.value === null)) {
+                    throw new WorkflowSyntaxError('The default value must be a string, number, boolean or null', param.left.loc);
+                }
                 return {
                     name: param.left.name,
                     default: param.right.value,
@@ -70,6 +71,6 @@ function parseSubworkflows(node) {
                 throw new WorkflowSyntaxError('Function parameter must be an identifier or an assignment', param.loc);
         }
     });
-    const steps = parseBlockStatement(node.body, {});
+    const steps = parseStatement(node.body, {});
     return new SubworkflowAST(node.id.name, steps, workflowParams);
 }

package/dist/transpiler/statements.d.ts

@@ -1,7 +1,8 @@
+import { TSESTree } from '@typescript-eslint/typescript-estree';
 import { StepName, WorkflowStepAST } from '../ast/steps.js';
 export interface ParsingContext {
     breakTarget?: StepName;
     continueTarget?: StepName;
 }
-export declare function parseBlockStatement(node: any, ctx: ParsingContext): WorkflowStepAST[];
+export declare function parseStatement(node: TSESTree.Statement, ctx: ParsingContext, postSteps?: WorkflowStepAST[]): 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":"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"}
+{"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,EASL,QAAQ,EAMR,eAAe,EAChB,MAAM,iBAAiB,CAAA;AA2BxB,MAAM,WAAW,cAAc;IAE7B,WAAW,CAAC,EAAE,QAAQ,CAAA;IAEtB,cAAc,CAAC,EAAE,QAAQ,CAAA;CAC1B;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,GAAG,EAAE,cAAc,EACnB,SAAS,CAAC,EAAE,eAAe,EAAE,GAC5B,eAAe,EAAE,CAGnB"}