ts2workflows 0.1.0

package/dist/ast/stepnames.js

@@ -0,0 +1,268 @@
+import { ForStepASTNamed, NextStepAST, ParallelStepASTNamed, StepsStepASTNamed, SwitchStepASTNamed, TryStepASTNamed, nestedSteps, } from './steps.js';
+import { Subworkflow, WorkflowApp } from './workflows.js';
+export class StepNameGenerator {
+    counters;
+    constructor() {
+        this.counters = new Map();
+    }
+    generate(prefix) {
+        const i = this.counters.get(prefix) ?? 1;
+        this.counters.set(prefix, i + 1);
+        return `${prefix}${i}`;
+    }
+}
+export function generateStepNames(ast) {
+    const stepNameGenerator = new StepNameGenerator();
+    const subworkflows = ast.subworkflows
+        .map((subworkflow) => {
+        return subworkflow.withStepNames((x) => stepNameGenerator.generate(x));
+    })
+        .map(fixJumpLabels);
+    return new WorkflowApp(subworkflows);
+}
+function fixJumpLabels(subworkflow) {
+    const jumpTargetLabels = collectActualJumpTargets(subworkflow);
+    const stepsWithoutJumpTargetNodes = removeJumpTargetSteps(subworkflow.steps);
+    const relabeledSteps = relabelNextLabels(stepsWithoutJumpTargetNodes, jumpTargetLabels);
+    return new Subworkflow(subworkflow.name, relabeledSteps, subworkflow.params);
+}
+/**
+ * Find a mapping from jump target labels to step names.
+ *
+ * Iterate over all steps in the workflow. For JumpTargetAST nodes, find the
+ * next node that is not a JumpTargetAST, save its name as the real jump taget
+ * name.
+ */
+function collectActualJumpTargets(subworkflow) {
+    const replacements = new Map();
+    // The processing is done iteratively with an explicit stack because
+    // nextNonJumpTargetNode() needs the stack. Note the order of steps on the
+    // stack: the first step is the last element of the stack.
+    const stack = [];
+    stack.push(...stepsToJumpStackElements(subworkflow.steps, 0));
+    while (stack.length > 0) {
+        // Do not yet pop in case nextNonJumpTargetNode needs to search the stack
+        const { namedStep, nestingLevel } = stack[stack.length - 1];
+        if (namedStep.step.tag === 'jumptarget') {
+            const currentLabel = namedStep.step.label;
+            const target = nextNonJumpTargetNode(stack);
+            const targetName = target ? target.name : 'end';
+            replacements.set(currentLabel, targetName);
+        }
+        // Now nextNonJumpTargetNode has been executed and it's safe to pop the
+        // current element from the stack.
+        stack.pop();
+        const children = nestedSteps(namedStep.step).map((x) => stepsToJumpStackElements(x, nestingLevel + 1));
+        children.reverse();
+        children.forEach((children) => {
+            stack.push(...children);
+        });
+    }
+    return replacements;
+}
+function stepsToJumpStackElements(steps, nestingLevel) {
+    const block = steps.map((step, i) => ({
+        namedStep: step,
+        nestingLevel,
+        isLastInBlock: i === steps.length - 1,
+    }));
+    block.reverse();
+    return block;
+}
+function nextNonJumpTargetNode(stack) {
+    if (stack.length <= 0) {
+        return undefined;
+    }
+    let nestingLevel = stack[stack.length - 1].nestingLevel;
+    while (nestingLevel >= 0) {
+        // Consider only the steps in the current code block (= the same nesting
+        // level, taking steps until isLastInBlock)
+        let endOfBlockIndex = stack.findLastIndex((x) => x.nestingLevel === nestingLevel && x.isLastInBlock);
+        if (endOfBlockIndex < 0) {
+            // should not be reached
+            endOfBlockIndex = stack.findLastIndex((x) => x.nestingLevel <= nestingLevel);
+            if (endOfBlockIndex < 0) {
+                endOfBlockIndex = 0;
+            }
+        }
+        const firstNonJumpTarget = stack
+            .slice(endOfBlockIndex)
+            .findLast((x) => x.nestingLevel === nestingLevel &&
+            x.namedStep.step.tag !== 'jumptarget');
+        if (firstNonJumpTarget) {
+            return firstNonJumpTarget.namedStep;
+        }
+        nestingLevel--;
+    }
+    return undefined;
+}
+function removeJumpTargetSteps(steps) {
+    return steps
+        .filter((x) => x.step.tag !== 'jumptarget')
+        .map(({ name, step }) => ({
+        name,
+        step: removeJumpTargetRecurse(step),
+    }));
+}
+function removeJumpTargetRecurse(step) {
+    switch (step.tag) {
+        case 'assign':
+        case 'call':
+        case 'next':
+        case 'raise':
+        case 'return':
+        case 'jumptarget':
+            return step;
+        case 'for':
+            return removeJumpTargetsFor(step);
+        case 'parallel':
+            return removeJumpTargetsParallel(step);
+        case 'steps':
+            return new StepsStepASTNamed(removeJumpTargetSteps(step.steps));
+        case 'switch':
+            return removeJumpTargetsSwitch(step);
+        case 'try':
+            return new TryStepASTNamed(removeJumpTargetSteps(step.trySteps), removeJumpTargetSteps(step.exceptSteps), step.retryPolicy, step.errorMap);
+    }
+}
+function removeJumpTargetsFor(step) {
+    return new ForStepASTNamed(removeJumpTargetSteps(step.steps), step.loopVariableName, step.listExpression, step.indexVariableName, step.rangeStart, step.rangeEnd);
+}
+function removeJumpTargetsParallel(step) {
+    let transformedSteps;
+    if (step.branches) {
+        transformedSteps = Object.fromEntries(step.branches.map((x) => {
+            return [
+                x.name,
+                new StepsStepASTNamed(removeJumpTargetSteps(nestedSteps(x.step).flat())),
+            ];
+        }));
+    }
+    else if (step.forStep) {
+        transformedSteps = removeJumpTargetsFor(step.forStep);
+    }
+    else {
+        // should not be reached
+        transformedSteps = {};
+    }
+    return new ParallelStepASTNamed(transformedSteps, step.shared, step.concurrenceLimit, step.exceptionPolicy);
+}
+function removeJumpTargetsSwitch(step) {
+    const transformedConditions = step.conditions.map((cond) => {
+        return {
+            condition: cond.condition,
+            steps: removeJumpTargetSteps(cond.steps),
+            next: cond.next,
+        };
+    });
+    return new SwitchStepASTNamed(transformedConditions, step.next);
+}
+function relabelNextLabels(steps, replacements) {
+    return steps.map((step) => ({
+        name: step.name,
+        step: renameJumpTargets(step.step, replacements),
+    }));
+}
+/**
+ * Renames a copy of a step with jump targets renamed according to replaceLabels map.
+ */
+function renameJumpTargets(step, replaceLabels) {
+    switch (step.tag) {
+        case 'assign':
+        case 'call':
+        case 'raise':
+        case 'return':
+        case 'jumptarget':
+            return step;
+        case 'next':
+            return renameJumpTargetsNext(step, replaceLabels);
+        case 'for':
+            return renameJumpTargetsFor(step, replaceLabels);
+        case 'parallel':
+            return renameJumpTargetsParallel(step, replaceLabels);
+        case 'steps':
+            return renameJumpTargetsSteps(step, replaceLabels);
+        case 'switch':
+            return renameJumpTargetsSwitch(step, replaceLabels);
+        case 'try':
+            return renameJumpTargetsTry(step, replaceLabels);
+    }
+}
+function renameJumpTargetsFor(step, replaceLabels) {
+    const transformedSteps = step.steps.map(({ name, step: nested }) => ({
+        name,
+        step: renameJumpTargets(nested, replaceLabels),
+    }));
+    return new ForStepASTNamed(transformedSteps, step.loopVariableName, step.listExpression, step.indexVariableName, step.rangeStart, step.rangeEnd);
+}
+function renameJumpTargetsNext(step, replaceLabels) {
+    const newLabel = replaceLabels.get(step.target);
+    if (newLabel) {
+        return new NextStepAST(newLabel);
+    }
+    else {
+        return step;
+    }
+}
+function renameJumpTargetsParallel(step, replaceLabels) {
+    let transformedSteps;
+    if (step.branches) {
+        transformedSteps = Object.fromEntries(step.branches.map(({ name, step: nested }) => {
+            const renamedNested = nestedSteps(nested)
+                .flat()
+                .map((x) => ({
+                name: x.name,
+                step: renameJumpTargets(x.step, replaceLabels),
+            }));
+            return [name, new StepsStepASTNamed(renamedNested)];
+        }));
+    }
+    else if (step.forStep) {
+        transformedSteps = renameJumpTargetsFor(step.forStep, replaceLabels);
+    }
+    else {
+        // should not be reached
+        transformedSteps = {};
+    }
+    return new ParallelStepASTNamed(transformedSteps, step.shared, step.concurrenceLimit, step.exceptionPolicy);
+}
+function renameJumpTargetsSteps(step, replaceLabels) {
+    const transformedSteps = step.steps.map(({ name, step: nested }) => ({
+        name,
+        step: renameJumpTargets(nested, replaceLabels),
+    }));
+    return new StepsStepASTNamed(transformedSteps);
+}
+function renameJumpTargetsSwitch(step, replaceLabels) {
+    let updatedNext = undefined;
+    if (step.next) {
+        updatedNext = replaceLabels.get(step.next) ?? step.next;
+    }
+    const updatedConditions = step.conditions.map((cond) => {
+        let updatedCondNext = undefined;
+        if (cond.next) {
+            updatedCondNext = replaceLabels.get(cond.next) ?? cond.next;
+        }
+        const updatedCondSteps = cond.steps.map((nested) => ({
+            name: nested.name,
+            step: renameJumpTargets(nested.step, replaceLabels),
+        }));
+        return {
+            condition: cond.condition,
+            steps: updatedCondSteps,
+            next: updatedCondNext,
+        };
+    });
+    return new SwitchStepASTNamed(updatedConditions, updatedNext);
+}
+function renameJumpTargetsTry(step, replaceLabels) {
+    const transformedTrySteps = step.trySteps.map(({ name, step: nested }) => ({
+        name,
+        step: renameJumpTargets(nested, replaceLabels),
+    }));
+    const transformedExceptSteps = step.exceptSteps.map(({ name, step: nested }) => ({
+        name,
+        step: renameJumpTargets(nested, replaceLabels),
+    }));
+    return new TryStepASTNamed(transformedTrySteps, transformedExceptSteps, step.retryPolicy, step.errorMap);
+}

