next-workflow-builder 0.1.0

package/src/plugins/switch/index.ts

@@ -0,0 +1,87 @@
+import { type IntegrationPlugin } from "../registry";
+import { SwitchIcon } from "./icon";
+
+const switchPlugin: IntegrationPlugin = {
+  type: "switch",
+  label: "Switch",
+  description: "Route data to different outputs based on rules or expressions",
+  icon: SwitchIcon,
+  isBuiltIn: true,
+
+  formFields: [],
+
+  actions: [
+    {
+      slug: "route",
+      label: "Switch",
+      description:
+        "Evaluate rules or expressions to route data to different outputs",
+      category: "System",
+      stepFunction: "switchStep",
+      stepImportPath: "evaluate",
+      configFields: [
+        {
+          key: "mode",
+          label: "Mode",
+          type: "select",
+          options: [
+            { value: "rules", label: "Rules" },
+            { value: "expression", label: "Expression" },
+          ],
+          defaultValue: "rules",
+        },
+        {
+          key: "value",
+          label: "Value to Evaluate",
+          type: "template-input",
+          placeholder: "e.g., {{PreviousNode.status}}, {{Trigger.type}}",
+          showWhen: { field: "mode", equals: "rules" },
+        },
+        {
+          key: "rules",
+          label: "Rules (JSON array)",
+          type: "template-textarea",
+          placeholder:
+            "[{\"output\": 0, \"operator\": \"equals\", \"value\": \"active\", \"name\": \"Active\"}, {\"output\": 1, \"operator\": \"equals\", \"value\": \"inactive\", \"name\": \"Inactive\"}]",
+          rows: 5,
+          showWhen: { field: "mode", equals: "rules" },
+        },
+        {
+          key: "outputExpression",
+          label: "Output Index Expression",
+          type: "template-input",
+          placeholder: "e.g., {{PreviousNode.outputIndex}}",
+          showWhen: { field: "mode", equals: "expression" },
+        },
+        {
+          key: "fallbackOutput",
+          label: "When No Rule Matches",
+          type: "select",
+          options: [
+            { value: "none", label: "Do nothing (discard)" },
+            { value: "fallback", label: "Route to fallback output" },
+          ],
+          defaultValue: "none",
+        },
+      ],
+      outputFields: [
+        {
+          field: "matchedOutput",
+          description: "Index of the matched output (0-based), or -1 if none",
+        },
+        {
+          field: "matchedRuleName",
+          description: "Name of the matched rule, if set",
+        },
+        {
+          field: "matchedRuleIndex",
+          description: "Index of the matched rule in the rules array",
+        },
+        { field: "value", description: "The value that was evaluated" },
+        { field: "outputCount", description: "Total number of outputs" },
+      ],
+    },
+  ],
+};
+
+export default switchPlugin;

package/src/plugins/switch/steps/evaluate.ts

