next-workflow-builder 0.3.0

package/dist/chunk-XJ67EFQA.js

@@ -0,0 +1,1162 @@
+import {
+  findActionById,
+  flattenConfigFields
+} from "./chunk-Z3BJJYHM.js";
+
+// src/client/lib/workflow-codegen-shared.ts
+var TEMPLATE_PATTERN = /\{\{([^}]+)\}\}/g;
+var WHITESPACE_PATTERN = /\s+/;
+var NON_ALPHANUMERIC_PATTERN = /[^a-zA-Z0-9]/g;
+var ARRAY_INDEX_PATTERN = /^([^[]+)\[(\d+)\]$/;
+var VALID_IDENTIFIER_PATTERN = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var NUMBER_START_PATTERN = /^[0-9]/;
+function findNodeReferences(template) {
+  const refs = /* @__PURE__ */ new Set();
+  if (!template || typeof template !== "string") {
+    return refs;
+  }
+  let match;
+  while ((match = TEMPLATE_PATTERN.exec(template)) !== null) {
+    const expression = match[1].trim();
+    if (expression.startsWith("@")) {
+      const withoutAt = expression.substring(1);
+      const colonIndex = withoutAt.indexOf(":");
+      if (colonIndex !== -1) {
+        const nodeId = withoutAt.substring(0, colonIndex);
+        refs.add(nodeId);
+      }
+    } else if (expression.startsWith("$")) {
+      const withoutDollar = expression.substring(1);
+      const parts = withoutDollar.split(".");
+      if (parts.length > 0) {
+        refs.add(parts[0]);
+      }
+    }
+  }
+  return refs;
+}
+function extractRefsFromConfigValue(value) {
+  const refs = /* @__PURE__ */ new Set();
+  if (typeof value === "string") {
+    const foundRefs = findNodeReferences(value);
+    for (const ref of foundRefs) {
+      refs.add(ref);
+    }
+  }
+  return refs;
+}
+function analyzeNodeUsage(nodes) {
+  const usedNodes = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (node.data.type !== "action") {
+      continue;
+    }
+    const config = node.data.config || {};
+    for (const value of Object.values(config)) {
+      const refs = extractRefsFromConfigValue(value);
+      for (const ref of refs) {
+        usedNodes.add(ref);
+      }
+    }
+  }
+  return usedNodes;
+}
+function buildEdgeMap(edges) {
+  const edgesBySource = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const targets = edgesBySource.get(edge.source) || [];
+    targets.push(edge.target);
+    edgesBySource.set(edge.source, targets);
+  }
+  return edgesBySource;
+}
+function findTriggerNodes(nodes, edges) {
+  const nodesWithIncoming = new Set(edges.map((e) => e.target));
+  return nodes.filter(
+    (node) => node.data.type === "trigger" && !nodesWithIncoming.has(node.id)
+  );
+}
+function buildAccessPath(fieldPath) {
+  return fieldPath.split(".").map((part) => {
+    const arrayMatch = ARRAY_INDEX_PATTERN.exec(part);
+    if (arrayMatch) {
+      return `.${arrayMatch[1]}[${arrayMatch[2]}]`;
+    }
+    return `.${part}`;
+  }).join("");
+}
+function toFriendlyVarName(label, actionType) {
+  const baseName = label || actionType || "result";
+  const camelCase = baseName.split(WHITESPACE_PATTERN).map((word, index) => {
+    const cleaned = word.replace(NON_ALPHANUMERIC_PATTERN, "");
+    if (!cleaned) {
+      return "";
+    }
+    if (index === 0) {
+      return cleaned.toLowerCase();
+    }
+    return cleaned.charAt(0).toUpperCase() + cleaned.slice(1).toLowerCase();
+  }).filter((word) => word.length > 0).join("");
+  return `${camelCase}Result`;
+}
+function removeInvisibleChars(str) {
+  return str.replace(/\u00a0/g, " ").replace(/[\u2000-\u200B\u2028\u2029]/g, " ");
+}
+function escapeForTemplateLiteral(str) {
+  if (!str) {
+    return "";
+  }
+  return str.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+}
+function sanitizeFunctionName(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "_").replace(NUMBER_START_PATTERN, "_$&").replace(/_+/g, "_");
+}
+function sanitizeStepName(name) {
+  const result = name.split(WHITESPACE_PATTERN).filter((word) => word.length > 0).map((word, index) => {
+    const cleaned = word.replace(/[^a-zA-Z0-9]/g, "");
+    if (!cleaned) {
+      return "";
+    }
+    if (index === 0) {
+      return cleaned.toLowerCase();
+    }
+    return cleaned.charAt(0).toUpperCase() + cleaned.slice(1).toLowerCase();
+  }).filter((word) => word.length > 0).join("");
+  if (!result || result.length === 0) {
+    return "unnamedStep";
+  }
+  const sanitized = result.replace(NUMBER_START_PATTERN, "_$&");
+  return `${sanitized}Step`;
+}
+function sanitizeVarName(id) {
+  return id.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function toTypeScriptLiteral(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => toTypeScriptLiteral(item));
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([key, val]) => {
+      const keyStr = VALID_IDENTIFIER_PATTERN.test(key) ? key : JSON.stringify(key);
+      return `${keyStr}: ${toTypeScriptLiteral(val)}`;
+    });
+    return `{${entries.join(", ")}}`;
+  }
+  return String(value);
+}
+var SYSTEM_STEP_INFO = {
+  "Database Query": {
+    functionName: "databaseQueryStep",
+    importPath: "./steps/database-query-step"
+  },
+  "HTTP Request": {
+    functionName: "httpRequestStep",
+    importPath: "./steps/http-request-step"
+  },
+  Condition: {
+    functionName: "conditionStep",
+    importPath: "./steps/condition-step"
+  }
+};
+function getStepInfo(actionType) {
+  const systemInfo = SYSTEM_STEP_INFO[actionType];
+  if (systemInfo) {
+    return systemInfo;
+  }
+  const action = findActionById(actionType);
+  if (action) {
+    return {
+      functionName: action.stepFunction,
+      // Convert plugin's stepImportPath to generated code import path
+      // Plugin uses "send-email", generated code uses "./steps/send-email-step"
+      importPath: `./steps/${action.stepImportPath}-step`
+    };
+  }
+  return {
+    functionName: "unknownStep",
+    importPath: "./steps/unknown-step"
+  };
+}
+
+// src/client/lib/workflow-codegen.ts
+var CONST_ASSIGNMENT_PATTERN = /^(\s*)(const\s+\w+\s*=\s*)(.*)$/;
+function generateWorkflowCode(nodes, edges, options = {}) {
+  const { functionName = "executeWorkflow" } = options;
+  const usedNodeOutputs = analyzeNodeUsage(nodes);
+  const imports = /* @__PURE__ */ new Set();
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  const edgesBySource = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+  const usedVarNames = /* @__PURE__ */ 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 generateSlackActionCode(node, indent, varName) {
+    const stepInfo = getStepInfo("Send Slack Message");
+    imports.add(
+      `import { ${stepInfo.functionName} } from '${stepInfo.importPath}';`
+    );
+    const config = node.data.config || {};
+    const slackChannel = config.slackChannel || "#general";
+    const slackMessage = config.slackMessage || "Message content";
+    const convertedChannel = convertTemplateToJS(slackChannel);
+    const convertedMessage = convertTemplateToJS(slackMessage);
+    const hasTemplateRefs = (str) => str.includes("${");
+    const escapeForOuterTemplate = (str) => str.replace(/\$\{/g, "$${");
+    const channelValue = hasTemplateRefs(convertedChannel) ? `\`${escapeForOuterTemplate(convertedChannel).replace(/`/g, "\\`")}\`` : `"${slackChannel}"`;
+    const messageValue = hasTemplateRefs(convertedMessage) ? `\`${escapeForOuterTemplate(convertedMessage).replace(/`/g, "\\`")}\`` : `"${slackMessage}"`;
+    return [
+      `${indent}const ${varName} = await ${stepInfo.functionName}({`,
+      `${indent}  slackChannel: ${channelValue},`,
+      `${indent}  slackMessage: ${messageValue},`,
+      `${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) : void 0;
+    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 === void 0 || 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 === "Send Slack Message") {
+      lines.push(
+        ...wrapActionCall(generateSlackActionCode(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 === void 0 || value === null || value === "") {
+        continue;
+      }
+      params.push(formatFieldValue(field.type, value, indent, field.key));
+    }
+    return params;
+  }
+  const EXCLUDED_CONFIG_KEYS = /* @__PURE__ */ 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 === void 0 || 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}
+
+${codeLines.join("\n")}
+`;
+  return {
+    code,
+    functionName,
+    imports: Array.from(imports)
+  };
+}
+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}
+`;
+}
+
+// src/plugins/condition/index.tsx
+import { GitBranch } from "lucide-react";
+import { jsx } from "react/jsx-runtime";
+var conditionAction = {
+  id: "Condition",
+  label: "Condition",
+  description: "Branch based on a condition",
+  category: "System",
+  icon: /* @__PURE__ */ jsx(GitBranch, { className: "size-12 text-pink-300", strokeWidth: 1.5 }),
+  codeGenerator: `export async function conditionStep(input: {
+  condition: boolean;
+}) {
+  "use step";
+  
+  // Evaluate condition
+  return { condition: input.condition };
+}`
+};
+
+// src/plugins/database-query/index.tsx
+import { Database } from "lucide-react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var databaseQueryAction = {
+  id: "Database Query",
+  label: "Database Query",
+  description: "Query your database",
+  category: "System",
+  icon: /* @__PURE__ */ jsx2(Database, { className: "size-12 text-blue-300", strokeWidth: 1.5 }),
+  codeGenerator: `export async function databaseQueryStep(input: {
+  query: string;
+}) {
+  "use step";
+  
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    return { success: false, error: "DATABASE_URL environment variable is not set" };
+  }
+  
+  const postgres = await import("postgres");
+  const sql = postgres.default(databaseUrl, { max: 1 });
+  
+  try {
+    const result = await sql.unsafe(input.query);
+    await sql.end();
+    return { success: true, rows: result, count: result.length };
+  } catch (error) {
+    await sql.end();
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: \`Database query failed: \${message}\` };
+  }
+}`
+};
+
+// src/plugins/http-request/index.tsx
+import { Zap } from "lucide-react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var httpRequestAction = {
+  id: "HTTP Request",
+  label: "HTTP Request",
+  description: "Make an HTTP request to any API",
+  category: "System",
+  icon: /* @__PURE__ */ jsx3(Zap, { className: "size-12 text-amber-300", strokeWidth: 1.5 }),
+  codeGenerator: `export async function httpRequestStep(input: {
+  endpoint: string;
+  httpMethod: string;
+  httpHeaders?: string;
+  httpBody?: string;
+}) {
+  "use step";
+  
+  let headers = {};
+  if (input.httpHeaders) {
+    try {
+      headers = JSON.parse(input.httpHeaders);
+    } catch {
+      // If parsing fails, use empty headers
+    }
+  }
+  
+  let body: string | undefined;
+  if (input.httpMethod !== "GET" && input.httpBody) {
+    try {
+      const parsedBody = JSON.parse(input.httpBody);
+      if (Object.keys(parsedBody).length > 0) {
+        body = JSON.stringify(parsedBody);
+      }
+    } catch {
+      if (input.httpBody.trim() && input.httpBody.trim() !== "{}") {
+        body = input.httpBody;
+      }
+    }
+  }
+  
+  const response = await fetch(input.endpoint, {
+    method: input.httpMethod,
+    headers,
+    body,
+  });
+  
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    return await response.json();
+  }
+  return await response.text();
+}`
+};
+
+export {
+  ARRAY_INDEX_PATTERN,
+  analyzeNodeUsage,
+  buildEdgeMap,
+  findTriggerNodes,
+  escapeForTemplateLiteral,
+  sanitizeFunctionName,
+  sanitizeStepName,
+  sanitizeVarName,
+  generateWorkflowCode,
+  generateWorkflowModule,
+  conditionAction,
+  databaseQueryAction,
+  httpRequestAction
+};