package/dist/ast/steps.d.ts

@@ -0,0 +1,176 @@
+import { Expression, VariableName } from './expressions.js';
+import { Subworkflow, WorkflowParameter } from './workflows.js';
+export type StepName = string;
+export type VariableAssignment = readonly [VariableName, Expression];
+export type WorkflowParameters = Record<VariableName, Expression>;
+export interface CustomRetryPolicy {
+    predicate: string;
+    maxRetries: number;
+    backoff: {
+        initialDelay: number;
+        maxDelay: number;
+        multiplier: number;
+    };
+}
+export interface WorkflowAST {
+    readonly subworkflows: SubworkflowAST[];
+}
+export declare class SubworkflowAST {
+    readonly name: string;
+    readonly steps: WorkflowStepAST[];
+    readonly params?: WorkflowParameter[];
+    constructor(name: string, steps: WorkflowStepAST[], params?: WorkflowParameter[]);
+    withStepNames(generate: (prefix: string) => string): Subworkflow;
+}
+/**
+ * A workflow step before step names have been assigned.
+ */
+export type WorkflowStepAST = AssignStepAST | CallStepAST | ForStepAST | NextStepAST | ParallelStepAST | RaiseStepAST | ReturnStepAST | StepsStepAST | SwitchStepAST | TryStepAST | JumpTargetAST;
+/**
+ * A workflow step after names have been generated for the nested steps.
+ */
+export type WorkflowStepASTWithNamedNested = AssignStepAST | CallStepAST | ForStepASTNamed | NextStepAST | ParallelStepASTNamed | RaiseStepAST | ReturnStepAST | StepsStepASTNamed | SwitchStepASTNamed | TryStepASTNamed | JumpTargetAST;
+export interface NamedWorkflowStep {
+    name: StepName;
+    step: WorkflowStepASTWithNamedNested;
+}
+export declare class AssignStepAST {
+    readonly tag = "assign";
+    readonly assignments: VariableAssignment[];
+    readonly label: string | undefined;
+    constructor(assignments: VariableAssignment[], label?: string);
+}
+export declare class CallStepAST {
+    readonly tag = "call";
+    readonly call: string;
+    readonly args?: WorkflowParameters;
+    readonly result?: VariableName;
+    readonly label: string | undefined;
+    constructor(call: string, args?: WorkflowParameters, result?: VariableName, label?: string);
+    labelPrefix(): string;
+}
+export declare class ForStepAST {
+    readonly tag = "for";
+    readonly steps: WorkflowStepAST[];
+    readonly loopVariableName: VariableName;
+    readonly indexVariableName?: VariableName;
+    readonly listExpression: Expression;
+    readonly rangeStart?: number;
+    readonly rangeEnd?: number;
+    readonly label: string | undefined;
+    constructor(steps: WorkflowStepAST[], loopVariableName: VariableName, listExpression: Expression, indexVariable?: VariableName, rangeStart?: number, rangeEnd?: number, label?: string);
+}
+export declare class ForStepASTNamed {
+    readonly tag = "for";
+    readonly steps: NamedWorkflowStep[];
+    readonly loopVariableName: VariableName;
+    readonly indexVariableName?: VariableName;
+    readonly listExpression?: Expression;
+    readonly rangeStart?: number;
+    readonly rangeEnd?: number;
+    constructor(steps: NamedWorkflowStep[], loopVariableName: VariableName, listExpression?: Expression, indexVariable?: VariableName, rangeStart?: number, rangeEnd?: number);
+}
+export declare class NextStepAST {
+    readonly tag = "next";
+    readonly target: string;
+    readonly label: string | undefined;
+    constructor(target: string, label?: string);
+}
+export declare class ParallelStepAST {
+    readonly tag = "parallel";
+    readonly steps: Record<StepName, StepsStepAST> | ForStepAST;
+    readonly shared?: VariableName[];
+    readonly concurrencyLimit?: number;
+    readonly exceptionPolicy?: string;
+    readonly label: string | undefined;
+    constructor(steps: Record<StepName, StepsStepAST> | ForStepAST, shared?: VariableName[], concurrencyLimit?: number, exceptionPolicy?: string, label?: string);
+}
+export declare class ParallelStepASTNamed {
+    readonly tag = "parallel";
+    readonly branches?: NamedWorkflowStep[];
+    readonly forStep?: ForStepASTNamed;
+    readonly shared?: VariableName[];
+    readonly concurrenceLimit?: number;
+    readonly exceptionPolicy?: string;
+    constructor(steps: Record<StepName, StepsStepASTNamed> | ForStepASTNamed, shared?: VariableName[], concurrencyLimit?: number, exceptionPolicy?: string);
+}
+export declare class RaiseStepAST {
+    readonly tag = "raise";
+    readonly value: Expression;
+    readonly label: string | undefined;
+    constructor(value: Expression, label?: string);
+}
+export declare class ReturnStepAST {
+    readonly tag = "return";
+    readonly value: Expression | undefined;
+    readonly label: string | undefined;
+    constructor(value: Expression | undefined, label?: string);
+}
+export declare class StepsStepAST {
+    readonly tag = "steps";
+    readonly steps: WorkflowStepAST[];
+    readonly label: string | undefined;
+    constructor(steps: WorkflowStepAST[], label?: string);
+}
+export declare class StepsStepASTNamed {
+    readonly tag = "steps";
+    readonly steps: NamedWorkflowStep[];
+    constructor(steps: NamedWorkflowStep[]);
+}
+export declare class SwitchStepAST {
+    readonly tag = "switch";
+    readonly branches: SwitchConditionAST<WorkflowStepAST>[];
+    readonly label: string | undefined;
+    constructor(branches: SwitchConditionAST<WorkflowStepAST>[], label?: string);
+}
+export declare class SwitchStepASTNamed {
+    readonly tag = "switch";
+    readonly conditions: SwitchConditionAST<NamedWorkflowStep>[];
+    readonly next?: StepName;
+    constructor(conditions: SwitchConditionAST<NamedWorkflowStep>[], next?: StepName);
+}
+export interface SwitchConditionAST<T extends WorkflowStepAST | NamedWorkflowStep> {
+    readonly condition: Expression;
+    readonly steps: T[];
+    readonly next?: StepName;
+}
+export declare class TryStepAST {
+    readonly tag = "try";
+    readonly trySteps: WorkflowStepAST[];
+    readonly exceptSteps: WorkflowStepAST[];
+    readonly retryPolicy?: string | CustomRetryPolicy;
+    readonly errorMap?: VariableName;
+    readonly label: string | undefined;
+    constructor(trySteps: WorkflowStepAST[], exceptSteps: WorkflowStepAST[], retryPolicy?: string | CustomRetryPolicy, errorMap?: VariableName, label?: string);
+}
+export declare class TryStepASTNamed {
+    readonly tag = "try";
+    readonly retryPolicy?: string | CustomRetryPolicy;
+    readonly errorMap?: VariableName;
+    readonly trySteps: NamedWorkflowStep[];
+    readonly exceptSteps: NamedWorkflowStep[];
+    constructor(steps: NamedWorkflowStep[], exceptSteps: NamedWorkflowStep[], retryPolicy?: string | CustomRetryPolicy, errorMap?: VariableName);
+}
+export declare class JumpTargetAST {
+    readonly tag = "jumptarget";
+    readonly label: string;
+    constructor();
+}
+/**
+ * Assign a name for this step and its child steps.
+ *
+ * The name is generated by calling generateName with a prefix identifying the step type.
+ */
+export declare function namedSteps(step: WorkflowStepAST, generateName: (prefix: string) => string): NamedWorkflowStep;
+/**
+ * Returns the nested steps in contained in this step.
+ *
+ * Used in iterating the AST tree.
+ */
+export declare function nestedSteps(step: WorkflowStepASTWithNamedNested): NamedWorkflowStep[][];
+/**
+ * Returns an GCP Workflows object representation of a step.
+ */
+export declare function renderStep(step: WorkflowStepASTWithNamedNested): Record<string, unknown>;
+export declare function stepWithLabel(step: WorkflowStepAST, label: string): WorkflowStepAST;
+//# sourceMappingURL=steps.d.ts.map

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

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