@@ -0,0 +1,139 @@
+/**
+ * Executable step function for Switch action
+ * Evaluates routing rules and returns the matched output index
+ * Similar to n8n's Switch node
+ */
+import "server-only";
+import { StepInput, withStepLogging } from "../../../lib/steps/step-handler";
+
+export type SwitchRule = {
+  /** Which output index this rule routes to */
+  output: number;
+  /** Comparison operator */
+  operator: string;
+  /** Value to compare against */
+  value: string;
+  /** Optional human-readable name for the rule */
+  name?: string;
+};
+
+export type SwitchInput = StepInput & {
+  /** Mode: "rules" or "expression" */
+  mode: string;
+  /** Value to evaluate against rules (rules mode) */
+  value?: string;
+  /** Parsed array of routing rules (rules mode) */
+  rules?: SwitchRule[];
+  /** Expression that resolves to an output index (expression mode) */
+  outputIndex?: number;
+  /** Fallback behavior: "none" or "fallback" */
+  fallbackOutput?: string;
+};
+
+export type SwitchResult = {
+  /** Matched output index, or -1 if no match */
+  matchedOutput: number;
+  /** Index of the matched rule in the rules array, or -1 */
+  matchedRuleIndex: number;
+  /** Name of the matched rule, if set */
+  matchedRuleName: string;
+  /** The value that was evaluated */
+  value: string;
+  /** Total number of outputs (max output index + 1, or expression result + 1) */
+  outputCount: number;
+};
+
+function applyOperator(
+  value: string,
+  operator: string,
+  operand: string,
+): boolean {
+  switch (operator) {
+    case "equals":
+      return value === operand;
+    case "notEquals":
+      return value !== operand;
+    case "contains":
+      return value.includes(operand);
+    case "notContains":
+      return !value.includes(operand);
+    case "greaterThan":
+      return Number(value) > Number(operand);
+    case "lessThan":
+      return Number(value) < Number(operand);
+    case "startsWith":
+      return value.startsWith(operand);
+    case "endsWith":
+      return value.endsWith(operand);
+    case "regex":
+      try {
+        return new RegExp(operand).test(value);
+      } catch {
+        return false;
+      }
+    case "isEmpty":
+      return value === "" || value === null || value === undefined;
+    case "isNotEmpty":
+      return value !== "" && value !== null && value !== undefined;
+    default:
+      return false;
+  }
+}
+
+function evaluateSwitch(input: SwitchInput): SwitchResult {
+  const mode = input.mode || "rules";
+
+  // Expression mode: outputIndex is already resolved
+  if (mode === "expression") {
+    const outputIndex =
+      typeof input.outputIndex === "number" ? input.outputIndex : -1;
+    return {
+      matchedOutput: outputIndex,
+      matchedRuleIndex: -1,
+      matchedRuleName: "",
+      value: String(input.outputIndex ?? ""),
+      outputCount: outputIndex >= 0 ? outputIndex + 1 : 0,
+    };
+  }
+
+  // Rules mode: evaluate value against each rule
+  const value = String(input.value ?? "");
+  const rules = Array.isArray(input.rules) ? input.rules : [];
+
+  let maxOutput = 0;
+  for (const rule of rules) {
+    if (rule.output > maxOutput) {
+      maxOutput = rule.output;
+    }
+  }
+
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i];
+    if (applyOperator(value, rule.operator, rule.value)) {
+      return {
+        matchedOutput: rule.output,
+        matchedRuleIndex: i,
+        matchedRuleName: rule.name || "",
+        value,
+        outputCount: maxOutput + 1,
+      };
+    }
+  }
+
+  // No match
+  return {
+    matchedOutput: -1,
+    matchedRuleIndex: -1,
+    matchedRuleName: "",
+    value,
+    outputCount: maxOutput + 1,
+  };
+}
+
+// biome-ignore lint/suspicious/useAwait: workflow "use step" requires async
+export async function switchStep(input: SwitchInput): Promise<SwitchResult> {
+  "use step";
+  return withStepLogging(input, () => Promise.resolve(evaluateSwitch(input)));
+}
+
+switchStep.maxRetries = 0;

package/src/plugins/switch/workflow-executor.patch

