@n8n/workflow-sdk 0.2.0

package/dist/codegen/code-generator.js

@@ -0,0 +1,807 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCode = generateCode;
+const constants_1 = require("./constants");
+const execution_schema_jsdoc_1 = require("./execution-schema-jsdoc");
+const node_type_utils_1 = require("./node-type-utils");
+const string_utils_1 = require("./string-utils");
+const subnode_generator_1 = require("./subnode-generator");
+const variable_names_1 = require("./variable-names");
+function getIndent(ctx) {
+    return '  '.repeat(ctx.indent);
+}
+function generateSubnodeCall(subnodeNode, builderName, ctx) {
+    const parts = [];
+    parts.push(`type: '${subnodeNode.type}'`);
+    parts.push(`version: ${subnodeNode.json.typeVersion}`);
+    const configParts = [];
+    const defaultName = (0, node_type_utils_1.generateDefaultNodeName)(subnodeNode.type);
+    if (subnodeNode.json.name && subnodeNode.json.name !== defaultName) {
+        configParts.push(`name: '${(0, string_utils_1.escapeString)(subnodeNode.json.name)}'`);
+    }
+    if (subnodeNode.json.parameters && Object.keys(subnodeNode.json.parameters).length > 0) {
+        configParts.push(`parameters: ${(0, subnode_generator_1.formatValue)(subnodeNode.json.parameters, ctx)}`);
+    }
+    if (subnodeNode.json.credentials) {
+        configParts.push(`credentials: ${(0, subnode_generator_1.formatValue)(subnodeNode.json.credentials, ctx)}`);
+    }
+    const pos = subnodeNode.json.position;
+    if (pos && (pos[0] !== 0 || pos[1] !== 0)) {
+        configParts.push(`position: [${pos[0]}, ${pos[1]}]`);
+    }
+    const nestedSubnodesConfig = generateSubnodesConfigForNode(subnodeNode, ctx);
+    if (nestedSubnodesConfig) {
+        configParts.push(`subnodes: ${nestedSubnodesConfig}`);
+    }
+    if (configParts.length > 0) {
+        parts.push(`config: { ${configParts.join(', ')} }`);
+    }
+    else {
+        parts.push('config: {}');
+    }
+    return `${builderName}({ ${parts.join(', ')} })`;
+}
+function generateSubnodesConfigForNode(node, ctx) {
+    if (node.subnodes.length === 0) {
+        return null;
+    }
+    const grouped = new Map();
+    for (const sub of node.subnodes) {
+        const subnodeNode = ctx.graph.nodes.get(sub.subnodeName);
+        if (!subnodeNode)
+            continue;
+        const existing = grouped.get(sub.connectionType) ?? [];
+        existing.push(subnodeNode);
+        grouped.set(sub.connectionType, existing);
+    }
+    const entries = [];
+    for (const [connType, subnodeNodes] of grouped) {
+        const configKey = constants_1.AI_CONNECTION_TO_CONFIG_KEY[connType];
+        const builderName = constants_1.AI_CONNECTION_TO_BUILDER[connType];
+        if (subnodeNodes.length === 0)
+            continue;
+        const calls = subnodeNodes.map((n) => generateSubnodeCall(n, builderName, ctx));
+        if (constants_1.AI_ALWAYS_ARRAY_TYPES.has(connType)) {
+            entries.push(`${configKey}: [${calls.join(', ')}]`);
+        }
+        else if (constants_1.AI_OPTIONAL_ARRAY_TYPES.has(connType)) {
+            if (subnodeNodes.length === 1) {
+                entries.push(`${configKey}: ${calls[0]}`);
+            }
+            else {
+                entries.push(`${configKey}: [${calls.join(', ')}]`);
+            }
+        }
+        else {
+            entries.push(`${configKey}: ${calls[0]}`);
+        }
+    }
+    if (entries.length === 0) {
+        return null;
+    }
+    return `{ ${entries.join(', ')} }`;
+}
+function generateSubnodesConfig(node, ctx) {
+    return generateSubnodesConfigForNode(node, ctx);
+}
+function collectSubnodesAsVariables(node, ctx) {
+    if (node.subnodes.length === 0)
+        return;
+    for (const sub of node.subnodes) {
+        const subnodeNode = ctx.graph.nodes.get(sub.subnodeName);
+        if (!subnodeNode)
+            continue;
+        collectSubnodesAsVariables(subnodeNode, ctx);
+        const builderName = constants_1.AI_CONNECTION_TO_BUILDER[sub.connectionType];
+        ctx.subnodeVariables.set(sub.subnodeName, { node: subnodeNode, builderName });
+    }
+}
+function generateSubnodeCallWithVarRefs(subnodeNode, builderName, ctx) {
+    const parts = [];
+    parts.push(`type: '${subnodeNode.type}'`);
+    parts.push(`version: ${subnodeNode.json.typeVersion}`);
+    const configParts = [];
+    const defaultName = (0, node_type_utils_1.generateDefaultNodeName)(subnodeNode.type);
+    if (subnodeNode.json.name && subnodeNode.json.name !== defaultName) {
+        configParts.push(`name: '${(0, string_utils_1.escapeString)(subnodeNode.json.name)}'`);
+    }
+    if (subnodeNode.json.parameters && Object.keys(subnodeNode.json.parameters).length > 0) {
+        configParts.push(`parameters: ${(0, subnode_generator_1.formatValue)(subnodeNode.json.parameters, ctx)}`);
+    }
+    if (subnodeNode.json.credentials) {
+        configParts.push(`credentials: ${(0, subnode_generator_1.formatValue)(subnodeNode.json.credentials, ctx)}`);
+    }
+    const pos = subnodeNode.json.position;
+    if (pos && (pos[0] !== 0 || pos[1] !== 0)) {
+        configParts.push(`position: [${pos[0]}, ${pos[1]}]`);
+    }
+    const nestedSubnodesConfig = generateSubnodesConfigWithVarRefs(subnodeNode, ctx);
+    if (nestedSubnodesConfig) {
+        configParts.push(`subnodes: ${nestedSubnodesConfig}`);
+    }
+    if (configParts.length > 0) {
+        parts.push(`config: { ${configParts.join(', ')} }`);
+    }
+    else {
+        parts.push('config: {}');
+    }
+    return `${builderName}({ ${parts.join(', ')} })`;
+}
+function generateSubnodesConfigWithVarRefs(node, ctx) {
+    if (node.subnodes.length === 0) {
+        return null;
+    }
+    const grouped = new Map();
+    for (const sub of node.subnodes) {
+        const varName = (0, variable_names_1.getVarName)(sub.subnodeName, ctx);
+        const existing = grouped.get(sub.connectionType) ?? [];
+        existing.push(varName);
+        grouped.set(sub.connectionType, existing);
+    }
+    const entries = [];
+    for (const [connType, varNames] of grouped) {
+        const configKey = constants_1.AI_CONNECTION_TO_CONFIG_KEY[connType];
+        if (varNames.length === 0)
+            continue;
+        if (constants_1.AI_ALWAYS_ARRAY_TYPES.has(connType)) {
+            entries.push(`${configKey}: [${varNames.join(', ')}]`);
+        }
+        else if (constants_1.AI_OPTIONAL_ARRAY_TYPES.has(connType)) {
+            if (varNames.length === 1) {
+                entries.push(`${configKey}: ${varNames[0]}`);
+            }
+            else {
+                entries.push(`${configKey}: [${varNames.join(', ')}]`);
+            }
+        }
+        else {
+            entries.push(`${configKey}: ${varNames[0]}`);
+        }
+    }
+    if (entries.length === 0) {
+        return null;
+    }
+    return `{ ${entries.join(', ')} }`;
+}
+function generateSubnodeVariableDeclarations(ctx) {
+    const declarations = [];
+    for (const [nodeName, { node, builderName }] of ctx.subnodeVariables) {
+        const varName = (0, variable_names_1.getUniqueVarName)(nodeName, ctx);
+        const call = generateSubnodeCallWithVarRefs(node, builderName, ctx);
+        declarations.push(`const ${varName} = ${call};`);
+    }
+    return declarations;
+}
+function generateNodeConfig(node, ctx) {
+    const indent = getIndent(ctx);
+    const innerIndent = getIndent({ ...ctx, indent: ctx.indent + 1 });
+    const parts = [];
+    parts.push(`${innerIndent}type: '${node.type}'`);
+    parts.push(`${innerIndent}version: ${node.json.typeVersion}`);
+    const configParts = [];
+    if (node.json.name) {
+        configParts.push(`name: '${(0, string_utils_1.escapeString)(node.json.name)}'`);
+    }
+    if (node.json.parameters && Object.keys(node.json.parameters).length > 0) {
+        configParts.push(`parameters: ${(0, subnode_generator_1.formatValue)(node.json.parameters, ctx)}`);
+    }
+    if (node.json.credentials) {
+        configParts.push(`credentials: ${(0, subnode_generator_1.formatValue)(node.json.credentials, ctx)}`);
+    }
+    const pos = node.json.position;
+    if (pos && (pos[0] !== 0 || pos[1] !== 0)) {
+        configParts.push(`position: [${pos[0]}, ${pos[1]}]`);
+    }
+    if (node.json.onError) {
+        configParts.push(`onError: '${node.json.onError}'`);
+    }
+    const subnodesConfig = ctx.subnodeVariables.size > 0
+        ? generateSubnodesConfigWithVarRefs(node, ctx)
+        : generateSubnodesConfig(node, ctx);
+    if (subnodesConfig) {
+        configParts.push(`subnodes: ${subnodesConfig}`);
+    }
+    if (configParts.length > 0) {
+        const configStr = configParts.join(', ');
+        const hasExpressionAnnotations = configStr.includes('/** @example');
+        const hasMultiline = configParts.some((entry) => entry.includes('\n'));
+        if (hasExpressionAnnotations || hasMultiline) {
+            const configIndent = getIndent({ ...ctx, indent: ctx.indent + 2 });
+            const withCommas = configParts.map((entry, i) => {
+                if (i === configParts.length - 1)
+                    return entry;
+                const lastLineStart = entry.lastIndexOf('\n');
+                const lastLine = lastLineStart >= 0 ? entry.substring(lastLineStart) : entry;
+                if (lastLine.trimEnd().endsWith(',')) {
+                    return entry;
+                }
+                return entry + ',';
+            });
+            parts.push(`${innerIndent}config: {\n${withCommas.map((p) => `${configIndent}${p}`).join('\n')}\n${innerIndent}}`);
+        }
+        else {
+            parts.push(`${innerIndent}config: { ${configStr} }`);
+        }
+    }
+    else {
+        parts.push(`${innerIndent}config: {}`);
+    }
+    const nodeName = node.json.name;
+    if (nodeName && ctx.nodeSchemas?.has(nodeName)) {
+        const schema = ctx.nodeSchemas.get(nodeName);
+        const outputSample = (0, execution_schema_jsdoc_1.schemaToOutputSample)(schema, ctx.valuesExcluded);
+        if (outputSample && Object.keys(outputSample).length > 0) {
+            if (ctx.valuesExcluded) {
+                parts.push(`${innerIndent}// Output values redacted`);
+            }
+            if (ctx.pinnedNodes?.has(nodeName)) {
+                parts.push(`${innerIndent}// Data is pinned. User must unpin node for real data`);
+            }
+            parts.push(`${innerIndent}output: [${(0, subnode_generator_1.formatValue)(outputSample, ctx)}]`);
+        }
+    }
+    return `{\n${parts.join(',\n')}\n${indent}}`;
+}
+function getVarRefOrInlineNode(node, ctx) {
+    const nodeName = node.json.name;
+    if (nodeName && ctx.variableNodes.has(nodeName)) {
+        return (0, variable_names_1.getVarName)(nodeName, ctx);
+    }
+    return generateNodeCall(node, ctx);
+}
+function getNodesInsideSticky(stickyNode, ctx) {
+    const pos = stickyNode.json.position ?? [0, 0];
+    const params = stickyNode.json.parameters;
+    const width = Number(params?.width) || 0;
+    const height = Number(params?.height) || 0;
+    if (width === 0 || height === 0)
+        return [];
+    const containedNodes = [];
+    for (const [nodeName, node] of ctx.graph.nodes) {
+        if ((0, node_type_utils_1.isStickyNote)(node.type))
+            continue;
+        const nodePos = node.json.position ?? [0, 0];
+        if (nodePos[0] >= pos[0] &&
+            nodePos[0] <= pos[0] + width &&
+            nodePos[1] >= pos[1] &&
+            nodePos[1] <= pos[1] + height) {
+            const varName = ctx.nodeNameToVarName.get(nodeName);
+            if (varName)
+                containedNodes.push(varName);
+        }
+    }
+    return containedNodes;
+}
+function generateStickyCall(node, ctx) {
+    const content = (0, string_utils_1.escapeString)(node.json.parameters?.content ?? '');
+    const nodesInside = getNodesInsideSticky(node, ctx);
+    const nodesStr = `[${nodesInside.join(', ')}]`;
+    const options = [];
+    if (node.json.name) {
+        options.push(`name: '${(0, string_utils_1.escapeString)(node.json.name)}'`);
+    }
+    const params = node.json.parameters;
+    if (params?.color !== undefined) {
+        options.push(`color: ${String(params.color)}`);
+    }
+    if (params?.width !== undefined) {
+        options.push(`width: ${Number(params.width)}`);
+    }
+    if (params?.height !== undefined) {
+        options.push(`height: ${Number(params.height)}`);
+    }
+    const pos = node.json.position;
+    if (pos && (pos[0] !== 0 || pos[1] !== 0)) {
+        options.push(`position: [${pos[0]}, ${pos[1]}]`);
+    }
+    const optionsStr = options.length > 0 ? `, { ${options.join(', ')} }` : '';
+    return `sticky('${content}', ${nodesStr}${optionsStr})`;
+}
+function generateMergeCall(node, ctx) {
+    const indent = getIndent(ctx);
+    const innerIndent = getIndent({ ...ctx, indent: ctx.indent + 1 });
+    const parts = [];
+    parts.push(`${innerIndent}version: ${node.json.typeVersion}`);
+    const configParts = [];
+    if (node.json.name) {
+        configParts.push(`name: '${(0, string_utils_1.escapeString)(node.json.name)}'`);
+    }
+    if (node.json.parameters && Object.keys(node.json.parameters).length > 0) {
+        configParts.push(`parameters: ${(0, subnode_generator_1.formatValue)(node.json.parameters, ctx)}`);
+    }
+    if (node.json.credentials) {
+        configParts.push(`credentials: ${(0, subnode_generator_1.formatValue)(node.json.credentials, ctx)}`);
+    }
+    const pos = node.json.position;
+    if (pos && (pos[0] !== 0 || pos[1] !== 0)) {
+        configParts.push(`position: [${pos[0]}, ${pos[1]}]`);
+    }
+    if (node.json.onError) {
+        configParts.push(`onError: '${node.json.onError}'`);
+    }
+    if (configParts.length > 0) {
+        parts.push(`${innerIndent}config: { ${configParts.join(', ')} }`);
+    }
+    return `merge({\n${parts.join(',\n')}\n${indent}})`;
+}
+function generateNodeCall(node, ctx) {
+    if ((0, node_type_utils_1.isStickyNote)(node.type)) {
+        return generateStickyCall(node, ctx);
+    }
+    if ((0, node_type_utils_1.isMergeType)(node.type)) {
+        return generateMergeCall(node, ctx);
+    }
+    const config = generateNodeConfig(node, ctx);
+    if ((0, node_type_utils_1.isTriggerType)(node.type)) {
+        return `trigger(${config})`;
+    }
+    else {
+        return `node(${config})`;
+    }
+}
+function generateLeafCode(leaf, ctx) {
+    const nodeName = leaf.node.json.name;
+    if (nodeName && ctx.variableNodes.has(nodeName)) {
+        return (0, variable_names_1.getVarName)(nodeName, ctx);
+    }
+    const nodeCall = generateNodeCall(leaf.node, ctx);
+    if (nodeName) {
+        const jsdoc = generateNodeJSDoc(nodeName, ctx);
+        if (jsdoc) {
+            return `${jsdoc}\n${nodeCall}`;
+        }
+    }
+    return nodeCall;
+}
+function generateLeaf(leaf, ctx) {
+    let code = generateLeafCode(leaf, ctx);
+    if (leaf.errorHandler) {
+        const errorHandlerCode = generateComposite(leaf.errorHandler, ctx);
+        code += `\n${getIndent(ctx)}.onError(${errorHandlerCode})`;
+    }
+    return code;
+}
+function generateChain(chain, ctx) {
+    const parts = [];
+    for (let i = 0; i < chain.nodes.length; i++) {
+        const node = chain.nodes[i];
+        const nodeCode = generateComposite(node, ctx);
+        if (i === 0) {
+            parts.push(nodeCode);
+        }
+        else {
+            parts.push(`.to(${nodeCode})`);
+        }
+    }
+    return parts.join('\n' + getIndent(ctx));
+}
+function generateVarRef(varRef, _ctx) {
+    return varRef.varName;
+}
+function generateBranchCode(branch, ctx) {
+    if (branch === null)
+        return 'null';
+    if (Array.isArray(branch)) {
+        const branchesCode = branch.map((b) => generateComposite(b, ctx)).join(', ');
+        return `[${branchesCode}]`;
+    }
+    return generateComposite(branch, ctx);
+}
+function generateIfElse(ifElse, ctx) {
+    const innerCtx = { ...ctx, indent: ctx.indent + 1 };
+    const ifNodeRef = getVarRefOrInlineNode(ifElse.ifNode, ctx);
+    let code = ifNodeRef;
+    if (ifElse.trueBranch !== null) {
+        const trueBranchCode = generateBranchCode(ifElse.trueBranch, innerCtx);
+        code += `.onTrue(${trueBranchCode})`;
+    }
+    if (ifElse.falseBranch !== null) {
+        const falseBranchCode = generateBranchCode(ifElse.falseBranch, innerCtx);
+        code += `.onFalse(${falseBranchCode})`;
+    }
+    return code;
+}
+function generateSwitchCase(switchCase, ctx) {
+    const innerCtx = { ...ctx, indent: ctx.indent + 1 };
+    const switchNodeRef = getVarRefOrInlineNode(switchCase.switchNode, ctx);
+    if (switchCase.cases.length === 0) {
+        return switchNodeRef;
+    }
+    let code = switchNodeRef;
+    switchCase.cases.forEach((c, i) => {
+        const caseIndex = switchCase.caseIndices[i] ?? i;
+        const caseCode = generateBranchCode(c, innerCtx);
+        code += `.onCase(${caseIndex}, ${caseCode})`;
+    });
+    return code;
+}
+function generateMerge(merge, ctx) {
+    const innerCtx = { ...ctx, indent: ctx.indent + 1 };
+    const inputEntries = merge.branches
+        .map((b, i) => {
+        const inputIndex = merge.inputIndices[i] ?? i;
+        return `input${inputIndex}: ${generateComposite(b, innerCtx)}`;
+    })
+        .join(', ');
+    const mergeNodeRef = getVarRefOrInlineNode(merge.mergeNode, ctx);
+    return `merge(${mergeNodeRef}, { ${inputEntries} })`;
+}
+function branchEndsWithVarRef(branch) {
+    if (branch === null)
+        return false;
+    if (Array.isArray(branch)) {
+        return branch.some((b) => branchEndsWithVarRef(b));
+    }
+    if (branch.kind === 'chain') {
+        const lastNode = branch.nodes[branch.nodes.length - 1];
+        return lastNode?.kind === 'varRef';
+    }
+    return branch.kind === 'varRef';
+}
+function stripTrailingVarRefFromCode(code, varName) {
+    const toPattern = new RegExp(`\\.to\\(${(0, string_utils_1.escapeRegexChars)(varName)}\\)$`);
+    if (toPattern.test(code)) {
+        return code.replace(toPattern, '');
+    }
+    if (code.trim() === varName) {
+        return null;
+    }
+    return code;
+}
+function generateSplitInBatches(sib, ctx) {
+    const innerCtx = { ...ctx, indent: ctx.indent + 1 };
+    const sibVarName = (0, variable_names_1.getVarName)(sib.sibNode.name, ctx);
+    let code = `splitInBatches(${sibVarName})`;
+    if (sib.loopChain) {
+        let eachCode;
+        if (Array.isArray(sib.loopChain)) {
+            const transformedBranches = sib.loopChain.map((branch) => {
+                let branchCode = generateComposite(branch, innerCtx);
+                if (branchEndsWithVarRef(branch)) {
+                    const strippedCode = stripTrailingVarRefFromCode(branchCode, sibVarName);
+                    if (strippedCode === null) {
+                        branchCode = `nextBatch(${sibVarName})`;
+                    }
+                    else {
+                        branchCode = `${strippedCode}.to(nextBatch(${sibVarName}))`;
+                    }
+                }
+                return branchCode;
+            });
+            eachCode = `[${transformedBranches.join(', ')}]`;
+        }
+        else {
+            eachCode = generateBranchCode(sib.loopChain, innerCtx);
+            if (branchEndsWithVarRef(sib.loopChain)) {
+                const strippedCode = stripTrailingVarRefFromCode(eachCode, sibVarName);
+                if (strippedCode === null) {
+                    eachCode = `nextBatch(${sibVarName})`;
+                }
+                else {
+                    eachCode = `${strippedCode}.to(nextBatch(${sibVarName}))`;
+                }
+            }
+        }
+        code += `\n${getIndent(ctx)}.onEachBatch(${eachCode})`;
+    }
+    if (sib.doneChain) {
+        const doneCode = generateBranchCode(sib.doneChain, innerCtx);
+        code += `\n${getIndent(ctx)}.onDone(${doneCode})`;
+    }
+    return code;
+}
+function generateFanOut(fanOut, ctx) {
+    const innerCtx = { ...ctx, indent: ctx.indent + 1 };
+    const sourceCode = generateComposite(fanOut.sourceNode, ctx);
+    const targetsCode = fanOut.targets
+        .map((target) => generateComposite(target, innerCtx))
+        .join(',\n' + getIndent(innerCtx));
+    return `${sourceCode}\n${getIndent(ctx)}.to([\n${getIndent(innerCtx)}${targetsCode}])`;
+}
+function generateExplicitConnections(explicitConns, ctx) {
+    if (explicitConns.nodes.length > 0) {
+        const firstNode = explicitConns.nodes[0];
+        const varName = (0, variable_names_1.getVarName)(firstNode.name, ctx);
+        return varName;
+    }
+    return '';
+}
+function generateMultiOutput(multiOutput, ctx) {
+    const varName = (0, variable_names_1.getVarName)(multiOutput.sourceNode.name, ctx);
+    return varName;
+}
+function generateComposite(node, ctx) {
+    switch (node.kind) {
+        case 'leaf':
+            return generateLeaf(node, ctx);
+        case 'chain':
+            return generateChain(node, ctx);
+        case 'varRef':
+            return generateVarRef(node, ctx);
+        case 'ifElse':
+            return generateIfElse(node, ctx);
+        case 'switchCase':
+            return generateSwitchCase(node, ctx);
+        case 'merge':
+            return generateMerge(node, ctx);
+        case 'splitInBatches':
+            return generateSplitInBatches(node, ctx);
+        case 'fanOut':
+            return generateFanOut(node, ctx);
+        case 'explicitConnections':
+            return generateExplicitConnections(node, ctx);
+        case 'multiOutput':
+            return generateMultiOutput(node, ctx);
+    }
+}
+function generateNodeJSDoc(nodeName, ctx) {
+    const jsdocParts = [];
+    const status = ctx.nodeExecutionStatus?.get(nodeName);
+    if (status?.status === 'error') {
+        jsdocParts.push(`@nodeExecutionStatus error - ${status.errorMessage}`);
+    }
+    else if (status?.status === 'success') {
+        jsdocParts.push('@nodeExecutionStatus success');
+    }
+    if (jsdocParts.length === 0)
+        return null;
+    const lines = ['/**'];
+    for (const part of jsdocParts) {
+        for (const line of part.split('\n')) {
+            lines.push(` * ${line}`);
+        }
+    }
+    lines.push(' */');
+    return lines.join('\n');
+}
+function generateVariableDeclarations(variables, ctx) {
+    const declarations = [];
+    for (const [nodeName, node] of variables) {
+        const varName = (0, variable_names_1.getUniqueVarName)(nodeName, ctx);
+        const nodeCall = generateNodeCall(node, ctx);
+        const jsdoc = generateNodeJSDoc(nodeName, ctx);
+        if (jsdoc) {
+            declarations.push(`${jsdoc}\nconst ${varName} = ${nodeCall};`);
+        }
+        else {
+            declarations.push(`const ${varName} = ${nodeCall};`);
+        }
+        ctx.generatedVars.add(nodeName);
+    }
+    return declarations.join('\n\n');
+}
+function collectNestedMultiOutputs(node, collected) {
+    if (!node)
+        return;
+    if (node.kind === 'multiOutput') {
+        collected.push(node);
+        for (const [, target] of node.outputTargets) {
+            collectNestedMultiOutputs(target, collected);
+        }
+    }
+    else if (node.kind === 'chain') {
+        for (const n of node.nodes) {
+            collectNestedMultiOutputs(n, collected);
+        }
+    }
+    else if (node.kind === 'splitInBatches') {
+        const sib = node;
+        if (sib.doneChain) {
+            if (Array.isArray(sib.doneChain)) {
+                for (const b of sib.doneChain)
+                    collectNestedMultiOutputs(b, collected);
+            }
+            else {
+                collectNestedMultiOutputs(sib.doneChain, collected);
+            }
+        }
+        if (sib.loopChain) {
+            if (Array.isArray(sib.loopChain)) {
+                for (const b of sib.loopChain)
+                    collectNestedMultiOutputs(b, collected);
+            }
+            else {
+                collectNestedMultiOutputs(sib.loopChain, collected);
+            }
+        }
+    }
+    else if (node.kind === 'ifElse') {
+        const ifElse = node;
+        if (ifElse.trueBranch) {
+            if (Array.isArray(ifElse.trueBranch)) {
+                for (const b of ifElse.trueBranch)
+                    collectNestedMultiOutputs(b, collected);
+            }
+            else {
+                collectNestedMultiOutputs(ifElse.trueBranch, collected);
+            }
+        }
+        if (ifElse.falseBranch) {
+            if (Array.isArray(ifElse.falseBranch)) {
+                for (const b of ifElse.falseBranch)
+                    collectNestedMultiOutputs(b, collected);
+            }
+            else {
+                collectNestedMultiOutputs(ifElse.falseBranch, collected);
+            }
+        }
+    }
+    else if (node.kind === 'switchCase') {
+        const switchCase = node;
+        for (const c of switchCase.cases) {
+            if (c) {
+                if (Array.isArray(c)) {
+                    for (const b of c)
+                        collectNestedMultiOutputs(b, collected);
+                }
+                else {
+                    collectNestedMultiOutputs(c, collected);
+                }
+            }
+        }
+    }
+    else if (node.kind === 'fanOut') {
+        const fanOut = node;
+        collectNestedMultiOutputs(fanOut.sourceNode, collected);
+        for (const t of fanOut.targets) {
+            collectNestedMultiOutputs(t, collected);
+        }
+    }
+    else if (node.kind === 'merge') {
+        const merge = node;
+        for (const b of merge.branches) {
+            collectNestedMultiOutputs(b, collected);
+        }
+    }
+}
+function generateMultiOutputConnections(multiOutput, ctx) {
+    const calls = [];
+    const sourceVarName = (0, variable_names_1.getVarName)(multiOutput.sourceNode.name, ctx);
+    const sortedOutputs = [...multiOutput.outputTargets.entries()].sort((a, b) => a[0] - b[0]);
+    for (const [outputIndex, targetComposite] of sortedOutputs) {
+        const targetCode = generateComposite(targetComposite, ctx);
+        calls.push(['add', `${sourceVarName}.output(${outputIndex}).to(${targetCode})`]);
+    }
+    return calls;
+}
+function flattenToWorkflowCalls(root, ctx) {
+    const calls = [];
+    if (root.kind === 'multiOutput') {
+        const multiOutput = root;
+        const sourceVarName = (0, variable_names_1.getVarName)(multiOutput.sourceNode.name, ctx);
+        calls.push(['add', sourceVarName]);
+        const sortedOutputs = [...multiOutput.outputTargets.entries()].sort((a, b) => a[0] - b[0]);
+        for (const [outputIndex, targetComposite] of sortedOutputs) {
+            const targetCode = generateComposite(targetComposite, ctx);
+            calls.push(['add', `${sourceVarName}.output(${outputIndex}).to(${targetCode})`]);
+        }
+    }
+    else if (root.kind === 'explicitConnections') {
+        const explicitConns = root;
+        for (const node of explicitConns.nodes) {
+            const varName = (0, variable_names_1.getVarName)(node.name, ctx);
+            calls.push(['add', varName]);
+        }
+        for (const conn of explicitConns.connections) {
+            const sourceVar = (0, variable_names_1.getVarName)(conn.sourceNode, ctx);
+            const targetVar = (0, variable_names_1.getVarName)(conn.targetNode, ctx);
+            calls.push([
+                'connect',
+                `${sourceVar}, ${conn.sourceOutput}, ${targetVar}, ${conn.targetInput}`,
+            ]);
+        }
+    }
+    else if (root.kind === 'chain') {
+        const nestedMultiOutputsInChain = [];
+        for (let i = 0; i < root.nodes.length; i++) {
+            const node = root.nodes[i];
+            if (node.kind === 'multiOutput') {
+                const multiOutput = node;
+                const sourceVarName = (0, variable_names_1.getVarName)(multiOutput.sourceNode.name, ctx);
+                const method = i === 0 ? 'add' : 'to';
+                calls.push([method, sourceVarName]);
+                const sortedOutputs = [...multiOutput.outputTargets.entries()].sort((a, b) => a[0] - b[0]);
+                for (const [outputIndex, targetComposite] of sortedOutputs) {
+                    const targetCode = generateComposite(targetComposite, ctx);
+                    calls.push(['add', `${sourceVarName}.output(${outputIndex}).to(${targetCode})`]);
+                }
+            }
+            else {
+                const method = i === 0 ? 'add' : 'to';
+                const code = generateComposite(node, ctx);
+                calls.push([method, code]);
+                collectNestedMultiOutputs(node, nestedMultiOutputsInChain);
+            }
+        }
+        for (const multiOutput of nestedMultiOutputsInChain) {
+            const multiOutputCalls = generateMultiOutputConnections(multiOutput, ctx);
+            calls.push(...multiOutputCalls);
+        }
+    }
+    else {
+        calls.push(['add', generateComposite(root, ctx)]);
+        const nestedMultiOutputs = [];
+        collectNestedMultiOutputs(root, nestedMultiOutputs);
+        for (const multiOutput of nestedMultiOutputs) {
+            const multiOutputCalls = generateMultiOutputConnections(multiOutput, ctx);
+            calls.push(...multiOutputCalls);
+        }
+    }
+    return calls;
+}
+function generateCode(tree, json, graph, executionContext) {
+    const ctx = {
+        indent: 0,
+        generatedVars: new Set(),
+        variableNodes: tree.variables,
+        graph,
+        nodeNameToVarName: new Map(),
+        usedVarNames: new Set(),
+        subnodeVariables: new Map(),
+        nodeSchemas: executionContext?.nodeSchemas,
+        nodeExecutionStatus: executionContext?.nodeExecutionStatus,
+        expressionAnnotations: executionContext?.expressionAnnotations,
+        workflowStatusJSDoc: executionContext?.workflowStatusJSDoc,
+        valuesExcluded: executionContext?.valuesExcluded,
+        pinnedNodes: executionContext?.pinnedNodes,
+    };
+    for (const node of graph.nodes.values()) {
+        collectSubnodesAsVariables(node, ctx);
+    }
+    const lines = [];
+    const subnodeDeclarations = generateSubnodeVariableDeclarations(ctx);
+    if (subnodeDeclarations.length > 0) {
+        lines.push(...subnodeDeclarations);
+        lines.push('');
+    }
+    if (tree.variables.size > 0) {
+        lines.push(generateVariableDeclarations(tree.variables, ctx));
+        lines.push('');
+    }
+    const workflowId = (0, string_utils_1.escapeString)(json.id ?? '');
+    const workflowName = (0, string_utils_1.escapeString)(json.name ?? '');
+    const settingsStr = json.settings && Object.keys(json.settings).length > 0 ? `, ${(0, subnode_generator_1.formatValue)(json.settings)}` : '';
+    lines.push(`const wf = workflow('${workflowId}', '${workflowName}'${settingsStr});`);
+    ctx.indent = 1;
+    const workflowCalls = [];
+    for (const root of tree.roots) {
+        const calls = flattenToWorkflowCalls(root, ctx);
+        for (const [method, code] of calls) {
+            workflowCalls.push(`  .${method}(${code})`);
+        }
+    }
+    for (const conn of tree.deferredConnections) {
+        const sourceVarName = (0, variable_names_1.getVarName)(conn.sourceNodeName, ctx);
+        const targetVarName = (0, variable_names_1.getVarName)(conn.targetNode.name, ctx);
+        const sourceRef = conn.sourceOutputIndex > 0
+            ? `${sourceVarName}.output(${conn.sourceOutputIndex})`
+            : sourceVarName;
+        workflowCalls.push(`  .add(${sourceRef}.to(${targetVarName}.input(${conn.targetInputIndex})))`);
+    }
+    for (const downstream of tree.deferredMergeDownstreams) {
+        const mergeVarName = (0, variable_names_1.getVarName)(downstream.mergeNode.name, ctx);
+        if (downstream.downstreamChain) {
+            const chainCode = generateComposite(downstream.downstreamChain, ctx);
+            workflowCalls.push(`  .add(${mergeVarName})`);
+            workflowCalls.push(`  .to(${chainCode})`);
+        }
+    }
+    lines.push('');
+    if (ctx.workflowStatusJSDoc) {
+        const jsdocLines = ['/**'];
+        for (const line of ctx.workflowStatusJSDoc.split('\n')) {
+            jsdocLines.push(` * ${line}`);
+        }
+        jsdocLines.push(' */');
+        lines.push(jsdocLines.join('\n'));
+    }
+    if (workflowCalls.length > 0) {
+        lines.push('export default wf');
+        lines.push(...workflowCalls);
+    }
+    else {
+        lines.push('export default wf');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=code-generator.js.map