ts2workflows 0.11.0 → 0.13.0

package/dist/ast/expressions.js

@@ -1,5 +1,4 @@
 import * as R from 'ramda';
-import { isRecord } from '../utils.js';
 // Operator precendence for unary and binary operators in the Workflows language.
 // Note that these differ somewhat from Javascript.
 // https://cloud.google.com/workflows/docs/reference/syntax/datatypes
@@ -24,171 +23,130 @@ const operatorPrecedenceValue = new Map([
     ['and', 2],
     ['or', 1],
 ]);
-// A primitive (string, number, list, etc) value
-export class PrimitiveExpression {
-    expressionType = 'primitive';
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    // Return the string representation of this expression.
-    // Not enclosed in ${}.
-    toString() {
-        const val = this.value;
-        if (Array.isArray(val)) {
-            const elements = val.map((v) => {
-                return isExpression(v) ? v.toString() : primitiveToString(v);
-            });
-            return `[${elements.join(', ')}]`;
-        }
-        else if (isRecord(val)) {
-            const elements = Object.entries(val).map(([k, v]) => {
-                return `"${k}": ${isExpression(v) ? v.toString() : primitiveToString(v)}`;
-            });
-            return `{${elements.join(', ')}}`;
-        }
-        else {
-            return `${JSON.stringify(val)}`;
-        }
-    }
-}
-export const nullEx = new PrimitiveExpression(null);
-export const trueEx = new PrimitiveExpression(true);
-export const falseEx = new PrimitiveExpression(false);
-// expr OPERATOR expr
-export class BinaryExpression {
-    expressionType = 'binary';
-    binaryOperator;
-    left;
-    right;
-    constructor(left, binaryOperator, right) {
-        this.binaryOperator = binaryOperator;
-        this.left = left;
-        this.right = right;
-    }
-    toString() {
-        let leftString = this.left.toString();
-        let rightString = this.right.toString();
-        if (this.left.expressionType === 'binary') {
-            const leftOpValue = operatorPrecedenceValue.get(this.left.binaryOperator) ?? 0;
-            const thisOpValue = operatorPrecedenceValue.get(this.binaryOperator) ?? 0;
-            if (leftOpValue < thisOpValue) {
-                leftString = `(${leftString})`;
+export const nullEx = { tag: 'null', value: null };
+export function stringEx(value) {
+    return { tag: 'string', value };
+}
+export function numberEx(value) {
+    return { tag: 'number', value };
+}
+export function booleanEx(value) {
+    return { tag: 'boolean', value };
+}
+export const trueEx = booleanEx(true);
+export const falseEx = booleanEx(false);
+export function listEx(value) {
+    return { tag: 'list', value };
+}
+export function mapEx(value) {
+    return { tag: 'map', value };
+}
+export function binaryEx(left, binaryOperator, right) {
+    return {
+        tag: 'binary',
+        binaryOperator,
+        left,
+        right,
+    };
+}
+export function variableReferenceEx(variableName) {
+    return { tag: 'variableReference', variableName };
+}
+export function functionInvocationEx(functionName, argumentExpressions) {
+    return {
+        tag: 'functionInvocation',
+        functionName,
+        arguments: argumentExpressions,
+    };
+}
+export function memberEx(object, property, computed) {
+    return { tag: 'member', object, property, computed };
+}
+export function unaryEx(operator, value) {
+    return { tag: 'unary', operator, value };
+}
+// Returns a string representation of ex, not enclosed in ${}
+export function expressionToString(ex) {
+    switch (ex.tag) {
+        case 'string':
+            return JSON.stringify(ex.value);
+        case 'number':
+            return ex.value.toString();
+        case 'boolean':
+            return ex.value ? 'true' : 'false';
+        case 'null':
+            return 'null';
+        case 'list':
+            return '[' + ex.value.map(expressionToString).join(', ') + ']';
+        case 'map':
+            return ('{' +
+                Object.entries(ex.value)
+                    .map(([key, val]) => JSON.stringify(key) + ': ' + expressionToString(val))
+                    .join(', ') +
+                '}');
+        case 'binary':
+            return binaryExpressionToString(ex);
+        case 'variableReference':
+            return ex.variableName;
+        case 'functionInvocation':
+            return `${ex.functionName}(${ex.arguments.map(expressionToString).join(', ')})`;
+        case 'member':
+            if (ex.computed) {
+                return `${expressionToString(ex.object)}[${expressionToString(ex.property)}]`;
             }
-        }
-        if (this.right.expressionType === 'binary') {
-            const rightOpValue = operatorPrecedenceValue.get(this.right.binaryOperator) ?? 0;
-            const thisOpValue = operatorPrecedenceValue.get(this.binaryOperator) ?? 0;
-            if (rightOpValue < thisOpValue) {
-                rightString = `(${rightString})`;
+            else {
+                return `${expressionToString(ex.object)}.${expressionToString(ex.property)}`;
             }
-        }
-        return `${leftString} ${this.binaryOperator} ${rightString}`;
-    }
-}
-// Variable name: a plain identifier (y, year) or a list
-// element accessor (names[3])
-export class VariableReferenceExpression {
-    expressionType = 'variableReference';
-    variableName;
-    constructor(variableName) {
-        this.variableName = variableName;
-    }
-    toString() {
-        return this.variableName;
-    }
-}
-// Function invocation with anonymous parameters: sys.get_env("GOOGLE_CLOUD_PROJECT_ID")
-export class FunctionInvocationExpression {
-    expressionType = 'functionInvocation';
-    functionName;
-    arguments;
-    constructor(functionName, argumentExpressions) {
-        this.functionName = functionName;
-        this.arguments = argumentExpressions;
-    }
-    toString() {
-        const argumentStrings = this.arguments.map((x) => x.toString());
-        return `${this.functionName}(${argumentStrings.join(', ')})`;
+        case 'unary':
+            return unaryExpressionToString(ex);
     }
 }
-// object.property or object[property]
-export class MemberExpression {
-    expressionType = 'member';
-    object;
-    property;
-    computed;
-    constructor(object, property, computed) {
-        this.object = object;
-        this.property = property;
-        this.computed = computed;
-    }
-    toString() {
-        if (this.computed) {
-            return `${this.object.toString()}[${this.property.toString()}]`;
-        }
-        else {
-            return `${this.object.toString()}.${this.property.toString()}`;
+function binaryExpressionToString(ex) {
+    let leftString = expressionToString(ex.left);
+    let rightString = expressionToString(ex.right);
+    if (ex.left.tag === 'binary') {
+        const leftOpValue = operatorPrecedenceValue.get(ex.left.binaryOperator) ?? 0;
+        const thisOpValue = operatorPrecedenceValue.get(ex.binaryOperator) ?? 0;
+        if (leftOpValue < thisOpValue) {
+            leftString = `(${leftString})`;
         }
     }
-}
-export class UnaryExpression {
-    expressionType = 'unary';
-    operator;
-    value;
-    constructor(operator, value) {
-        this.operator = operator;
-        this.value = value;
-    }
-    toString() {
-        const separator = this.operator === 'not' ? ' ' : '';
-        let valueString = this.value.toString();
-        if (this.value.expressionType === 'binary') {
-            valueString = `(${valueString})`;
+    if (ex.right.tag === 'binary') {
+        const rightOpValue = operatorPrecedenceValue.get(ex.right.binaryOperator) ?? 0;
+        const thisOpValue = operatorPrecedenceValue.get(ex.binaryOperator) ?? 0;
+        if (rightOpValue < thisOpValue) {
+            rightString = `(${rightString})`;
         }
-        return `${this.operator}${separator}${valueString}`;
     }
+    return `${leftString} ${ex.binaryOperator} ${rightString}`;
 }
-// Convert an Expression or Primitive to a string representation.
-// Does not add ${}.
-const expressionOrPrimitiveToString = R.ifElse(isExpression, (x) => x.toString(), primitiveToString);
-// Convert a Primitive to a string representation.
-// Does not add ${}.
-function primitiveToString(val) {
-    const valuesToString = R.map(expressionOrPrimitiveToString);
-    if (Array.isArray(val)) {
-        return `[${valuesToString(val).join(', ')}]`;
+function unaryExpressionToString(ex) {
+    const separator = ex.operator === 'not' ? ' ' : '';
+    let valueString = expressionToString(ex.value);
+    if (ex.value.tag === 'binary') {
+        valueString = `(${valueString})`;
     }
-    else if (val !== null && typeof val === 'object') {
-        const elements = Object.values(valuesToString(val)).map(([k, v]) => `"${k}":${v}`);
-        return `{${elements.join(',')}}`;
-    }
-    else {
-        return JSON.stringify(val);
-    }
-}
-export function isExpression(val) {
-    return val instanceof Object && 'expressionType' in val && !isRecord(val);
-}
-export function asExpression(x) {
-    return isExpression(x) ? x : new PrimitiveExpression(x);
-}
-export function safeAsExpression(x) {
-    return x === undefined ? undefined : asExpression(x);
+    return `${ex.operator}${separator}${valueString}`;
 }
 // Returns a literal for simple terms and a literal expression enclosed in ${} for complex terms.
 export function expressionToLiteralValueOrLiteralExpression(ex) {
-    switch (ex.expressionType) {
-        case 'primitive':
-            return primitiveExpressionToLiteralValueOrLiteralExpression(ex);
+    switch (ex.tag) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'null':
+            return ex.value;
+        case 'list':
+            return R.map(expressionToLiteralValueOrLiteralExpression, ex.value);
+        case 'map':
+            return R.map(expressionToLiteralValueOrLiteralExpression, ex.value);
         case 'binary':
         case 'variableReference':
         case 'functionInvocation':
         case 'member':
-            return `\${${ex.toString()}}`;
+            return `\${${expressionToString(ex)}}`;
         case 'unary':
-            if (ex.value.expressionType === 'primitive' &&
-                typeof ex.value.value === 'number') {
+            if (ex.value.tag === 'number') {
                 if (ex.operator === '+') {
                     return ex.value.value;
                 }
@@ -196,98 +154,22 @@ export function expressionToLiteralValueOrLiteralExpression(ex) {
                     return -ex.value.value;
                 }
                 else {
-                    return `\${${ex.toString()}}`;
+                    return `\${${expressionToString(ex)}}`;
                 }
             }
             else {
-                return `\${${ex.toString()}}`;
-            }
-    }
-}
-function primitiveExpressionToLiteralValueOrLiteralExpression(ex) {
-    if (typeof ex.value === 'number' ||
-        typeof ex.value === 'string' ||
-        typeof ex.value === 'boolean' ||
-        ex.value === null) {
-        return ex.value;
-    }
-    else if (Array.isArray(ex.value)) {
-        return ex.value.map((x) => {
-            if (isExpression(x)) {
-                return expressionToLiteralValueOrLiteralExpression(x);
-            }
-            else if (Array.isArray(x) || isRecord(x)) {
-                return primitiveExpressionToLiteralValueOrLiteralExpression(new PrimitiveExpression(x));
-            }
-            else if (x === null ||
-                typeof x === 'string' ||
-                typeof x === 'number' ||
-                typeof x === 'boolean') {
-                return x;
-            }
-            else {
-                return `\${${primitiveToString(x)}}`;
+                return `\${${expressionToString(ex)}}`;
             }
-        });
-    }
-    else if (isRecord(ex.value)) {
-        const mapRecord = R.map((v) => {
-            if (isExpression(v)) {
-                return expressionToLiteralValueOrLiteralExpression(v);
-            }
-            else if (Array.isArray(v) || isRecord(v)) {
-                return primitiveExpressionToLiteralValueOrLiteralExpression(new PrimitiveExpression(v));
-            }
-            else if (v === null ||
-                typeof v === 'string' ||
-                typeof v === 'number' ||
-                typeof v === 'boolean') {
-                return v;
-            }
-            else {
-                return `\${${primitiveToString(v)}}`;
-            }
-        });
-        return mapRecord(ex.value);
-    }
-    else {
-        return `\${${ex.toString()}}`;
     }
 }
-// Returns true if expression is a literal value.
-// Examples of literals: number, string, array of numbers or strings, etc.
-// Examples of non-literals: array that contains complex expressions.
-export function isLiteral(ex) {
-    switch (ex.expressionType) {
-        case 'primitive':
-            return primitiveIsLiteral(ex.value);
-        case 'unary':
-            return isLiteral(ex.value);
-        case 'binary':
-        case 'variableReference':
-        case 'functionInvocation':
-        case 'member':
-            return false;
-    }
-}
-const expressionOrPrimitiveIsLiteral = R.ifElse(isExpression, isLiteral, primitiveIsLiteral);
-function primitiveIsLiteral(value) {
-    if (Array.isArray(value)) {
-        return value.every(expressionOrPrimitiveIsLiteral);
-    }
-    else if (isRecord(value)) {
-        return Object.values(value).every(expressionOrPrimitiveIsLiteral);
-    }
-    else {
-        return (typeof value === 'string' ||
-            typeof value === 'number' ||
-            typeof value === 'boolean' ||
-            value === null);
-    }
-}
-export function isFullyQualifiedName(ex) {
-    switch (ex.expressionType) {
-        case 'primitive':
+export function isQualifiedName(ex) {
+    switch (ex.tag) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'null':
+        case 'list':
+        case 'map':
         case 'binary':
         case 'functionInvocation':
         case 'unary':
@@ -295,27 +177,14 @@ export function isFullyQualifiedName(ex) {
         case 'variableReference':
             return true;
         case 'member':
-            return (isFullyQualifiedName(ex.object) &&
-                (isFullyQualifiedName(ex.property) ||
-                    (ex.computed && ex.property.expressionType === 'primitive')));
+            return (isQualifiedName(ex.object) &&
+                (isQualifiedName(ex.property) ||
+                    (ex.computed && isPrimitive(ex.property))));
     }
 }
-/**
- * Returns true if ex is pure expression (can't have side-effects)
- */
-export function isPure(ex) {
-    switch (ex.expressionType) {
-        case 'primitive':
-            return true;
-        case 'binary':
-            return isPure(ex.left) && isPure(ex.right);
-        case 'functionInvocation':
-            return false;
-        case 'variableReference':
-            return true;
-        case 'member':
-            return isPure(ex.object) && isPure(ex.property);
-        case 'unary':
-            return isPure(ex.value);
-    }
+export function isPrimitive(ex) {
+    return (ex.tag === 'string' ||
+        ex.tag === 'number' ||
+        ex.tag === 'boolean' ||
+        ex.tag === 'null');
 }

package/dist/ast/statements.d.ts

@@ -0,0 +1,132 @@
+import { Expression, MemberExpression, VariableName, VariableReferenceExpression } from './expressions.js';
+import { StepName } from './steps.js';
+export type WorkflowParameters = Record<VariableName, Expression>;
+export interface VariableAssignment {
+    name: VariableReferenceExpression | MemberExpression;
+    value: Expression;
+}
+export interface CustomRetryPolicy {
+    predicate?: string;
+    maxRetries: Expression;
+    backoff: {
+        initialDelay?: Expression;
+        maxDelay?: Expression;
+        multiplier?: Expression;
+    };
+}
+export declare class AssignStatement {
+    readonly assignments: VariableAssignment[];
+    readonly tag = "assign";
+    constructor(assignments: VariableAssignment[]);
+}
+export declare class BreakStatement {
+    readonly label?: string | undefined;
+    readonly tag = "break";
+    constructor(label?: string | undefined);
+}
+export declare class ContinueStatement {
+    readonly label?: string | undefined;
+    readonly tag = "continue";
+    constructor(label?: string | undefined);
+}
+export declare class ForStatement {
+    readonly body: WorkflowStatement[];
+    readonly loopVariableName: VariableName;
+    readonly listExpression: Expression;
+    readonly indexVariableName?: VariableName | undefined;
+    readonly tag = "for";
+    constructor(body: WorkflowStatement[], loopVariableName: VariableName, listExpression: Expression, indexVariableName?: VariableName | undefined);
+}
+export declare class ForRangeStatement {
+    readonly body: WorkflowStatement[];
+    readonly loopVariableName: VariableName;
+    readonly rangeStart: number | Expression;
+    readonly rangeEnd: number | Expression;
+    readonly tag = "for-range";
+    constructor(body: WorkflowStatement[], loopVariableName: VariableName, rangeStart: number | Expression, rangeEnd: number | Expression);
+}
+export declare class FunctionInvocationStatement {
+    readonly callee: string;
+    readonly args?: WorkflowParameters | undefined;
+    readonly result?: VariableName | undefined;
+    readonly tag = "function-invocation";
+    constructor(callee: string, args?: WorkflowParameters | undefined, result?: VariableName | undefined);
+}
+export interface IfBranch {
+    readonly condition: Expression;
+    readonly body: WorkflowStatement[];
+}
+export interface IfNextBranch {
+    readonly condition: Expression;
+    readonly next: StepName;
+}
+export declare class IfStatement {
+    readonly branches: (IfBranch | IfNextBranch)[];
+    readonly tag = "if";
+    constructor(branches: (IfBranch | IfNextBranch)[]);
+}
+export interface ParallelBranch {
+    readonly name: string;
+    readonly body: WorkflowStatement[];
+}
+export declare class ParallelStatement {
+    readonly branches: ParallelBranch[];
+    readonly shared?: VariableName[] | undefined;
+    readonly concurrencyLimit?: number | undefined;
+    readonly exceptionPolicy?: string | undefined;
+    readonly tag = "parallel";
+    constructor(branches: ParallelBranch[], shared?: VariableName[] | undefined, concurrencyLimit?: number | undefined, exceptionPolicy?: string | undefined);
+}
+export declare class ParallelForStatement {
+    readonly forStep: ForStatement | ForRangeStatement;
+    readonly shared?: VariableName[] | undefined;
+    readonly concurrencyLimit?: number | undefined;
+    readonly exceptionPolicy?: string | undefined;
+    readonly tag = "parallel-for";
+    constructor(forStep: ForStatement | ForRangeStatement, shared?: VariableName[] | undefined, concurrencyLimit?: number | undefined, exceptionPolicy?: string | undefined);
+}
+export declare class RaiseStatement {
+    readonly value: Expression;
+    readonly tag = "raise";
+    constructor(value: Expression);
+}
+export declare class ReturnStatement {
+    readonly value: Expression | undefined;
+    readonly tag = "return";
+    constructor(value: Expression | undefined);
+}
+export declare class SwitchStatement {
+    readonly branches: IfBranch[];
+    readonly tag = "switch";
+    constructor(branches: IfBranch[]);
+}
+export declare class TryStatement {
+    readonly tryBody: WorkflowStatement[];
+    readonly exceptBody?: WorkflowStatement[] | undefined;
+    readonly retryPolicy?: (string | CustomRetryPolicy) | undefined;
+    readonly errorMap?: VariableName | undefined;
+    readonly finalizerBody?: WorkflowStatement[] | undefined;
+    readonly tag = "try";
+    constructor(tryBody: WorkflowStatement[], exceptBody?: WorkflowStatement[] | undefined, retryPolicy?: (string | CustomRetryPolicy) | undefined, errorMap?: VariableName | undefined, finalizerBody?: WorkflowStatement[] | undefined);
+}
+export declare class WhileStatement {
+    readonly condition: Expression;
+    readonly body: WorkflowStatement[];
+    readonly tag = "while";
+    constructor(condition: Expression, body: WorkflowStatement[]);
+}
+export declare class DoWhileStatement {
+    readonly condition: Expression;
+    readonly body: WorkflowStatement[];
+    readonly tag = "do-while";
+    constructor(condition: Expression, body: WorkflowStatement[]);
+}
+export declare class LabelledStatement {
+    readonly label: string;
+    readonly statements: WorkflowStatement[];
+    readonly tag = "label";
+    constructor(label: string, statements: WorkflowStatement[]);
+}
+export type WorkflowStatement = AssignStatement | BreakStatement | ContinueStatement | DoWhileStatement | ForStatement | ForRangeStatement | FunctionInvocationStatement | IfStatement | LabelledStatement | ParallelForStatement | ParallelStatement | RaiseStatement | ReturnStatement | SwitchStatement | TryStatement | WhileStatement;
+export declare function applyNested(fn: (x: WorkflowStatement[]) => WorkflowStatement[], s: WorkflowStatement): WorkflowStatement;
+//# sourceMappingURL=statements.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../src/ast/statements.ts"],"names":[],"mappings":"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"}