@@ -0,0 +1,130 @@
+diff --git a/workflow-builder/lib/workflow-executor.workflow.ts b/workflow-builder/lib/workflow-executor.workflow.ts
+index 075494c78..9bbe7746a 100644
+--- a/workflow-builder/lib/workflow-executor.workflow.ts
++++ b/workflow-builder/lib/workflow-executor.workflow.ts
+@@ -312,6 +312,56 @@ async function executeActionStep(input: {
+     });
+   }
+ 
++  // Special handling for Switch action - rules/expression routing handled in executeNode
++  if (actionType === "Switch" || actionType === "switch/route") {
++    const stepImporter = getStepImporter("switch/route");
++    if (!stepImporter) {
++      return { success: false, error: "Switch step not found in plugin registry" };
++    }
++    const module = await stepImporter.importer();
++    const mode = (stepInput.mode as string) || "rules";
++
++    // Parse rules from JSON string if needed
++    let rules: unknown[] = [];
++    if (typeof stepInput.rules === "string") {
++      const trimmed = (stepInput.rules as string).trim();
++      if (trimmed.startsWith("[")) {
++        try {
++          rules = JSON.parse(trimmed);
++        } catch (e) {
++          console.error("[Switch] Failed to parse rules JSON:", e);
++        }
++      }
++    } else if (Array.isArray(stepInput.rules)) {
++      rules = stepInput.rules;
++    }
++
++    // Parse outputExpression to a number for expression mode
++    let outputIndex: number | undefined;
++    if (mode === "expression") {
++      const raw = stepInput.outputExpression;
++      if (typeof raw === "number") {
++        outputIndex = raw;
++      } else if (typeof raw === "string") {
++        outputIndex = parseInt(raw, 10);
++        if (Number.isNaN(outputIndex)) {
++          outputIndex = -1;
++        }
++      }
++    }
++
++    console.log("[Switch] Mode:", mode, "Rules:", rules.length, "OutputIndex:", outputIndex);
++
++    return await module[stepImporter.stepFunction]({
++      mode,
++      value: stepInput.value,
++      rules,
++      outputIndex,
++      fallbackOutput: stepInput.fallbackOutput ?? "none",
++      _context: context,
++    });
++  }
++
+   // Check system actions first (Database Query, HTTP Request)
+   const systemAction = SYSTEM_ACTIONS[actionType];
+   if (systemAction) {
+@@ -734,6 +784,11 @@ export async function executeWorkflow(input: WorkflowExecutionInput) {
+           node.data.type === "action" &&
+           (loopActionType === "Loop" || loopActionType === "loop/iterate");
+ 
++        // Check if this is a switch node
++        const isSwitchNode =
++          node.data.type === "action" &&
++          (loopActionType === "Switch" || loopActionType === "switch/route");
++
+         if (isConditionNode) {
+           // For condition nodes, only execute next nodes if condition is true
+           const conditionResult = (result.data as { condition?: boolean })
+@@ -817,6 +872,56 @@ export async function executeWorkflow(input: WorkflowExecutionInput) {
+           }
+ 
+           console.log("[Workflow Executor] Loop completed all iterations");
++        } else if (isSwitchNode) {
++          // For switch nodes, route to specific downstream nodes based on matched output
++          const switchResult = result.data as {
++            matchedOutput?: number;
++            fallbackOutput?: string;
++          };
++          const matchedOutput = switchResult?.matchedOutput ?? -1;
++          const fallbackOutput = node.data.config?.fallbackOutput as string || "none";
++
++          console.log(
++            "[Workflow Executor] Switch node: matchedOutput:", matchedOutput,
++            "fallbackOutput:", fallbackOutput
++          );
++
++          // Filter edges from this node based on sourceHandle
++          const switchEdges = edges.filter((edge) => edge.source === nodeId);
++          const matchedTargets: string[] = [];
++
++          for (const edge of switchEdges) {
++            const handle = edge.sourceHandle;
++
++            if (!handle) {
++              // No sourceHandle: always execute (backward compat)
++              matchedTargets.push(edge.target);
++            } else if (handle === "fallback") {
++              // Fallback handle: execute only when no rule matched and fallback is enabled
++              if (matchedOutput === -1 && fallbackOutput === "fallback") {
++                matchedTargets.push(edge.target);
++              }
++            } else if (handle.startsWith("output_")) {
++              // Numbered output handle: execute when matched
++              const outputIndex = parseInt(handle.replace("output_", ""), 10);
++              if (outputIndex === matchedOutput) {
++                matchedTargets.push(edge.target);
++              }
++            }
++          }
++
++          console.log(
++            "[Workflow Executor] Switch routing to",
++            matchedTargets.length,
++            "of",
++            switchEdges.length,
++            "downstream nodes"
++          );
++
++          // Execute matched downstream nodes (preserve loop context if inside a loop)
++          await Promise.all(
++            matchedTargets.map((targetId) => executeNode(targetId, visited, loopContext))
++          );
+         } else {
+           // For non-condition/non-loop nodes, execute all next nodes in parallel
+           const nextNodes = edgesBySource.get(nodeId) || [];

package/src/scripts/create-plugin.ts

@@ -0,0 +1,301 @@
+#!/usr/bin/env tsx
+/**
+ * Plugin Scaffolding Script
+ *
+ * Creates a new plugin from templates using interactive prompts.
+ *
+ * Usage:
+ *   pnpm create-plugin
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { input } from "@inquirer/prompts";
+
+const PLUGINS_DIR = join(process.cwd(), "plugins");
+const TEMPLATE_DIR = join(import.meta.dirname, "..", "plugins", "_template");
+
+// Regex patterns used for case conversions (hoisted for performance)
+const LEADING_UPPERCASE_REGEX = /^[A-Z]/;
+const VALID_IDENTIFIER_REGEX = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+const UNSAFE_PATH_REGEX = /[/\\]|\.\./;
+
+/**
+ * Convert a string to various case formats
+ */
+function toKebabCase(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .toLowerCase();
+}
+
+function toCamelCase(str: string): string {
+  return str
+    .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ""))
+    .replace(LEADING_UPPERCASE_REGEX, (c) => c.toLowerCase());
+}
+
+function toPascalCase(str: string): string {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+function toUpperSnake(str: string): string {
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/[-\s]+/g, "_")
+    .toUpperCase();
+}
+
+function toTitleCase(str: string): string {
+  return str
+    .replace(/[-_]+/g, " ")
+    .replace(
+      /\w\S*/g,
+      (txt) => txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase()
+    );
+}
+
+/**
+ * Escape special characters for use in string literals.
+ */
+function escapeString(str: string): string {
+  return str
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/'/g, "\\'")
+    .replace(/`/g, "\\`")
+    .replace(/\$/g, "\\$")
+    .replace(/\n/g, "\\n")
+    .replace(/\r/g, "\\r")
+    .replace(/\t/g, "\\t")
+    .replace(/\0/g, "\\0");
+}
+
+/**
+ * Check if a string is a valid JavaScript identifier
+ */
+function isValidIdentifier(str: string): boolean {
+  return VALID_IDENTIFIER_REGEX.test(str);
+}
+
+type PluginConfig = {
+  integrationName: string;
+  integrationDescription: string;
+  actionName: string;
+  actionDescription: string;
+};
+
+/**
+ * Replace all placeholders in content
+ */
+function replacePlaceholders(content: string, config: PluginConfig): string {
+  const {
+    integrationName,
+    integrationDescription,
+    actionName,
+    actionDescription,
+  } = config;
+
+  // Integration placeholders
+  const intKebab = toKebabCase(integrationName);
+  const intCamel = toCamelCase(integrationName);
+  const intPascal = toPascalCase(integrationName);
+  const intUpperSnake = toUpperSnake(integrationName);
+  const intTitle = toTitleCase(integrationName);
+
+  // Action placeholders
+  const actKebab = toKebabCase(actionName);
+  const actCamel = toCamelCase(actionName);
+  const actPascal = toPascalCase(actionName);
+  const actUpperSnake = toUpperSnake(actionName);
+  const actTitle = toTitleCase(actionName);
+
+  return (
+    content
+      // Integration placeholders
+      .replace(/\[integration-type\]/g, intKebab)
+      .replace(/\[integration-name\]/g, intKebab)
+      .replace(/\[integrationName\]/g, intCamel)
+      .replace(/\[IntegrationName\]/g, intPascal)
+      .replace(/\[INTEGRATION_NAME\]/g, intUpperSnake)
+      .replace(/\[Integration Name\]/g, intTitle)
+      .replace(
+        /\[Integration Description\]/g,
+        escapeString(integrationDescription)
+      )
+      // Action placeholders
+      .replace(/\[action-slug\]/g, actKebab)
+      .replace(/\[actionName\]/g, actCamel)
+      .replace(/\[ActionName\]/g, actPascal)
+      .replace(/\[ACTION_NAME\]/g, actUpperSnake)
+      .replace(/\[Action Name\]/g, actTitle)
+      .replace(/\[Action Label\]/g, actTitle)
+      .replace(/\[Action Description\]/g, escapeString(actionDescription))
+  );
+}
+
+/**
+ * Get dynamic template files based on action name
+ */
+function getTemplateFiles(actionSlug: string) {
+  return [
+    { src: "index.ts.txt", dest: "index.ts" },
+    { src: "icon.tsx.txt", dest: "icon.tsx" },
+    { src: "test.ts.txt", dest: "test.ts" },
+    { src: "credentials.ts.txt", dest: "credentials.ts" },
+    { src: "steps/action.ts.txt", dest: `steps/${actionSlug}.ts` },
+  ];
+}
+
+/**
+ * Main execution
+ */
+async function main(): Promise<void> {
+  console.log("\nCreate New Plugin for Workflow Builder\n");
+
+  // Check if template directory exists (ships with the package)
+  if (!existsSync(TEMPLATE_DIR)) {
+    console.error("Error: Template directory not found at", TEMPLATE_DIR);
+    console.error("   The next-workflow-builder package may be corrupted.\n");
+    process.exit(1);
+  }
+
+  // Ensure plugins directory exists
+  if (!existsSync(PLUGINS_DIR)) {
+    mkdirSync(PLUGINS_DIR, { recursive: true });
+  }
+
+  // Prompt for plugin details
+  const integrationName = await input({
+    message: "Integration Name:",
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Integration name is required";
+      }
+      if (UNSAFE_PATH_REGEX.test(value)) {
+        return "Name cannot contain path separators (/, \\) or '..'";
+      }
+      const camel = toCamelCase(value);
+      const pascal = toPascalCase(value);
+      if (!(isValidIdentifier(camel) && isValidIdentifier(pascal))) {
+        return `Integration name must produce valid JavaScript identifiers. "${value}" converts to "${camel}" (camelCase) and "${pascal}" (PascalCase). Use only letters, numbers, underscores, and dollar signs.`;
+      }
+      const kebab = toKebabCase(value);
+      const dir = join(PLUGINS_DIR, kebab);
+      if (existsSync(dir)) {
+        return `Plugin already exists at plugins/${kebab}/`;
+      }
+      return true;
+    },
+  });
+
+  const integrationDescription = await input({
+    message: "Integration Description (<10 words):",
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Integration description is required";
+      }
+      return true;
+    },
+  });
+
+  const actionName = await input({
+    message: "Action Name:",
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Action name is required";
+      }
+      if (UNSAFE_PATH_REGEX.test(value)) {
+        return "Name cannot contain path separators (/, \\) or '..'";
+      }
+      const camel = toCamelCase(value);
+      const pascal = toPascalCase(value);
+      if (!(isValidIdentifier(camel) && isValidIdentifier(pascal))) {
+        return `Action name must produce valid JavaScript identifiers. "${value}" converts to "${camel}" (camelCase) and "${pascal}" (PascalCase). Use only letters, numbers, underscores, and dollar signs.`;
+      }
+      return true;
+    },
+  });
+
+  const actionDescription = await input({
+    message: "Action Description (<10 words):",
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Action description is required";
+      }
+      return true;
+    },
+  });
+
+  const answers: PluginConfig = {
+    integrationName,
+    integrationDescription,
+    actionName,
+    actionDescription,
+  };
+
+  const pluginName = toKebabCase(integrationName);
+  const actionSlug = toKebabCase(actionName);
+  const pluginDir = join(PLUGINS_DIR, pluginName);
+
+  console.log(`\nGenerating plugin: ${pluginName}`);
+
+  // Create directories
+  mkdirSync(join(pluginDir, "steps"), { recursive: true });
+
+  // Copy and process template files
+  const createdFiles: string[] = [];
+  const templateFiles = getTemplateFiles(actionSlug);
+
+  for (const { src, dest } of templateFiles) {
+    const srcPath = join(TEMPLATE_DIR, src);
+    const destPath = join(pluginDir, dest);
+
+    if (!existsSync(srcPath)) {
+      console.error(`\nError: Template file not found: ${src}`);
+      console.error("   The template directory may be corrupted.\n");
+      process.exit(1);
+    }
+
+    let content = readFileSync(srcPath, "utf-8");
+    content = replacePlaceholders(content, answers);
+
+    writeFileSync(destPath, content, "utf-8");
+    createdFiles.push(`plugins/${pluginName}/${dest}`);
+  }
+
+  // Print created files
+  console.log(`\nCreated plugin at plugins/${pluginName}/\n`);
+  console.log("Files created:");
+  for (const file of createdFiles) {
+    console.log(`  - ${file}`);
+  }
+
+  // Run discover-plugins to register the new plugin
+  console.log("\nAdding plugin to registry...");
+  execFileSync("npx", ["nwb", "discover-plugins"], { stdio: "inherit" });
+
+  console.log(
+    `\nPlugin "${answers.integrationName}" has been added to the registry!\n`
+  );
+  console.log("Next steps:");
+  console.log(`  1. Review and customize the files in plugins/${pluginName}/`);
+  console.log("  2. Update the icon in icon.tsx with your integration's SVG");
+  console.log(
+    "  3. Implement the API logic in steps/ (codegen is auto-generated)"
+  );
+  console.log("  4. Test: pnpm dev\n");
+}
+
+main().catch((error: unknown) => {
+  if (error instanceof Error && error.name === "ExitPromptError") {
+    console.log("\nCome back anytime to create your plugin.\n");
+    process.exit(0);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.error("Error:", message);
+  process.exit(1);
+});