ts2workflows 0.1.0

package/dist/transpiler/expressions.js

@@ -0,0 +1,223 @@
+/* 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 { 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;
+export function convertExpression(instance) {
+    const expOrPrimitive = convertExpressionOrPrimitive(instance);
+    if (isExpression(expOrPrimitive)) {
+        return expOrPrimitive;
+    }
+    else {
+        return new PrimitiveExpression(expOrPrimitive);
+    }
+}
+export function convertObjectExpression(node) {
+    assertType(node, ObjectExpression);
+    const properties = node.properties;
+    return Object.fromEntries(properties.map(({ key, value }) => {
+        let keyPrimitive;
+        if (key.type === Identifier) {
+            keyPrimitive = key.name;
+        }
+        else if (key.type === 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);
+        }
+        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];
+    }));
+}
+function convertExpressionOrPrimitive(instance) {
+    switch (instance.type) {
+        case ArrayExpression:
+            return instance.elements.map(convertExpressionOrPrimitive);
+        case ObjectExpression:
+            return convertObjectExpression(instance);
+        case Literal:
+            return instance.value;
+        case TemplateLiteral:
+            return convertTemplateLiteralToExpression(instance);
+        case 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;
+            }
+            else {
+                return new VariableReferenceExpression(instance.name);
+            }
+        case AST_NODE_TYPES.UnaryExpression:
+            return convertUnaryExpression(instance);
+        case AST_NODE_TYPES.BinaryExpression:
+        case LogicalExpression:
+            return convertBinaryExpression(instance);
+        case AST_NODE_TYPES.MemberExpression:
+            return convertMemberExpression(instance);
+        case CallExpression:
+            return convertCallExpression(instance);
+        case ConditionalExpression:
+            return convertConditionalExpression(instance);
+        case TSAsExpression:
+            return convertExpressionOrPrimitive(instance.expression);
+        case AwaitExpression:
+            return convertExpressionOrPrimitive(instance.argument);
+        default:
+            throw new WorkflowSyntaxError(`Not implemented expression type: ${instance.type}`, instance.loc);
+    }
+}
+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 === '??') {
+        return nullishCoalescingExpression(instance.left, instance.right);
+    }
+    let op;
+    switch (instance.operator) {
+        case '+':
+        case '-':
+        case '*':
+        case '/':
+        case '%':
+        case '==':
+        case '!=':
+        case '>':
+        case '>=':
+        case '<':
+        case '<=':
+        case 'in':
+            op = instance.operator;
+            break;
+        case '===':
+            op = '==';
+            break;
+        case '!==':
+            op = '!=';
+            break;
+        case '&&':
+            op = 'and';
+            break;
+        case '||':
+            op = 'or';
+            break;
+        default:
+            throw new WorkflowSyntaxError(`Unsupported binary operator: ${instance.operator}`, instance.loc);
+    }
+    return new BinaryExpression(convertExpression(instance.left), op, convertExpression(instance.right));
+}
+function nullishCoalescingExpression(left, right) {
+    return new FunctionInvocationExpression('default', [
+        convertExpression(left),
+        convertExpression(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);
+    }
+    let op;
+    switch (instance.operator) {
+        case '+':
+            op = '+';
+            break;
+        case '-':
+            op = '-';
+            break;
+        case '!':
+            op = 'not';
+            break;
+        case 'void':
+            // Just evalute the side-effecting expression.
+            // This is wrong: the return value should be ignored.
+            op = undefined;
+            break;
+        case undefined:
+            op = undefined;
+            break;
+        default:
+            throw new WorkflowSyntaxError(`Unsupported unary operator: ${instance.operator}`, instance.loc);
+    }
+    const ex = convertExpression(instance.argument);
+    return op ? new UnaryExpression(op, ex) : ex;
+}
+export function convertMemberExpression(node) {
+    assertType(node, AST_NODE_TYPES.MemberExpression);
+    const object = convertExpression(node.object);
+    return new MemberExpression(object, convertExpression(node.property), node.computed);
+}
+function convertCallExpression(node) {
+    assertType(node, CallExpression);
+    const calleeExpression = convertExpression(node.callee);
+    if (isFullyQualifiedName(calleeExpression)) {
+        const nodeArguments = node.arguments;
+        const argumentExpressions = nodeArguments.map(convertExpression);
+        return new FunctionInvocationExpression(calleeExpression.toString(), argumentExpressions);
+    }
+    else {
+        throw new WorkflowSyntaxError('Callee should be a qualified name', node.loc);
+    }
+}
+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
+        .map((x) => x.value.cooked)
+        .map((x) => new PrimitiveExpression(x));
+    const expressionNodes = node.expressions;
+    const templateTerms = expressionNodes.map(convertExpression);
+    // interleave string parts and the expression parts starting with strings
+    const interleavedTerms = stringTerms
+        .slice(0, stringTerms.length - 1)
+        .flatMap((stringTerm, i) => {
+        const combined = [stringTerm];
+        if (i < templateTerms.length) {
+            combined.push(templateTerms[i]);
+        }
+        return combined;
+    });
+    if (stringTerms[stringTerms.length - 1].value !== '') {
+        interleavedTerms.push(stringTerms[stringTerms.length - 1]);
+    }
+    if (interleavedTerms.length === 0) {
+        return new PrimitiveExpression('');
+    }
+    else if (interleavedTerms.length === 1) {
+        return interleavedTerms[0];
+    }
+    else {
+        return interleavedTerms.reduce((previous, current) => {
+            return new BinaryExpression(previous, '+', current);
+        });
+    }
+}

package/dist/transpiler/generated/functionMetadata.d.ts

@@ -0,0 +1,2 @@
+export declare const blockingFunctions: Map<string, string[]>;
+//# sourceMappingURL=functionMetadata.d.ts.map

package/dist/transpiler/generated/functionMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionMetadata.d.ts","sourceRoot":"","sources":["../../../src/transpiler/generated/functionMetadata.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,uBAiU5B,CAAA"}

package/dist/transpiler/generated/functionMetadata.js

@@ -0,0 +1,324 @@
+// This is a generated file, do not modify!
+// Blocking function names and argument names
+export const blockingFunctions = new Map([
+    [
+        "events.await_callback",
+        [
+            "callback",
+            "timeout"
+        ]
+    ],
+    [
+        "http.delete",
+        [
+            "url",
+            "timeout",
+            "body",
+            "headers",
+            "query",
+            "auth",
+            "private_service_name",
+            "ca_certificate"
+        ]
+    ],
+    [
+        "http.get",
+        [
+            "url",
+            "timeout",
+            "headers",
+            "query",
+            "auth",
+            "private_service_name",
+            "ca_certificate"
+        ]
+    ],
+    [
+        "http.patch",
+        [
+            "url",
+            "timeout",
+            "body",
+            "headers",
+            "query",
+            "auth",
+            "private_service_name",
+            "ca_certificate"
+        ]
+    ],
+    [
+        "http.post",
+        [
+            "url",
+            "timeout",
+            "body",
+            "headers",
+            "query",
+            "auth",
+            "private_service_name",
+            "ca_certificate"
+        ]
+    ],
+    [
+        "http.put",
+        [
+            "url",
+            "timeout",
+            "body",
+            "headers",
+            "query",
+            "auth",
+            "private_service_name",
+            "ca_certificate"
+        ]
+    ],
+    [
+        "http.request",
+        [
+            "method",
+            "url",
+            "timeout",
+            "body",
+            "headers",
+            "query",
+            "auth",
+            "private_service_name",
+            "ca_certificate"
+        ]
+    ],
+    [
+        "sys.log",
+        [
+            "data",
+            "severity",
+            "text",
+            "json",
+            "timeout"
+        ]
+    ],
+    [
+        "sys.sleep",
+        [
+            "seconds"
+        ]
+    ],
+    [
+        "sys.sleep_until",
+        [
+            "time"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.exportDocuments",
+        [
+            "name",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.importDocuments",
+        [
+            "name",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.collectionGroups.fields.get",
+        [
+            "name"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.collectionGroups.fields.list",
+        [
+            "parent",
+            "filter",
+            "pageSize",
+            "pageToken"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.collectionGroups.fields.patch",
+        [
+            "name",
+            "updateMask",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.collectionGroups.indexes.create",
+        [
+            "parent",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.collectionGroups.indexes.delete",
+        [
+            "name"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.collectionGroups.indexes.get",
+        [
+            "name"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.collectionGroups.indexes.list",
+        [
+            "parent",
+            "filter",
+            "pageSize",
+            "pageToken"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.batchGet",
+        [
+            "database",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.batchWrite",
+        [
+            "database",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.beginTransaction",
+        [
+            "database",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.commit",
+        [
+            "database",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.createDocument",
+        [
+            "collectionId",
+            "parent",
+            "body",
+            "documentId",
+            "mask"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.delete",
+        [
+            "name",
+            "currentDocument"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.get",
+        [
+            "name",
+            "mask",
+            "readTime",
+            "transaction"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.list",
+        [
+            "collectionId",
+            "parent",
+            "mask",
+            "orderBy",
+            "pageSize",
+            "pageToken",
+            "readTime",
+            "showMissing",
+            "transaction"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.listCollectionIds",
+        [
+            "parent",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.partitionQuery",
+        [
+            "parent",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.patch",
+        [
+            "name",
+            "currentDocument",
+            "mask",
+            "updateMask",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.rollback",
+        [
+            "database",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.documents.runQuery",
+        [
+            "parent",
+            "body"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.operations.cancel",
+        [
+            "name"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.operations.delete",
+        [
+            "name"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.operations.get",
+        [
+            "name"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.databases.operations.list",
+        [
+            "name",
+            "filter",
+            "pageSize",
+            "pageToken"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.locations.get",
+        [
+            "name"
+        ]
+    ],
+    [
+        "googleapis.firestore.v1.projects.locations.list",
+        [
+            "name",
+            "filter",
+            "pageSize",
+            "pageToken"
+        ]
+    ]
+]);

package/dist/transpiler/index.d.ts

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

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

@@ -0,0 +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"}

package/dist/transpiler/index.js

@@ -0,0 +1,74 @@
+/* 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 * 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, TSTypeAliasDeclaration, TSInterfaceDeclaration, } = AST_NODE_TYPES;
+export function transpile(code) {
+    const parserOptions = {
+        jsDocParsingMode: 'none',
+        loc: true,
+        range: false,
+    };
+    const ast = parser.parse(code, parserOptions);
+    assertType(ast, Program);
+    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:
+            return [parseSubworkflows(node)];
+        case ImportDeclaration:
+            if (node.specifiers.some((spec) => spec.type === ImportNamespaceSpecifier ||
+                spec.type === ImportDefaultSpecifier)) {
+                throw new WorkflowSyntaxError('Only named imports are allowed', node.loc);
+            }
+            return [];
+        case ExportNamedDeclaration:
+            // "export" keyword is ignored, but a possible function declaration is transpiled.
+            if (node?.declaration) {
+                return parseTopLevelStatement(node.declaration);
+            }
+            else {
+                return [];
+            }
+        case TSInterfaceDeclaration:
+        case TSTypeAliasDeclaration:
+            // Ignore "type" and "interface" declarations 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);
+    }
+}
+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:
+                return { name: param.name };
+            case AssignmentPattern:
+                assertType(param.left, Identifier);
+                if (param.right.type !== Literal) {
+                    throw new WorkflowSyntaxError('The default value must be a literal', param.right.loc);
+                }
+                return {
+                    name: param.left.name,
+                    default: param.right.value,
+                };
+            default:
+                throw new WorkflowSyntaxError('Function parameter must be an identifier or an assignment', param.loc);
+        }
+    });
+    const steps = parseBlockStatement(node.body, {});
+    return new SubworkflowAST(node.id.name, steps, workflowParams);
+}

package/dist/transpiler/statements.d.ts

@@ -0,0 +1,7 @@
+import { StepName, WorkflowStepAST } from '../ast/steps.js';
+export interface ParsingContext {
+    breakTarget?: StepName;
+    continueTarget?: StepName;
+}
+export declare function parseBlockStatement(node: any, ctx: ParsingContext): WorkflowStepAST[];
+//# sourceMappingURL=statements.d.ts.map

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

@@ -0,0 +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"}