next-workflow-builder 0.1.0

package/dist/lib/workflow-codegen.js

@@ -0,0 +1,786 @@
+import { findActionById, flattenConfigFields } from "../plugins/registry.js";
+import { analyzeNodeUsage, buildAccessPath, getStepInfo, removeInvisibleChars, TEMPLATE_PATTERN, toFriendlyVarName, toTypeScriptLiteral, } from "./workflow-codegen-shared.js";
+const CONST_ASSIGNMENT_PATTERN = /^(\s*)(const\s+\w+\s*=\s*)(.*)$/;
+export function generateWorkflowCode(nodes, edges, options = {}) {
+    const { functionName = "executeWorkflow" } = options;
+    const usedNodeOutputs = analyzeNodeUsage(nodes);
+    const imports = new Set();
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const edgesBySource = new Map();
+    for (const edge of edges) {
+        const targets = edgesBySource.get(edge.source) || [];
+        targets.push(edge.target);
+        edgesBySource.set(edge.source, targets);
+    }
+    const nodesWithIncoming = new Set(edges.map((e) => e.target));
+    const triggerNodes = nodes.filter((node) => node.data.type === "trigger" && !nodesWithIncoming.has(node.id));
+    const inputIsUsed = triggerNodes.some((trigger) => usedNodeOutputs.has(trigger.id));
+    const codeLines = [];
+    const visited = new Set();
+    const functionSignature = inputIsUsed
+        ? `export async function ${functionName}<TInput>(input: TInput) {`
+        : `export async function ${functionName}() {`;
+    codeLines.push(functionSignature);
+    codeLines.push(`  "use workflow";`);
+    codeLines.push("");
+    const nodeIdToVarName = new Map();
+    const usedVarNames = new Set();
+    for (const node of nodes) {
+        let varName;
+        if (node.data.type === "action") {
+            const actionType = node.data.config?.actionType;
+            const label = node.data.label || "";
+            const baseVarName = toFriendlyVarName(label, actionType);
+            varName = baseVarName;
+            let counter = 1;
+            while (usedVarNames.has(varName)) {
+                varName = `${baseVarName}${counter}`;
+                counter += 1;
+            }
+            usedVarNames.add(varName);
+        }
+        else {
+            varName = "input";
+        }
+        nodeIdToVarName.set(node.id, varName);
+    }
+    function processAtFormat(trimmed, match) {
+        const withoutAt = trimmed.substring(1);
+        const colonIndex = withoutAt.indexOf(":");
+        if (colonIndex === -1) {
+            return match;
+        }
+        const nodeId = withoutAt.substring(0, colonIndex);
+        const rest = withoutAt.substring(colonIndex + 1);
+        const dotIndex = rest.indexOf(".");
+        const fieldPath = dotIndex !== -1 ? rest.substring(dotIndex + 1) : "";
+        const varName = nodeIdToVarName.get(nodeId);
+        if (!varName) {
+            return match;
+        }
+        if (!fieldPath) {
+            return `\${${varName}}`;
+        }
+        const accessPath = buildAccessPath(fieldPath);
+        return `\${${varName}${accessPath}}`;
+    }
+    function processDollarFormat(trimmed, match) {
+        const withoutDollar = trimmed.substring(1);
+        const parts = withoutDollar.split(".");
+        const nodeId = parts[0];
+        const fieldPath = parts.slice(1).join(".");
+        const varName = nodeIdToVarName.get(nodeId);
+        if (!varName) {
+            return match;
+        }
+        if (!fieldPath) {
+            return `\${${varName}}`;
+        }
+        const accessPath = buildAccessPath(fieldPath);
+        return `\${${varName}${accessPath}}`;
+    }
+    function processAtFormatForExpression(trimmed, match) {
+        const withoutAt = trimmed.substring(1);
+        const colonIndex = withoutAt.indexOf(":");
+        if (colonIndex === -1) {
+            return match;
+        }
+        const nodeId = withoutAt.substring(0, colonIndex);
+        const rest = withoutAt.substring(colonIndex + 1);
+        const dotIndex = rest.indexOf(".");
+        const fieldPath = dotIndex !== -1 ? rest.substring(dotIndex + 1) : "";
+        const varName = nodeIdToVarName.get(nodeId);
+        if (!varName) {
+            return match;
+        }
+        if (!fieldPath) {
+            return varName;
+        }
+        const accessPath = buildAccessPath(fieldPath);
+        return `${varName}${accessPath}`;
+    }
+    function processDollarFormatForExpression(trimmed, match) {
+        const withoutDollar = trimmed.substring(1);
+        const parts = withoutDollar.split(".");
+        const nodeId = parts[0];
+        const fieldPath = parts.slice(1).join(".");
+        const varName = nodeIdToVarName.get(nodeId);
+        if (!varName) {
+            return match;
+        }
+        if (!fieldPath) {
+            return varName;
+        }
+        const accessPath = buildAccessPath(fieldPath);
+        return `${varName}${accessPath}`;
+    }
+    function convertTemplateToJS(template) {
+        if (!template || typeof template !== "string") {
+            return template;
+        }
+        return template.replace(TEMPLATE_PATTERN, (match, expression) => {
+            const trimmed = expression.trim();
+            if (trimmed.startsWith("@")) {
+                return processAtFormat(trimmed, match);
+            }
+            if (trimmed.startsWith("$")) {
+                return processDollarFormat(trimmed, match);
+            }
+            return match;
+        });
+    }
+    function convertConditionToJS(condition) {
+        if (!condition || typeof condition !== "string") {
+            return condition;
+        }
+        const cleaned = removeInvisibleChars(condition);
+        const converted = cleaned.replace(TEMPLATE_PATTERN, (match, expression) => {
+            const trimmed = expression.trim();
+            if (trimmed.startsWith("@")) {
+                return processAtFormatForExpression(trimmed, match);
+            }
+            if (trimmed.startsWith("$")) {
+                return processDollarFormatForExpression(trimmed, match);
+            }
+            return match;
+        });
+        return removeInvisibleChars(converted);
+    }
+    function generateEmailActionCode(node, indent, varName) {
+        const stepInfo = getStepInfo("Send Email");
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const emailTo = config.emailTo || "user@example.com";
+        const emailSubject = config.emailSubject || "Notification";
+        const emailBody = config.emailBody || "No content";
+        const convertedEmailTo = convertTemplateToJS(emailTo);
+        const convertedSubject = convertTemplateToJS(emailSubject);
+        const convertedBody = convertTemplateToJS(emailBody);
+        const hasTemplateRefs = (str) => str.includes("${");
+        const escapeForOuterTemplate = (str) => str.replace(/\$\{/g, "$${");
+        const emailToValue = hasTemplateRefs(convertedEmailTo)
+            ? `\`${escapeForOuterTemplate(convertedEmailTo).replace(/`/g, "\\`")}\``
+            : `'${emailTo.replace(/'/g, "\\'")}'`;
+        const subjectValue = hasTemplateRefs(convertedSubject)
+            ? `\`${escapeForOuterTemplate(convertedSubject).replace(/`/g, "\\`")}\``
+            : `'${emailSubject.replace(/'/g, "\\'")}'`;
+        const bodyValue = hasTemplateRefs(convertedBody)
+            ? `\`${escapeForOuterTemplate(convertedBody).replace(/`/g, "\\`")}\``
+            : `'${emailBody.replace(/'/g, "\\'")}'`;
+        return [
+            `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+            `${indent}  emailTo: ${emailToValue},`,
+            `${indent}  emailSubject: ${subjectValue},`,
+            `${indent}  emailBody: ${bodyValue},`,
+            `${indent}});`,
+        ];
+    }
+    function generateTicketActionCode(node, indent, varName) {
+        const stepInfo = getStepInfo("Create Ticket");
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const ticketTitle = config.ticketTitle || "New Ticket";
+        const ticketDescription = config.ticketDescription || "";
+        const convertedTitle = convertTemplateToJS(ticketTitle);
+        const convertedDescription = convertTemplateToJS(ticketDescription);
+        const hasTemplateRefs = (str) => str.includes("${");
+        const escapeForOuterTemplate = (str) => str.replace(/\$\{/g, "$${");
+        const titleValue = hasTemplateRefs(convertedTitle)
+            ? `\`${escapeForOuterTemplate(convertedTitle).replace(/`/g, "\\`")}\``
+            : `'${ticketTitle.replace(/'/g, "\\'")}'`;
+        const descValue = hasTemplateRefs(convertedDescription)
+            ? `\`${escapeForOuterTemplate(convertedDescription).replace(/`/g, "\\`")}\``
+            : `'${ticketDescription.replace(/'/g, "\\'")}'`;
+        return [
+            `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+            `${indent}  ticketTitle: ${titleValue},`,
+            `${indent}  ticketDescription: ${descValue},`,
+            `${indent}});`,
+        ];
+    }
+    function generateDatabaseActionCode(node, indent, varName) {
+        const stepInfo = getStepInfo("Database Query");
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const dbQuery = config.dbQuery || "";
+        const dataSource = config.dataSource || "";
+        const tableName = config.dbTable ||
+            config.tableName ||
+            "your_table";
+        const lines = [
+            `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+        ];
+        if (dataSource) {
+            lines.push(`${indent}  dataSource: { name: "${dataSource}" },`);
+        }
+        else {
+            lines.push(`${indent}  dataSource: {},`);
+        }
+        if (dbQuery) {
+            const convertedQuery = convertTemplateToJS(dbQuery);
+            const hasTemplateRefs = convertedQuery.includes("${");
+            const escapeForOuterTemplate = (str) => str.replace(/\$\{/g, "$${");
+            const queryValue = hasTemplateRefs
+                ? `\`${escapeForOuterTemplate(convertedQuery).replace(/`/g, "\\`")}\``
+                : `\`${dbQuery.replace(/`/g, "\\`")}\``;
+            lines.push(`${indent}  query: ${queryValue},`);
+        }
+        else {
+            lines.push(`${indent}  query: "${tableName}",`);
+        }
+        lines.push(`${indent}});`);
+        return lines;
+    }
+    function generateHTTPActionCode(node, indent, varName) {
+        const stepInfo = getStepInfo("HTTP Request");
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const endpoint = config.endpoint || "https://api.example.com/endpoint";
+        const method = config.httpMethod || "POST";
+        return [
+            `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+            `${indent}  url: '${endpoint}',`,
+            `${indent}  method: '${method}',`,
+            `${indent}  body: {},`,
+            `${indent}});`,
+        ];
+    }
+    function processAiSchema(aiSchema) {
+        if (!aiSchema) {
+            return null;
+        }
+        try {
+            const parsedSchema = JSON.parse(aiSchema);
+            const schemaWithoutIds = Array.isArray(parsedSchema)
+                ? parsedSchema.map((field) => {
+                    const { id: _id, ...rest } = field;
+                    return rest;
+                })
+                : parsedSchema;
+            return toTypeScriptLiteral(schemaWithoutIds);
+        }
+        catch {
+            return null;
+        }
+    }
+    function generatePromptValue(aiPrompt) {
+        const convertedPrompt = convertTemplateToJS(aiPrompt);
+        const hasTemplateRefs = convertedPrompt.includes("${");
+        const escapeForOuterTemplate = (str) => str.replace(/\$\{/g, "$${");
+        if (hasTemplateRefs) {
+            return `\`${escapeForOuterTemplate(convertedPrompt).replace(/`/g, "\\`")}\``;
+        }
+        return `\`${aiPrompt.replace(/`/g, "\\`")}\``;
+    }
+    function generateAiTextActionCode(node, indent, varName) {
+        const stepInfo = getStepInfo("Generate Text");
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const aiPrompt = config.aiPrompt || "Generate a summary";
+        const aiModel = config.aiModel || "meta/llama-4-scout";
+        const aiFormat = config.aiFormat || "text";
+        const aiSchema = config.aiSchema;
+        const promptValue = generatePromptValue(aiPrompt);
+        const lines = [
+            `${indent}// Generate text using AI`,
+            `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+            `${indent}  model: "${aiModel}",`,
+            `${indent}  prompt: ${promptValue},`,
+        ];
+        if (aiFormat === "object") {
+            lines.push(`${indent}  format: "object",`);
+            const schemaString = processAiSchema(aiSchema);
+            if (schemaString) {
+                lines.push(`${indent}  schema: ${schemaString},`);
+            }
+        }
+        lines.push(`${indent}});`);
+        return lines;
+    }
+    function generateAiImageActionCode(node, indent, varName) {
+        imports.add("import { experimental_generateImage as generateImage } from 'ai';");
+        const imagePrompt = node.data.config?.imagePrompt || "A beautiful landscape";
+        const imageModel = node.data.config?.imageModel || "google/imagen-4.0-generate";
+        return [
+            `${indent}// Generate image using AI`,
+            `${indent}const ${varName} = await generateImage({`,
+            `${indent}  model: "${imageModel}",`,
+            `${indent}  prompt: \`${imagePrompt}\`,`,
+            `${indent}  size: "1024x1024",`,
+            `${indent}});`,
+        ];
+    }
+    function formatTemplateValue(value) {
+        const converted = convertTemplateToJS(value);
+        const hasTemplateRefs = converted.includes("${");
+        const escaped = converted.replace(/\$\{/g, "$${").replace(/`/g, "\\`");
+        return hasTemplateRefs
+            ? `\`${escaped}\``
+            : `\`${value.replace(/`/g, "\\`")}\``;
+    }
+    function generateFirecrawlActionCode(node, indent, varName) {
+        const actionType = node.data.config?.actionType;
+        const stepInfo = getStepInfo(actionType);
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const url = config.url || "";
+        const query = config.query || "";
+        const limit = config.limit ? Number(config.limit) : undefined;
+        const lines = [
+            `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+        ];
+        if (url) {
+            lines.push(`${indent}  url: ${formatTemplateValue(url)},`);
+        }
+        if (query) {
+            lines.push(`${indent}  query: ${formatTemplateValue(query)},`);
+        }
+        if (limit) {
+            lines.push(`${indent}  limit: ${limit},`);
+        }
+        lines.push(`${indent}});`);
+        return lines;
+    }
+    function generateV0CreateChatActionCode(node, indent, varName) {
+        const stepInfo = getStepInfo("Create Chat");
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const message = config.message || "";
+        const system = config.system || "";
+        const lines = [
+            `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+            `${indent}  message: ${formatTemplateValue(message)},`,
+        ];
+        if (system) {
+            lines.push(`${indent}  system: ${formatTemplateValue(system)},`);
+        }
+        lines.push(`${indent}});`);
+        return lines;
+    }
+    function generateV0SendMessageActionCode(node, indent, varName) {
+        const stepInfo = getStepInfo("Send Message");
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const chatId = config.chatId || "";
+        const message = config.message || "";
+        const lines = [
+            `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+            `${indent}  chatId: ${formatTemplateValue(chatId)},`,
+            `${indent}  message: ${formatTemplateValue(message)},`,
+            `${indent}});`,
+        ];
+        return lines;
+    }
+    function formatFieldValue(fieldType, value, indent, key) {
+        const fieldTypeFormatters = {
+            "template-input": () => `${indent}  ${key}: ${formatTemplateValue(String(value))},`,
+            "template-textarea": () => `${indent}  ${key}: ${formatTemplateValue(String(value))},`,
+            number: () => `${indent}  ${key}: ${value},`,
+            select: () => `${indent}  ${key}: "${value}",`,
+            "schema-builder": () => `${indent}  ${key}: ${JSON.stringify(value)},`,
+        };
+        const formatter = fieldTypeFormatters[fieldType];
+        return formatter ? formatter() : `${indent}  ${key}: "${value}",`;
+    }
+    function generatePluginActionCode(node, actionType, indent, varName) {
+        const action = findActionById(actionType);
+        if (!action) {
+            return null;
+        }
+        const stepInfo = getStepInfo(actionType);
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const config = node.data.config || {};
+        const configFields = flattenConfigFields(action.configFields);
+        const paramLines = [];
+        for (const field of configFields) {
+            const value = config[field.key];
+            if (value === undefined || value === null || value === "") {
+                continue;
+            }
+            paramLines.push(formatFieldValue(field.type, value, indent, field.key));
+        }
+        const lines = [];
+        if (paramLines.length > 0) {
+            lines.push(`${indent}const ${varName} = await ${stepInfo.functionName}({`);
+            lines.push(...paramLines);
+            lines.push(`${indent}});`);
+        }
+        else {
+            lines.push(`${indent}const ${varName} = await ${stepInfo.functionName}({});`);
+        }
+        return lines;
+    }
+    function generateActionNodeCode(node, nodeId, indent, varName) {
+        const actionType = node.data.config?.actionType;
+        const actionLabel = node.data.label || actionType || "Unknown Action";
+        const lines = [`${indent}// Action: ${actionLabel}`];
+        if (node.data.description) {
+            lines.push(`${indent}// ${node.data.description}`);
+        }
+        const outputIsUsed = usedNodeOutputs.has(nodeId);
+        function processAwaitLine(line) {
+            const match = CONST_ASSIGNMENT_PATTERN.exec(line);
+            if (match) {
+                const [, lineIndent, , rest] = match;
+                return `${lineIndent}${rest}`;
+            }
+            return line;
+        }
+        function processConstLine(line) {
+            const match = CONST_ASSIGNMENT_PATTERN.exec(line);
+            if (match) {
+                const [, lineIndent, , rest] = match;
+                return `${lineIndent}void ${rest}`;
+            }
+            return line;
+        }
+        function removeVariableAssignment(actionLines) {
+            const result = [];
+            for (const line of actionLines) {
+                if (line.includes("await")) {
+                    result.push(processAwaitLine(line));
+                }
+                else if (line.trim().startsWith("const") && line.includes("{")) {
+                    result.push(processConstLine(line));
+                }
+                else {
+                    result.push(line);
+                }
+            }
+            return result;
+        }
+        const wrapActionCall = (actionLines) => {
+            if (outputIsUsed) {
+                return actionLines;
+            }
+            return removeVariableAssignment(actionLines);
+        };
+        if (actionType === "Generate Text") {
+            lines.push(...wrapActionCall(generateAiTextActionCode(node, indent, varName)));
+        }
+        else if (actionType === "Generate Image") {
+            lines.push(...wrapActionCall(generateAiImageActionCode(node, indent, varName)));
+        }
+        else if (actionType === "Send Email") {
+            lines.push(...wrapActionCall(generateEmailActionCode(node, indent, varName)));
+        }
+        else if (actionType === "Create Ticket") {
+            lines.push(...wrapActionCall(generateTicketActionCode(node, indent, varName)));
+        }
+        else if (actionType === "Scrape" || actionType === "Search") {
+            lines.push(...wrapActionCall(generateFirecrawlActionCode(node, indent, varName)));
+        }
+        else if (actionType === "Create Chat") {
+            lines.push(...wrapActionCall(generateV0CreateChatActionCode(node, indent, varName)));
+        }
+        else if (actionType === "Send Message") {
+            lines.push(...wrapActionCall(generateV0SendMessageActionCode(node, indent, varName)));
+        }
+        else if (actionType === "Database Query") {
+            lines.push(...wrapActionCall(generateDatabaseActionCode(node, indent, varName)));
+        }
+        else if (actionType === "HTTP Request") {
+            lines.push(...wrapActionCall(generateHTTPActionCode(node, indent, varName)));
+        }
+        else {
+            const pluginCode = generatePluginActionCode(node, actionType, indent, varName);
+            if (pluginCode) {
+                lines.push(...wrapActionCall(pluginCode));
+            }
+            else if (outputIsUsed) {
+                lines.push(`${indent}// TODO: Implement action type "${actionType}"`);
+                lines.push(`${indent}const ${varName} = { status: 'pending', actionType: "${actionType}" };`);
+            }
+            else {
+                lines.push(`${indent}// TODO: Implement action type "${actionType}"`);
+                lines.push(`${indent}void ({ status: 'pending', actionType: "${actionType}" });`);
+            }
+        }
+        return lines;
+    }
+    function generateConditionNodeCode(node, nodeId, indent) {
+        const lines = [`${indent}// Condition: ${node.data.label}`];
+        if (node.data.description) {
+            lines.push(`${indent}// ${node.data.description}`);
+        }
+        const condition = node.data.config?.condition;
+        const nextNodes = edgesBySource.get(nodeId) || [];
+        if (nextNodes.length > 0) {
+            const trueNode = nextNodes[0];
+            const falseNode = nextNodes[1];
+            const convertedCondition = condition
+                ? convertConditionToJS(condition)
+                : "true";
+            lines.push(`${indent}if (${convertedCondition}) {`);
+            if (trueNode) {
+                const trueNodeCode = generateNodeCode(trueNode, `${indent}  `);
+                lines.push(...trueNodeCode);
+            }
+            if (falseNode) {
+                lines.push(`${indent}} else {`);
+                const falseNodeCode = generateNodeCode(falseNode, `${indent}  `);
+                lines.push(...falseNodeCode);
+            }
+            lines.push(`${indent}}`);
+        }
+        return lines;
+    }
+    function processTriggerNode(nodeId, indent) {
+        const nextNodes = edgesBySource.get(nodeId) || [];
+        const lines = generateParallelNodeCode(nextNodes, indent);
+        return { lines, wasSkipped: true };
+    }
+    function processActionNode(node, nodeId, varName, indent) {
+        const lines = [];
+        const actionType = node.data.config?.actionType;
+        if (actionType === "Condition") {
+            lines.push(...generateConditionNodeCode(node, nodeId, indent));
+            return lines;
+        }
+        lines.push(...generateActionNodeCode(node, nodeId, indent, varName));
+        return lines;
+    }
+    function generateBranchCode(nodeId, indent, branchVisited) {
+        if (branchVisited.has(nodeId)) {
+            return [];
+        }
+        branchVisited.add(nodeId);
+        const node = nodeMap.get(nodeId);
+        if (!node) {
+            return [];
+        }
+        const lines = [];
+        if (node.data.type === "action") {
+            const actionType = node.data.config?.actionType;
+            if (actionType === "Condition") {
+                lines.push(...generateConditionBranchCode(node, nodeId, indent, branchVisited));
+            }
+            else {
+                lines.push(...generateActionCallCode(node, indent));
+                const children = edgesBySource.get(nodeId) || [];
+                if (children.length > 0) {
+                    lines.push("");
+                    lines.push(...generateChildrenCode(children, indent, branchVisited));
+                }
+            }
+        }
+        return lines;
+    }
+    function generateConditionBranchCode(node, nodeId, indent, branchVisited) {
+        const lines = [`${indent}// Condition: ${node.data.label}`];
+        const condition = node.data.config?.condition;
+        const nextNodes = edgesBySource.get(nodeId) || [];
+        if (nextNodes.length > 0) {
+            const convertedCondition = condition
+                ? convertConditionToJS(condition)
+                : "true";
+            lines.push(`${indent}if (${convertedCondition}) {`);
+            if (nextNodes[0]) {
+                lines.push(...generateBranchCode(nextNodes[0], `${indent}  `, branchVisited));
+            }
+            if (nextNodes[1]) {
+                lines.push(`${indent}} else {`);
+                lines.push(...generateBranchCode(nextNodes[1], `${indent}  `, branchVisited));
+            }
+            lines.push(`${indent}}`);
+        }
+        return lines;
+    }
+    function generateActionCallCode(node, indent) {
+        const actionType = node.data.config?.actionType;
+        const actionLabel = node.data.label || actionType || "Unknown Action";
+        const stepInfo = getStepInfo(actionType);
+        const configParams = buildActionConfigParams(node, `${indent}  `);
+        imports.add(`import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`);
+        const lines = [`${indent}// ${actionLabel}`];
+        if (configParams.length > 0) {
+            lines.push(`${indent}await ${stepInfo.functionName}({`);
+            lines.push(...configParams);
+            lines.push(`${indent}});`);
+        }
+        else {
+            lines.push(`${indent}await ${stepInfo.functionName}({});`);
+        }
+        return lines;
+    }
+    function generateChildrenCode(childIds, indent, branchVisited) {
+        const unvisited = childIds.filter((id) => !branchVisited.has(id));
+        if (unvisited.length === 0) {
+            return [];
+        }
+        if (unvisited.length === 1) {
+            return generateBranchCode(unvisited[0], indent, branchVisited);
+        }
+        const lines = [`${indent}await Promise.all([`];
+        for (let i = 0; i < unvisited.length; i++) {
+            const childId = unvisited[i];
+            const isLast = i === unvisited.length - 1;
+            const comma = isLast ? "" : ",";
+            const childBranchVisited = new Set(branchVisited);
+            const branchCode = generateBranchCode(childId, `${indent}    `, childBranchVisited);
+            if (branchCode.length > 0) {
+                lines.push(`${indent}  (async () => {`);
+                lines.push(...branchCode);
+                lines.push(`${indent}  })()${comma}`);
+            }
+        }
+        lines.push(`${indent}]);`);
+        return lines;
+    }
+    function generateAsyncIIFEBranch(nodeId, indent, isLast) {
+        const branchVisited = new Set(visited);
+        branchVisited.delete(nodeId);
+        const branchCode = generateBranchCode(nodeId, `${indent}    `, branchVisited);
+        const comma = isLast ? "" : ",";
+        if (branchCode.length === 0) {
+            return [];
+        }
+        return [
+            `${indent}  (async () => {`,
+            ...branchCode,
+            `${indent}  })()${comma}`,
+        ];
+    }
+    function generateParallelNodeCode(nodeIds, indent) {
+        if (nodeIds.length === 0) {
+            return [];
+        }
+        const unvisited = nodeIds.filter((id) => !visited.has(id) && nodeMap.get(id)?.data.type === "action");
+        if (unvisited.length === 0) {
+            return [];
+        }
+        if (unvisited.length === 1) {
+            const branchVisited = new Set(visited);
+            visited.add(unvisited[0]);
+            return generateBranchCode(unvisited[0], indent, branchVisited);
+        }
+        for (const id of unvisited) {
+            visited.add(id);
+        }
+        const lines = [`${indent}await Promise.all([`];
+        for (let i = 0; i < unvisited.length; i++) {
+            lines.push(...generateAsyncIIFEBranch(unvisited[i], indent, i === unvisited.length - 1));
+        }
+        lines.push(`${indent}]);`);
+        return lines;
+    }
+    function buildPluginConfigParams(config, actionType, indent) {
+        const action = findActionById(actionType);
+        if (!action) {
+            return [];
+        }
+        const params = [];
+        for (const field of flattenConfigFields(action.configFields)) {
+            const value = config[field.key];
+            if (value === undefined || value === null || value === "") {
+                continue;
+            }
+            params.push(formatFieldValue(field.type, value, indent, field.key));
+        }
+        return params;
+    }
+    const EXCLUDED_CONFIG_KEYS = new Set(["actionType", "integrationId"]);
+    function buildFallbackConfigParams(config, indent) {
+        const params = [];
+        for (const [key, value] of Object.entries(config)) {
+            if (EXCLUDED_CONFIG_KEYS.has(key) ||
+                value === undefined ||
+                value === null) {
+                continue;
+            }
+            if (typeof value === "string") {
+                params.push(`${indent}${key}: ${formatTemplateValue(value)},`);
+            }
+            else if (typeof value === "number" || typeof value === "boolean") {
+                params.push(`${indent}${key}: ${value},`);
+            }
+            else {
+                params.push(`${indent}${key}: ${JSON.stringify(value)},`);
+            }
+        }
+        return params;
+    }
+    function buildActionConfigParams(node, indent) {
+        const actionType = node.data.config?.actionType;
+        const config = node.data.config || {};
+        const pluginParams = buildPluginConfigParams(config, actionType, indent);
+        if (pluginParams.length > 0) {
+            return pluginParams;
+        }
+        return buildFallbackConfigParams(config, indent);
+    }
+    function processNextNodes(nodeId, currentLines, indent) {
+        const nextNodes = edgesBySource.get(nodeId) || [];
+        const result = [...currentLines];
+        if (currentLines.length > 0 && nextNodes.length > 0) {
+            result.push("");
+        }
+        result.push(...generateParallelNodeCode(nextNodes, indent));
+        return result;
+    }
+    function generateNodeCode(nodeId, indent = "  ") {
+        if (visited.has(nodeId)) {
+            return [`${indent}// Already processed: ${nodeId}`];
+        }
+        visited.add(nodeId);
+        const node = nodeMap.get(nodeId);
+        if (!node) {
+            return [];
+        }
+        const varName = nodeIdToVarName.get(nodeId) ||
+            `${node.data.type}_${nodeId.replace(/-/g, "_")}`;
+        let lines = [];
+        switch (node.data.type) {
+            case "trigger": {
+                const { lines: triggerLines, wasSkipped } = processTriggerNode(nodeId, indent);
+                if (wasSkipped) {
+                    return triggerLines;
+                }
+                return processNextNodes(nodeId, triggerLines, indent);
+            }
+            case "action": {
+                const actionLines = processActionNode(node, nodeId, varName, indent);
+                const actionType = node.data.config?.actionType;
+                if (actionType === "Condition") {
+                    return actionLines;
+                }
+                lines = actionLines;
+                break;
+            }
+            default:
+                lines.push(`${indent}// Unknown node type: ${node.data.type}`);
+                break;
+        }
+        return processNextNodes(nodeId, lines, indent);
+    }
+    if (triggerNodes.length === 0) {
+        codeLines.push("  // No trigger nodes found");
+    }
+    else {
+        for (const trigger of triggerNodes) {
+            const triggerCode = generateNodeCode(trigger.id, "  ");
+            codeLines.push(...triggerCode);
+        }
+    }
+    codeLines.push("}");
+    const importStatements = Array.from(imports).join("\n");
+    const code = `${importStatements}\n\n${codeLines.join("\n")}\n`;
+    return {
+        code,
+        functionName,
+        imports: Array.from(imports),
+    };
+}
+export function generateWorkflowModule(workflowName, nodes, edges, options = {}) {
+    const { code } = generateWorkflowCode(nodes, edges, options);
+    return `/**
+ * Generated Workflow: ${workflowName}
+ * 
+ * This file was automatically generated from a workflow definition.
+ * DO NOT EDIT MANUALLY - regenerate from the workflow editor instead.
+ */
+
+${code}
+`;
+}
+//# sourceMappingURL=workflow-codegen.js.map