ts2workflows 0.1.0

package/dist/ast/steps.js

@@ -0,0 +1,534 @@
+import { isRecord } from '../utils.js';
+import { expressionToLiteralValueOrLiteralExpression, } from './expressions.js';
+import { Subworkflow } from './workflows.js';
+export class SubworkflowAST {
+    name;
+    steps;
+    params;
+    constructor(name, steps, params) {
+        this.name = name;
+        this.steps = steps;
+        this.params = params;
+    }
+    withStepNames(generate) {
+        const steps = this.steps.map((step) => namedSteps(step, generate));
+        return new Subworkflow(this.name, steps, this.params);
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/variables#assign-step
+export class AssignStepAST {
+    tag = 'assign';
+    assignments;
+    label;
+    constructor(assignments, label) {
+        this.assignments = assignments;
+        this.label = label;
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/calls
+export class CallStepAST {
+    tag = 'call';
+    call;
+    args;
+    result;
+    label;
+    constructor(call, args, result, label) {
+        this.call = call;
+        this.args = args;
+        this.result = result;
+        this.label = label;
+    }
+    labelPrefix() {
+        return 'call_' + this.call.replaceAll(/[^a-zA-Z0-9]/g, '_') + '_';
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/iteration
+export class ForStepAST {
+    tag = 'for';
+    steps;
+    loopVariableName;
+    indexVariableName;
+    listExpression;
+    rangeStart;
+    rangeEnd;
+    label;
+    constructor(steps, loopVariableName, listExpression, indexVariable, rangeStart, rangeEnd, label) {
+        this.steps = steps;
+        this.loopVariableName = loopVariableName;
+        this.listExpression = listExpression;
+        this.indexVariableName = indexVariable;
+        this.rangeStart = rangeStart;
+        this.rangeEnd = rangeEnd;
+        this.label = label;
+    }
+}
+export class ForStepASTNamed {
+    tag = 'for';
+    steps;
+    loopVariableName;
+    indexVariableName;
+    listExpression;
+    rangeStart;
+    rangeEnd;
+    constructor(steps, loopVariableName, listExpression, indexVariable, rangeStart, rangeEnd) {
+        this.steps = steps;
+        this.loopVariableName = loopVariableName;
+        this.listExpression = listExpression;
+        this.indexVariableName = indexVariable;
+        this.rangeStart = rangeStart;
+        this.rangeEnd = rangeEnd;
+    }
+}
+export class NextStepAST {
+    tag = 'next';
+    target;
+    label;
+    constructor(target, label) {
+        this.target = target;
+        this.label = label;
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/parallel-steps
+export class ParallelStepAST {
+    tag = 'parallel';
+    steps;
+    shared;
+    concurrencyLimit;
+    exceptionPolicy;
+    label;
+    constructor(steps, shared, concurrencyLimit, exceptionPolicy, label) {
+        this.steps = steps;
+        this.shared = shared;
+        this.concurrencyLimit = concurrencyLimit;
+        this.exceptionPolicy = exceptionPolicy;
+        this.label = label;
+    }
+}
+export class ParallelStepASTNamed {
+    tag = 'parallel';
+    branches; // Either steps for each branch
+    forStep; // ... or a parallel for
+    shared;
+    concurrenceLimit;
+    exceptionPolicy;
+    constructor(steps, shared, concurrencyLimit, exceptionPolicy) {
+        this.shared = shared;
+        this.concurrenceLimit = concurrencyLimit;
+        this.exceptionPolicy = exceptionPolicy;
+        if (!isRecord(steps)) {
+            this.forStep = steps;
+        }
+        else {
+            this.branches = Object.entries(steps).map((x) => {
+                return { name: x[0], step: x[1] };
+            });
+        }
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/raising-errors
+export class RaiseStepAST {
+    tag = 'raise';
+    value;
+    label;
+    constructor(value, label) {
+        this.value = value;
+        this.label = label;
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/completing
+export class ReturnStepAST {
+    tag = 'return';
+    value;
+    label;
+    constructor(value, label) {
+        this.value = value;
+        this.label = label;
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/steps#embedded-steps
+export class StepsStepAST {
+    tag = 'steps';
+    steps;
+    label;
+    constructor(steps, label) {
+        this.steps = steps;
+        this.label = label;
+    }
+}
+export class StepsStepASTNamed {
+    tag = 'steps';
+    steps;
+    constructor(steps) {
+        this.steps = steps;
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/conditions
+export class SwitchStepAST {
+    tag = 'switch';
+    branches;
+    label;
+    constructor(branches, label) {
+        this.branches = branches;
+        this.label = label;
+    }
+}
+export class SwitchStepASTNamed {
+    tag = 'switch';
+    conditions;
+    next;
+    constructor(conditions, next) {
+        this.conditions = conditions;
+        this.next = next;
+    }
+}
+// https://cloud.google.com/workflows/docs/reference/syntax/catching-errors
+export class TryStepAST {
+    tag = 'try';
+    trySteps;
+    exceptSteps;
+    retryPolicy;
+    errorMap;
+    label;
+    constructor(trySteps, exceptSteps, retryPolicy, errorMap, label) {
+        this.trySteps = trySteps;
+        this.exceptSteps = exceptSteps;
+        this.retryPolicy = retryPolicy;
+        this.errorMap = errorMap;
+        this.label = label;
+    }
+}
+export class TryStepASTNamed {
+    tag = 'try';
+    retryPolicy;
+    errorMap;
+    // Steps in the try block
+    trySteps;
+    // Steps in the except block
+    exceptSteps;
+    constructor(steps, exceptSteps, retryPolicy, errorMap) {
+        this.trySteps = steps;
+        this.retryPolicy = retryPolicy;
+        this.errorMap = errorMap;
+        this.exceptSteps = exceptSteps;
+    }
+}
+// Internal step that represents a potential jump target.
+// This can be ued as a placeholder when the actual target step is not yet known.
+// JumpTargetAST is removed before transpiling to workflows YAML.
+export class JumpTargetAST {
+    tag = 'jumptarget';
+    label;
+    constructor() {
+        this.label = `jumptarget_${Math.floor(Math.random() * 2 ** 32).toString(16)}`;
+    }
+}
+/**
+ * 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 function namedSteps(step, generateName) {
+    switch (step.tag) {
+        case 'assign':
+        case 'next':
+        case 'raise':
+        case 'return':
+            return {
+                name: step.label ?? generateName(step.tag),
+                step,
+            };
+        case 'call':
+            return {
+                name: step.label ?? generateName(step.labelPrefix()),
+                step,
+            };
+        case 'for':
+            return namedStepsFor(step, generateName);
+        case 'parallel':
+            return namedStepsParallel(step, generateName);
+        case 'steps':
+            return namedStepsSteps(step, generateName);
+        case 'switch':
+            return namedStepsSwitch(step, generateName);
+        case 'try':
+            return namedStepsTry(step, generateName);
+        case 'jumptarget':
+            return {
+                name: step.label,
+                step: step,
+            };
+    }
+}
+function namedStepsFor(step, generateName) {
+    return {
+        name: step.label ?? generateName('for'),
+        step: new ForStepASTNamed(step.steps.map((nestedStep) => namedSteps(nestedStep, generateName)), step.loopVariableName, step.listExpression),
+    };
+}
+function namedStepsParallel(step, generateName) {
+    let steps;
+    if (!isRecord(step.steps)) {
+        const forStep = namedSteps(step.steps, generateName).step;
+        if (forStep.tag !== 'for') {
+            throw new Error(`Encountered a step of type ${forStep.tag} when a for step was expected`);
+        }
+        steps = forStep;
+    }
+    else {
+        steps = Object.fromEntries(Object.entries(step.steps).map(([name, nested]) => {
+            const named = nested.steps.map((x) => namedSteps(x, generateName));
+            return [name, new StepsStepASTNamed(named)];
+        }));
+    }
+    return {
+        name: step.label ?? generateName('parallel'),
+        step: new ParallelStepASTNamed(steps, step.shared, step.concurrencyLimit, step.exceptionPolicy),
+    };
+}
+function namedStepsSteps(step, generateName) {
+    return {
+        name: step.label ?? generateName('steps'),
+        step: new StepsStepASTNamed(step.steps.map((nested) => namedSteps(nested, generateName))),
+    };
+}
+function namedStepsSwitch(step, generateName) {
+    const namedBranches = step.branches.map((branch) => ({
+        condition: branch.condition,
+        steps: branch.steps.map((nested) => namedSteps(nested, generateName)),
+        next: branch.next,
+    }));
+    return {
+        name: step.label ?? generateName('switch'),
+        step: new SwitchStepASTNamed(namedBranches),
+    };
+}
+function namedStepsTry(step, generateName) {
+    const namedTrySteps = step.trySteps.map((nested) => namedSteps(nested, generateName));
+    const namedExceptSteps = step.exceptSteps.map((nested) => namedSteps(nested, generateName));
+    return {
+        name: step.label ?? generateName('try'),
+        step: new TryStepASTNamed(namedTrySteps, namedExceptSteps, step.retryPolicy, step.errorMap),
+    };
+}
+/**
+ * Returns the nested steps in contained in this step.
+ *
+ * Used in iterating the AST tree.
+ */
+export function nestedSteps(step) {
+    switch (step.tag) {
+        case 'assign':
+        case 'call':
+        case 'next':
+        case 'raise':
+        case 'return':
+        case 'jumptarget':
+            return [];
+        case 'for':
+        case 'steps':
+            return [step.steps];
+        case 'parallel':
+            return nestedStepsParallel(step);
+        case 'switch':
+            return step.conditions.map((x) => x.steps);
+        case 'try':
+            return nestedStepsTry(step);
+    }
+}
+function nestedStepsParallel(step) {
+    const nested = [];
+    if (step.branches && step.branches.length > 0) {
+        // return each branch as a separate child
+        nested.push(...step.branches.map((x) => [x]));
+    }
+    if (step.forStep?.steps && step.forStep.steps.length > 0) {
+        nested.push(step.forStep.steps);
+    }
+    return nested;
+}
+function nestedStepsTry(step) {
+    const nested = [];
+    if (step.trySteps.length > 0) {
+        nested.push(step.trySteps);
+    }
+    if (step.exceptSteps.length > 0) {
+        nested.push(step.exceptSteps);
+    }
+    return nested;
+}
+/**
+ * Returns an GCP Workflows object representation of a step.
+ */
+export function renderStep(step) {
+    switch (step.tag) {
+        case 'assign':
+            return {
+                assign: step.assignments.map(([key, val]) => {
+                    return { [key]: expressionToLiteralValueOrLiteralExpression(val) };
+                }),
+            };
+        case 'call':
+            return renderCallStep(step);
+        case 'for':
+            return {
+                for: renderForBody(step),
+            };
+        case 'parallel':
+            return {
+                parallel: {
+                    ...(step.shared && { shared: step.shared }),
+                    ...(step.concurrenceLimit && {
+                        concurrency_limit: step.concurrenceLimit,
+                    }),
+                    ...(step.exceptionPolicy && {
+                        exception_policy: step.exceptionPolicy,
+                    }),
+                    ...(step.branches && { branches: renderSteps(step.branches) }),
+                    ...(step.forStep && { for: renderForBody(step.forStep) }),
+                },
+            };
+        case 'next':
+            return {
+                next: step.target,
+            };
+        case 'raise':
+            return {
+                raise: expressionToLiteralValueOrLiteralExpression(step.value),
+            };
+        case 'return':
+            return renderReturnStep(step);
+        case 'steps':
+            return {
+                steps: renderSteps(step.steps),
+            };
+        case 'switch':
+            return {
+                switch: step.conditions.map(renderSwitchCondition),
+                ...(step.next && { next: step.next }),
+            };
+        case 'try':
+            return renderTryStep(step);
+        case 'jumptarget':
+            return {};
+    }
+}
+function renderSwitchCondition(cond) {
+    return {
+        condition: expressionToLiteralValueOrLiteralExpression(cond.condition),
+        ...(cond.steps.length > 0 && { steps: renderSteps(cond.steps) }),
+        ...(cond.next && { next: cond.next }),
+    };
+}
+function renderCallStep(step) {
+    let args = undefined;
+    if (step.args) {
+        args = Object.fromEntries(Object.entries(step.args).map(([k, v]) => {
+            return [k, expressionToLiteralValueOrLiteralExpression(v)];
+        }));
+    }
+    return {
+        call: step.call,
+        ...(args && { args }),
+        ...(step.result && { result: step.result }),
+    };
+}
+function renderForBody(step) {
+    let range;
+    let inValue;
+    if (typeof step.listExpression === 'undefined') {
+        range = [step.rangeStart, step.rangeEnd];
+        inValue = undefined;
+    }
+    else {
+        inValue = expressionToLiteralValueOrLiteralExpression(step.listExpression);
+        range = undefined;
+    }
+    return {
+        value: step.loopVariableName,
+        ...(step.indexVariableName && { index: step.indexVariableName }),
+        ...(inValue && { in: inValue }),
+        ...(range && { range }),
+        steps: renderSteps(step.steps),
+    };
+}
+function renderReturnStep(step) {
+    if (step.value) {
+        return {
+            return: expressionToLiteralValueOrLiteralExpression(step.value),
+        };
+    }
+    else {
+        return {
+            next: 'end',
+        };
+    }
+}
+function renderTryStep(step) {
+    let retry;
+    if (typeof step.retryPolicy === 'undefined') {
+        retry = undefined;
+    }
+    else if (typeof step.retryPolicy === 'string') {
+        retry = `\${${step.retryPolicy}}`;
+    }
+    else {
+        const predicateName = step.retryPolicy.predicate;
+        retry = {
+            predicate: `\${${predicateName}}`,
+            max_retries: step.retryPolicy.maxRetries,
+            backoff: {
+                initial_delay: step.retryPolicy.backoff.initialDelay,
+                max_delay: step.retryPolicy.backoff.maxDelay,
+                multiplier: step.retryPolicy.backoff.multiplier,
+            },
+        };
+    }
+    let except;
+    if (step.exceptSteps.length > 0) {
+        except = {
+            as: step.errorMap,
+            steps: renderSteps(step.exceptSteps),
+        };
+    }
+    else {
+        except = undefined;
+    }
+    return {
+        try: {
+            steps: renderSteps(step.trySteps),
+        },
+        ...(retry && { retry }),
+        ...(except && { except }),
+    };
+}
+function renderSteps(steps) {
+    return steps.map((x) => {
+        return { [x.name]: renderStep(x.step) };
+    });
+}
+export function stepWithLabel(step, label) {
+    switch (step.tag) {
+        case 'assign':
+            return new AssignStepAST(step.assignments, label);
+        case 'call':
+            return new CallStepAST(step.call, step.args, step.result, label);
+        case 'for':
+            return new ForStepAST(step.steps, step.loopVariableName, step.listExpression, step.indexVariableName, step.rangeStart, step.rangeEnd, label);
+        case 'next':
+            return new NextStepAST(step.target, label);
+        case 'parallel':
+            return new ParallelStepAST(step.steps, step.shared, step.concurrencyLimit, step.exceptionPolicy, label);
+        case 'raise':
+            return new RaiseStepAST(step.value, label);
+        case 'return':
+            return new ReturnStepAST(step.value, label);
+        case 'steps':
+            return new StepsStepAST(step.steps, label);
+        case 'switch':
+            return new SwitchStepAST(step.branches, label);
+        case 'try':
+            return new TryStepAST(step.trySteps, step.exceptSteps, step.retryPolicy, step.errorMap, label);
+        case 'jumptarget':
+            return step;
+    }
+}

package/dist/ast/validation.d.ts

@@ -0,0 +1,20 @@
+import { WorkflowApp } from './workflows.js';
+export declare class WorkflowValidationError extends Error {
+    issues: WorkflowIssue[];
+    constructor(issues: WorkflowIssue[]);
+}
+export interface WorkflowIssue {
+    type: string;
+    message: string;
+}
+/**
+ * Execute all syntax validators on a WorkflowApp app.
+ *
+ * Throws a WorkflowValidationError if there are errors.
+ */
+export declare function validate(app: WorkflowApp, disabled?: string[]): void;
+/**
+ * Returns all validator names.
+ */
+export declare function validatorNames(): string[];
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/ast/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEzD,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,MAAM,EAAE,aAAa,EAAE,CAAA;gBAEX,MAAM,EAAE,aAAa,EAAE;CAMpC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAWD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,QAAQ,GAAE,MAAM,EAAO,GAAG,IAAI,CAexE;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAEzC"}