@n8n/workflow-sdk 0.9.0 → 0.10.1

package/dist/prompts/sdk-reference/workflow-patterns.js

@@ -0,0 +1,479 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKFLOW_PATTERNS_CONCISE = exports.WORKFLOW_SDK_PATTERNS = void 0;
+const SDK_IMPORT = "import { workflow, node, trigger, sticky, placeholder, newCredential, ifElse, switchCase, merge, splitInBatches, nextBatch, languageModel, memory, tool, outputParser, embedding, embeddings, vectorStore, retriever, documentLoader, textSplitter, fromAi, expr } from '@n8n/workflow-sdk';";
+exports.WORKFLOW_SDK_PATTERNS = `<linear_chain>
+\`\`\`javascript
+${SDK_IMPORT}
+
+// 1. Define all nodes first
+const startTrigger = trigger({
+  type: 'n8n-nodes-base.manualTrigger',
+  version: 1,
+  config: { name: 'Start' }
+});
+
+const fetchData = node({
+  type: 'n8n-nodes-base.httpRequest',
+  version: 4.3,
+  config: { name: 'Fetch Data', parameters: { method: 'GET', url: '...' } }
+});
+
+const processData = node({
+  type: 'n8n-nodes-base.set',
+  version: 3.4,
+  config: { name: 'Process Data', parameters: {} }
+});
+
+// 2. Compose workflow
+export default workflow('id', 'name')
+  .add(startTrigger)
+  .to(fetchData)
+  .to(processData);
+\`\`\`
+
+</linear_chain>
+
+<independent_sources>
+When nodes return more than 1 item, chaining causes item multiplication: if Source A returns N items, a chained Source B runs N times instead of once.
+
+**When to use \`executeOnce: true\`:**
+- A node fetches data independently but is chained after another data source (prevents N×M multiplication)
+- A node should summarize/aggregate all upstream items in a single call (e.g., AI summary, send one notification)
+- A node calls an API that doesn't vary per input item
+
+Fix with \`executeOnce: true\` (simplest) or parallel branches + Merge (when combining results):
+
+\`\`\`javascript
+// sourceA outputs 10 items. sourceB outputs 10 items.
+// WRONG - processResults runs 100 times
+// startTrigger.to(sourceA.to(sourceB.to(processResults)))
+
+// FIX 1 - executeOnce: sourceB runs once regardless of input items
+const sourceB = node({ ..., config: { ..., executeOnce: true } });
+startTrigger.to(sourceA.to(sourceB.to(processResults)));
+
+// FIX 2 - parallel branches + Merge (combine by position)
+const combineResults = merge({
+  version: 3.2,
+  config: { name: 'Combine Results', parameters: { mode: 'combine', combineBy: 'combineByPosition' } }
+});
+export default workflow('id', 'name')
+  .add(startTrigger)
+  .to(sourceA.to(combineResults.input(0)))
+  .add(startTrigger)
+  .to(sourceB.to(combineResults.input(1)))
+  .add(combineResults)
+  .to(processResults);
+
+// FIX 3 - parallel branches + Merge (append)
+const allResults = merge({
+  version: 3.2,
+  config: { name: 'All Results', parameters: { mode: 'append' } }
+});
+export default workflow('id', 'name')
+  .add(startTrigger)
+  .to(sourceA.to(allResults.input(0)))
+  .add(startTrigger)
+  .to(sourceB.to(allResults.input(1)))
+  .add(allResults)
+  .to(processResults);
+\`\`\`
+
+</independent_sources>
+
+<zero_item_safety>
+Nodes that fetch or filter data may return 0 items, which stops the entire downstream chain.
+Use \`alwaysOutputData: true\` on data-fetching nodes to ensure the chain continues with an empty item \`{json: {}}\`.
+
+\`\`\`javascript
+// Data Table might be empty (fresh table, no matching rows)
+const getReflections = node({
+  type: 'n8n-nodes-base.dataTable',
+  version: 1.1,
+  config: {
+    name: 'Get Reflections',
+    alwaysOutputData: true,  // Chain continues even if table is empty
+    parameters: { resource: 'row', operation: 'get', returnAll: true }
+  }
+});
+
+// Downstream Code node handles the empty case
+const processData = node({
+  type: 'n8n-nodes-base.code',
+  version: 2,
+  config: {
+    name: 'Process Data',
+    parameters: {
+      mode: 'runOnceForAllItems',
+      jsCode: \\\`
+const items = $input.all();
+// items will be [{json: {}}] if upstream had no data
+const hasData = items.length > 0 && Object.keys(items[0].json).length > 0;
+// ... handle both cases
+\\\`.trim()
+    }
+  }
+});
+\`\`\`
+
+**When to use \`alwaysOutputData: true\`:**
+- Data Table with \`operation: 'get'\` (table may be empty or freshly created)
+- Any lookup/search/filter node whose result feeds into downstream processing
+- HTTP Request that may return an empty array
+
+**When NOT to use it:**
+- Trigger nodes (they always produce output)
+- Code nodes (handle empty input in your code logic instead)
+- Nodes at the end of the chain (no downstream to protect)
+
+</zero_item_safety>
+
+<conditional_branching>
+
+**CRITICAL:** Each branch defines a COMPLETE processing path. Chain multiple steps INSIDE the branch using .to().
+
+Every IF/Filter \`conditions\` parameter MUST include \`options\`, \`conditions\`, and \`combinator\`:
+\`\`\`javascript
+const checkValid = ifElse({
+  version: 2.2,
+  config: {
+    name: 'Check Valid',
+    parameters: {
+      conditions: {
+        options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' },
+        conditions: [{ leftValue: '={{ $json.status }}', operator: { type: 'string', operation: 'equals' }, rightValue: 'active' }],
+        combinator: 'and'
+      }
+    }
+  }
+});
+
+export default workflow('id', 'name')
+  .add(startTrigger)
+  .to(checkValid
+    .onTrue(formatData.to(enrichData.to(saveToDb)))  // Chain 3 nodes on true branch
+    .onFalse(logError));
+\`\`\`
+
+</conditional_branching>
+
+<multi_way_routing>
+
+Switch rules use \`rules.values\` (NOT \`rules.rules\`). Each rule needs \`outputKey\` and a complete \`conditions\` object:
+\`\`\`javascript
+const routeByPriority = switchCase({
+  version: 3.2,
+  config: {
+    name: 'Route by Priority',
+    parameters: {
+      rules: {
+        values: [
+          { outputKey: 'urgent', conditions: { options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' }, conditions: [{ leftValue: '={{ $json.priority }}', operator: { type: 'string', operation: 'equals' }, rightValue: 'urgent' }], combinator: 'and' } },
+          { outputKey: 'normal', conditions: { options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' }, conditions: [{ leftValue: '={{ $json.priority }}', operator: { type: 'string', operation: 'equals' }, rightValue: 'normal' }], combinator: 'and' } },
+        ]
+      }
+    }
+  }
+});
+
+export default workflow('id', 'name')
+  .add(startTrigger)
+  .to(routeByPriority
+    .onCase('urgent', processUrgent.to(notifyTeam.to(escalate)))
+    .onCase('normal', processNormal)
+    .onDefault(archive));
+\`\`\`
+
+</multi_way_routing>
+
+<parallel_execution>
+\`\`\`javascript
+// First declare the Merge node using merge()
+const combineResults = merge({
+  version: 3.2,
+  config: { name: 'Combine Results', parameters: { mode: 'combine' } }
+});
+
+// Declare branch nodes
+const branch1 = node({ type: 'n8n-nodes-base.httpRequest', ... });
+const branch2 = node({ type: 'n8n-nodes-base.httpRequest', ... });
+const processResults = node({ type: 'n8n-nodes-base.set', ... });
+
+// Connect branches to specific merge inputs using .input(n)
+export default workflow('id', 'name')
+  .add(trigger({ ... }))
+  .to(branch1.to(combineResults.input(0)))  // Connect to input 0
+  .add(trigger({ ... }))
+  .to(branch2.to(combineResults.input(1)))  // Connect to input 1
+  .add(combineResults)
+  .to(processResults);  // Process merged results
+\`\`\`
+
+</parallel_execution>
+
+<batch_processing>
+\`\`\`javascript
+const startTrigger = trigger({
+  type: 'n8n-nodes-base.manualTrigger',
+  version: 1,
+  config: { name: 'Start' }
+});
+
+const fetchRecords = node({
+  type: 'n8n-nodes-base.httpRequest',
+  version: 4.3,
+  config: { name: 'Fetch Records', parameters: { method: 'GET', url: '...' } }
+});
+
+const finalizeResults = node({
+  type: 'n8n-nodes-base.set',
+  version: 3.4,
+  config: { name: 'Finalize', parameters: {} }
+});
+
+const processRecord = node({
+  type: 'n8n-nodes-base.httpRequest',
+  version: 4.3,
+  config: { name: 'Process Record', parameters: { method: 'POST', url: '...' } }
+});
+
+const sibNode = splitInBatches({ version: 3, config: { name: 'Batch Process', parameters: { batchSize: 10 } } });
+
+export default workflow('id', 'name')
+  .add(startTrigger)
+  .to(fetchRecords)
+  .to(sibNode
+    .onDone(finalizeResults)
+    .onEachBatch(processRecord.to(nextBatch(sibNode)))
+  );
+\`\`\`
+
+</batch_processing>
+
+<multiple_triggers>
+\`\`\`javascript
+const webhookTrigger = trigger({
+  type: 'n8n-nodes-base.webhook',
+  version: 2.1,
+  config: { name: 'Webhook' }
+});
+
+const processWebhook = node({
+  type: 'n8n-nodes-base.set',
+  version: 3.4,
+  config: { name: 'Process Webhook', parameters: {} }
+});
+
+const scheduleTrigger = trigger({
+  type: 'n8n-nodes-base.scheduleTrigger',
+  version: 1.3,
+  config: { name: 'Daily Schedule', parameters: {} }
+});
+
+const processSchedule = node({
+  type: 'n8n-nodes-base.set',
+  version: 3.4,
+  config: { name: 'Process Schedule', parameters: {} }
+});
+
+export default workflow('id', 'name')
+  .add(webhookTrigger)
+  .to(processWebhook)
+  .add(scheduleTrigger)
+  .to(processSchedule);
+\`\`\`
+
+</multiple_triggers>
+
+<fan_in>
+\`\`\`javascript
+// Each trigger's execution runs in COMPLETE ISOLATION.
+// Different branches have no effect on each other.
+// Never duplicate chains for "isolation" - it's already guaranteed.
+
+const webhookTrigger = trigger({
+  type: 'n8n-nodes-base.webhook',
+  version: 2.1,
+  config: { name: 'Webhook Trigger' }
+});
+
+const scheduleTrigger = trigger({
+  type: 'n8n-nodes-base.scheduleTrigger',
+  version: 1.3,
+  config: { name: 'Daily Schedule' }
+});
+
+const processData = node({
+  type: 'n8n-nodes-base.set',
+  version: 3.4,
+  config: { name: 'Process Data', parameters: {} }
+});
+
+const sendNotification = node({
+  type: 'n8n-nodes-base.slack',
+  version: 2.3,
+  config: { name: 'Notify Slack', parameters: {} }
+});
+
+export default workflow('id', 'name')
+  .add(webhookTrigger)
+  .to(processData)
+  .to(sendNotification)
+  .add(scheduleTrigger)
+  .to(processData);
+\`\`\`
+
+</fan_in>
+
+<ai_agent_basic>
+\`\`\`javascript
+const openAiModel = languageModel({
+  type: '@n8n/n8n-nodes-langchain.lmChatOpenAi',
+  version: 1.3,
+  config: { name: 'OpenAI Model', parameters: {} }
+});
+
+const startTrigger = trigger({
+  type: 'n8n-nodes-base.manualTrigger',
+  version: 1,
+  config: { name: 'Start' }
+});
+
+const aiAgent = node({
+  type: '@n8n/n8n-nodes-langchain.agent',
+  version: 3.1,
+  config: {
+    name: 'AI Assistant',
+    parameters: { promptType: 'define', text: 'You are a helpful assistant' },
+    subnodes: { model: openAiModel }
+  }
+});
+
+export default workflow('ai-assistant', 'AI Assistant')
+  .add(startTrigger)
+  .to(aiAgent);
+\`\`\`
+
+</ai_agent_basic>
+
+<ai_agent_with_tools>
+\`\`\`javascript
+const openAiModel = languageModel({
+  type: '@n8n/n8n-nodes-langchain.lmChatOpenAi',
+  version: 1.3,
+  config: {
+    name: 'OpenAI Model',
+    parameters: {},
+    credentials: { openAiApi: newCredential('OpenAI') }
+  }
+});
+
+const calculatorTool = tool({
+  type: '@n8n/n8n-nodes-langchain.toolCalculator',
+  version: 1,
+  config: { name: 'Calculator', parameters: {} }
+});
+
+const startTrigger = trigger({
+  type: 'n8n-nodes-base.manualTrigger',
+  version: 1,
+  config: { name: 'Start' }
+});
+
+const aiAgent = node({
+  type: '@n8n/n8n-nodes-langchain.agent',
+  version: 3.1,
+  config: {
+    name: 'Math Agent',
+    parameters: { promptType: 'define', text: 'You can use tools to help users' },
+    subnodes: { model: openAiModel, tools: [calculatorTool] }
+  }
+});
+
+export default workflow('ai-calculator', 'AI Calculator')
+  .add(startTrigger)
+  .to(aiAgent);
+\`\`\`
+
+</ai_agent_with_tools>
+
+<ai_agent_with_from_ai>
+\`\`\`javascript
+const openAiModel = languageModel({
+  type: '@n8n/n8n-nodes-langchain.lmChatOpenAi',
+  version: 1.3,
+  config: {
+    name: 'OpenAI Model',
+    parameters: {},
+    credentials: { openAiApi: newCredential('OpenAI') }
+  }
+});
+
+const gmailTool = tool({
+  type: 'n8n-nodes-base.gmailTool',
+  version: 1,
+  config: {
+    name: 'Gmail Tool',
+    parameters: {
+      sendTo: fromAi('recipient', 'Email address'),
+      subject: fromAi('subject', 'Email subject'),
+      message: fromAi('body', 'Email content')
+    },
+    credentials: { gmailOAuth2: newCredential('Gmail') }
+  }
+});
+
+const startTrigger = trigger({
+  type: 'n8n-nodes-base.manualTrigger',
+  version: 1,
+  config: { name: 'Start' }
+});
+
+const aiAgent = node({
+  type: '@n8n/n8n-nodes-langchain.agent',
+  version: 3.1,
+  config: {
+    name: 'Email Agent',
+    parameters: { promptType: 'define', text: 'You can send emails' },
+    subnodes: { model: openAiModel, tools: [gmailTool] }
+  }
+});
+
+export default workflow('ai-email', 'AI Email Sender')
+  .add(startTrigger)
+  .to(aiAgent);
+\`\`\`
+</ai_agent_with_from_ai>
+
+<ai_agent_with_structured_output>
+\`\`\`javascript
+const structuredParser = outputParser({
+  type: '@n8n/n8n-nodes-langchain.outputParserStructured',
+  version: 1.3,
+  config: {
+    name: 'Structured Output Parser',
+    parameters: {
+      schemaType: 'fromJson',
+      jsonSchemaExample: '{ "sentiment": "positive", "confidence": 0.95, "summary": "brief summary" }'
+    }
+  }
+});
+
+const aiAgent = node({
+  type: '@n8n/n8n-nodes-langchain.agent',
+  version: 3.1,
+  config: {
+    name: 'Sentiment Analyzer',
+    parameters: { promptType: 'define', text: 'Analyze the sentiment of the input text', hasOutputParser: true },
+    subnodes: { model: openAiModel, outputParser: structuredParser }
+  }
+});
+
+export default workflow('ai-sentiment', 'AI Sentiment Analyzer')
+  .add(startTrigger)
+  .to(aiAgent);
+\`\`\`
+</ai_agent_with_structured_output>`;
+exports.WORKFLOW_PATTERNS_CONCISE = exports.WORKFLOW_SDK_PATTERNS;
+//# sourceMappingURL=workflow-patterns.js.map

package/dist/prompts/sdk-reference/workflow-patterns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-patterns.js","sourceRoot":"","sources":["../../../src/prompts/sdk-reference/workflow-patterns.ts"],"names":[],"mappings":";;;AAUA,MAAM,UAAU,GACf,8RAA8R,CAAC;AAMnR,QAAA,qBAAqB,GAAG;;EAEnC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAsduB,CAAC;AAEF,oCA1drB,6BAAqB,CA0dyB"}

package/dist/prompts/sdk-reference/workflow-rules.d.ts

@@ -0,0 +1 @@
+export declare const WORKFLOW_RULES = "Follow these rules strictly when generating workflows:\n\n1. **Always use newCredential() for authentication**\n   - When a node needs credentials, always use `newCredential('Name')` in the credentials config\n   - NEVER use placeholder strings, fake API keys, or hardcoded auth values\n   - Example: `credentials: { slackApi: newCredential('Slack Bot') }`\n   - The credential type must match what the node expects\n\n2. **Handle empty outputs with `alwaysOutputData: true`**\n   - Nodes that query data (Data Table get, Google Sheets lookup, HTTP Request, etc.) may return 0 items\n   - When a node returns 0 items, all downstream nodes are SKIPPED \u2014 the workflow chain breaks silently\n   - Set `alwaysOutputData: true` on any node whose output feeds downstream nodes and might return empty results\n   - Common cases: fresh/empty Data Tables, filtered queries, conditional lookups, API searches with no matches\n   - Example: `config: { ..., alwaysOutputData: true }`\n\n3. **Use `executeOnce: true` for single-execution nodes**\n   - When a node receives N items but should only execute once (not N times), set `executeOnce: true`\n   - Common cases: sending a summary notification, generating a report, calling an API that doesn't need per-item execution\n   - Example: `config: { ..., executeOnce: true }`";

package/dist/prompts/sdk-reference/workflow-rules.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKFLOW_RULES = void 0;
+exports.WORKFLOW_RULES = `Follow these rules strictly when generating workflows:
+
+1. **Always use newCredential() for authentication**
+   - When a node needs credentials, always use \`newCredential('Name')\` in the credentials config
+   - NEVER use placeholder strings, fake API keys, or hardcoded auth values
+   - Example: \`credentials: { slackApi: newCredential('Slack Bot') }\`
+   - The credential type must match what the node expects
+
+2. **Handle empty outputs with \`alwaysOutputData: true\`**
+   - Nodes that query data (Data Table get, Google Sheets lookup, HTTP Request, etc.) may return 0 items
+   - When a node returns 0 items, all downstream nodes are SKIPPED — the workflow chain breaks silently
+   - Set \`alwaysOutputData: true\` on any node whose output feeds downstream nodes and might return empty results
+   - Common cases: fresh/empty Data Tables, filtered queries, conditional lookups, API searches with no matches
+   - Example: \`config: { ..., alwaysOutputData: true }\`
+
+3. **Use \`executeOnce: true\` for single-execution nodes**
+   - When a node receives N items but should only execute once (not N times), set \`executeOnce: true\`
+   - Common cases: sending a summary notification, generating a report, calling an API that doesn't need per-item execution
+   - Example: \`config: { ..., executeOnce: true }\``;
+//# sourceMappingURL=workflow-rules.js.map

package/dist/prompts/sdk-reference/workflow-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-rules.js","sourceRoot":"","sources":["../../../src/prompts/sdk-reference/workflow-rules.ts"],"names":[],"mappings":";;;AAQa,QAAA,cAAc,GAAG;;;;;;;;;;;;;;;;;;qDAkBuB,CAAC"}

package/dist/workflow-builder/plugins/defaults.js

@@ -15,6 +15,7 @@ const coreValidators = [
     validators_1.fromAiValidator,
     validators_1.setNodeValidator,
     validators_1.mergeNodeValidator,
+    validators_1.filterNodeValidator,
     validators_1.expressionPrefixValidator,
     validators_1.dateMethodValidator,
     validators_1.expressionPathValidator,

package/dist/workflow-builder/plugins/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../../src/workflow-builder/plugins/defaults.ts"],"names":[],"mappings":";;AAyFA,wDA2BC;AA7GD,6DAA+F;AAE/F,+CAA+C;AAE/C,6CAgBsB;AAatB,MAAM,cAAc,GAAsB;IAEzC,6BAAgB;IAChB,oCAAuB;IACvB,8BAAiB;IAGjB,2BAAc;IACd,8BAAiB;IACjB,iCAAoB;IACpB,8BAAiB;IACjB,4BAAe;IAGf,6BAAgB;IAChB,+BAAkB;IAGlB,sCAAyB;IACzB,gCAAmB;IACnB,oCAAuB;IAGvB,sCAAyB;IACzB,uCAA0B;CAC1B,CAAC;AAKF,MAAM,qBAAqB,GAA6B;IACvD,kCAAa;IACb,sCAAiB;IACjB,0CAAqB;CACrB,CAAC;AAKF,MAAM,eAAe,GAAuB,CAAC,4BAAc,CAAC,CAAC;AAU7D,SAAgB,sBAAsB,CAAC,QAAwB;IAE9D,KAAK,MAAM,SAAS,IAAI,cAAc,EAAE,CAAC;QACxC,IAAI,CAAC;YACJ,QAAQ,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC;QAET,CAAC;IACF,CAAC;IAGD,KAAK,MAAM,OAAO,IAAI,qBAAqB,EAAE,CAAC;QAC7C,IAAI,CAAC;YACJ,QAAQ,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;QAC5C,CAAC;QAAC,MAAM,CAAC;QAET,CAAC;IACF,CAAC;IAGD,KAAK,MAAM,UAAU,IAAI,eAAe,EAAE,CAAC;QAC1C,IAAI,CAAC;YACJ,QAAQ,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;QACzC,CAAC;QAAC,MAAM,CAAC;QAET,CAAC;IACF,CAAC;AACF,CAAC"}
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../../src/workflow-builder/plugins/defaults.ts"],"names":[],"mappings":";;AA2FA,wDA2BC;AA/GD,6DAA+F;AAE/F,+CAA+C;AAE/C,6CAiBsB;AAatB,MAAM,cAAc,GAAsB;IAEzC,6BAAgB;IAChB,oCAAuB;IACvB,8BAAiB;IAGjB,2BAAc;IACd,8BAAiB;IACjB,iCAAoB;IACpB,8BAAiB;IACjB,4BAAe;IAGf,6BAAgB;IAChB,+BAAkB;IAClB,gCAAmB;IAGnB,sCAAyB;IACzB,gCAAmB;IACnB,oCAAuB;IAGvB,sCAAyB;IACzB,uCAA0B;CAC1B,CAAC;AAKF,MAAM,qBAAqB,GAA6B;IACvD,kCAAa;IACb,sCAAiB;IACjB,0CAAqB;CACrB,CAAC;AAKF,MAAM,eAAe,GAAuB,CAAC,4BAAc,CAAC,CAAC;AAU7D,SAAgB,sBAAsB,CAAC,QAAwB;IAE9D,KAAK,MAAM,SAAS,IAAI,cAAc,EAAE,CAAC;QACxC,IAAI,CAAC;YACJ,QAAQ,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC;QAET,CAAC;IACF,CAAC;IAGD,KAAK,MAAM,OAAO,IAAI,qBAAqB,EAAE,CAAC;QAC7C,IAAI,CAAC;YACJ,QAAQ,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;QAC5C,CAAC;QAAC,MAAM,CAAC;QAET,CAAC;IACF,CAAC;IAGD,KAAK,MAAM,UAAU,IAAI,eAAe,EAAE,CAAC;QAC1C,IAAI,CAAC;YACJ,QAAQ,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;QACzC,CAAC;QAAC,MAAM,CAAC;QAET,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/workflow-builder/plugins/validators/filter-node-validator.d.ts

@@ -0,0 +1,2 @@
+import { type ValidatorPlugin } from '../types';
+export declare const filterNodeValidator: ValidatorPlugin;

package/dist/workflow-builder/plugins/validators/filter-node-validator.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterNodeValidator = void 0;
+const types_1 = require("../types");
+const FILTER_NODE_TYPES = ['n8n-nodes-base.if', 'n8n-nodes-base.switch', 'n8n-nodes-base.filter'];
+function validateFilterValue(filterValue, nodeRef, paramPath, nodeName, originalName) {
+    const issues = [];
+    if (!filterValue.options || typeof filterValue.options !== 'object') {
+        issues.push({
+            code: 'FILTER_MISSING_OPTIONS',
+            message: `${nodeRef} is missing 'options' in ${paramPath}. Add: options: { caseSensitive: true, leftValue: '', typeValidation: 'strict' }`,
+            severity: 'error',
+            nodeName,
+            originalName,
+            parameterPath: `${paramPath}.options`,
+        });
+    }
+    if (!Array.isArray(filterValue.conditions) || filterValue.conditions.length === 0) {
+        issues.push({
+            code: 'FILTER_MISSING_CONDITIONS',
+            message: `${nodeRef} is missing or has empty 'conditions' array in ${paramPath}. Add at least one condition with leftValue, operator, and rightValue.`,
+            severity: 'error',
+            nodeName,
+            originalName,
+            parameterPath: `${paramPath}.conditions`,
+        });
+    }
+    if (filterValue.combinator === undefined) {
+        issues.push({
+            code: 'FILTER_MISSING_COMBINATOR',
+            message: `${nodeRef} is missing 'combinator' in ${paramPath}. Add: combinator: 'and'`,
+            severity: 'error',
+            nodeName,
+            originalName,
+            parameterPath: `${paramPath}.combinator`,
+        });
+    }
+    return issues;
+}
+exports.filterNodeValidator = {
+    id: 'core:filter-node',
+    name: 'Filter Node Validator',
+    nodeTypes: FILTER_NODE_TYPES,
+    priority: 40,
+    validateNode(node, graphNode, ctx) {
+        const issues = [];
+        const params = node.config?.parameters;
+        if (!params)
+            return issues;
+        const mapKey = (0, types_1.findMapKey)(graphNode, ctx);
+        const originalName = node.name;
+        const renamed = (0, types_1.isAutoRenamed)(mapKey, originalName);
+        const displayName = renamed ? mapKey : originalName;
+        const origForWarning = renamed ? originalName : undefined;
+        const nodeRef = (0, types_1.formatNodeRef)(displayName, origForWarning, node.type);
+        const conditions = params.conditions;
+        if (conditions &&
+            typeof conditions === 'object' &&
+            ('conditions' in conditions || 'options' in conditions || 'combinator' in conditions)) {
+            issues.push(...validateFilterValue(conditions, nodeRef, 'conditions', displayName, origForWarning));
+        }
+        const rules = params.rules;
+        if (rules && typeof rules === 'object') {
+            if ('rules' in rules && !('values' in rules)) {
+                issues.push({
+                    code: 'SWITCH_WRONG_RULES_KEY',
+                    message: `${nodeRef} uses 'rules.rules' but the Switch node expects 'rules.values'. Rename the inner key from 'rules' to 'values'.`,
+                    severity: 'error',
+                    nodeName: displayName,
+                    originalName: origForWarning,
+                    parameterPath: 'rules',
+                });
+            }
+            const values = (rules.values ?? rules.rules);
+            if (Array.isArray(values)) {
+                for (let i = 0; i < values.length; i++) {
+                    const rule = values[i];
+                    const ruleConditions = rule?.conditions;
+                    if (ruleConditions &&
+                        typeof ruleConditions === 'object' &&
+                        'conditions' in ruleConditions) {
+                        issues.push(...validateFilterValue(ruleConditions, nodeRef, `rules.values[${i}].conditions`, displayName, origForWarning));
+                    }
+                }
+            }
+        }
+        return issues;
+    },
+};
+//# sourceMappingURL=filter-node-validator.js.map

package/dist/workflow-builder/plugins/validators/filter-node-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-node-validator.js","sourceRoot":"","sources":["../../../../src/workflow-builder/plugins/validators/filter-node-validator.ts"],"names":[],"mappings":"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"}

package/dist/workflow-builder/plugins/validators/index.d.ts

@@ -5,6 +5,7 @@ export { disconnectedNodeValidator } from './disconnected-node-validator';
 export { expressionPathValidator } from './expression-path-validator';
 export { subnodeConnectionValidator } from './subnode-connection-validator';
 export { expressionPrefixValidator } from './expression-prefix-validator';
+export { filterNodeValidator } from './filter-node-validator';
 export { fromAiValidator } from './from-ai-validator';
 export { httpRequestValidator } from './http-request-validator';
 export { maxNodesValidator } from './max-nodes-validator';

package/dist/workflow-builder/plugins/validators/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolNodeValidator = exports.setNodeValidator = exports.noNodesValidator = exports.missingTriggerValidator = exports.mergeNodeValidator = exports.maxNodesValidator = exports.httpRequestValidator = exports.fromAiValidator = exports.expressionPrefixValidator = exports.subnodeConnectionValidator = exports.expressionPathValidator = exports.disconnectedNodeValidator = exports.dateMethodValidator = exports.chainLlmValidator = exports.agentValidator = void 0;
+exports.toolNodeValidator = exports.setNodeValidator = exports.noNodesValidator = exports.missingTriggerValidator = exports.mergeNodeValidator = exports.maxNodesValidator = exports.httpRequestValidator = exports.fromAiValidator = exports.filterNodeValidator = exports.expressionPrefixValidator = exports.subnodeConnectionValidator = exports.expressionPathValidator = exports.disconnectedNodeValidator = exports.dateMethodValidator = exports.chainLlmValidator = exports.agentValidator = void 0;
 var agent_validator_1 = require("./agent-validator");
 Object.defineProperty(exports, "agentValidator", { enumerable: true, get: function () { return agent_validator_1.agentValidator; } });
 var chain_llm_validator_1 = require("./chain-llm-validator");
@@ -15,6 +15,8 @@ var subnode_connection_validator_1 = require("./subnode-connection-validator");
 Object.defineProperty(exports, "subnodeConnectionValidator", { enumerable: true, get: function () { return subnode_connection_validator_1.subnodeConnectionValidator; } });
 var expression_prefix_validator_1 = require("./expression-prefix-validator");
 Object.defineProperty(exports, "expressionPrefixValidator", { enumerable: true, get: function () { return expression_prefix_validator_1.expressionPrefixValidator; } });
+var filter_node_validator_1 = require("./filter-node-validator");
+Object.defineProperty(exports, "filterNodeValidator", { enumerable: true, get: function () { return filter_node_validator_1.filterNodeValidator; } });
 var from_ai_validator_1 = require("./from-ai-validator");
 Object.defineProperty(exports, "fromAiValidator", { enumerable: true, get: function () { return from_ai_validator_1.fromAiValidator; } });
 var http_request_validator_1 = require("./http-request-validator");

package/dist/workflow-builder/plugins/validators/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/workflow-builder/plugins/validators/index.ts"],"names":[],"mappings":";;;AAMA,qDAAmD;AAA1C,iHAAA,cAAc,OAAA;AACvB,6DAA0D;AAAjD,wHAAA,iBAAiB,OAAA;AAC1B,iEAA8D;AAArD,4HAAA,mBAAmB,OAAA;AAC5B,6EAA0E;AAAjE,wIAAA,yBAAyB,OAAA;AAClC,yEAAsE;AAA7D,oIAAA,uBAAuB,OAAA;AAChC,+EAA4E;AAAnE,0IAAA,0BAA0B,OAAA;AACnC,6EAA0E;AAAjE,wIAAA,yBAAyB,OAAA;AAClC,yDAAsD;AAA7C,oHAAA,eAAe,OAAA;AACxB,mEAAgE;AAAvD,8HAAA,oBAAoB,OAAA;AAC7B,6DAA0D;AAAjD,wHAAA,iBAAiB,OAAA;AAC1B,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA;AAC3B,yEAAsE;AAA7D,oIAAA,uBAAuB,OAAA;AAChC,2DAAwD;AAA/C,sHAAA,gBAAgB,OAAA;AACzB,2DAAwD;AAA/C,sHAAA,gBAAgB,OAAA;AACzB,6DAA0D;AAAjD,wHAAA,iBAAiB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/workflow-builder/plugins/validators/index.ts"],"names":[],"mappings":";;;AAMA,qDAAmD;AAA1C,iHAAA,cAAc,OAAA;AACvB,6DAA0D;AAAjD,wHAAA,iBAAiB,OAAA;AAC1B,iEAA8D;AAArD,4HAAA,mBAAmB,OAAA;AAC5B,6EAA0E;AAAjE,wIAAA,yBAAyB,OAAA;AAClC,yEAAsE;AAA7D,oIAAA,uBAAuB,OAAA;AAChC,+EAA4E;AAAnE,0IAAA,0BAA0B,OAAA;AACnC,6EAA0E;AAAjE,wIAAA,yBAAyB,OAAA;AAClC,iEAA8D;AAArD,4HAAA,mBAAmB,OAAA;AAC5B,yDAAsD;AAA7C,oHAAA,eAAe,OAAA;AACxB,mEAAgE;AAAvD,8HAAA,oBAAoB,OAAA;AAC7B,6DAA0D;AAAjD,wHAAA,iBAAiB,OAAA;AAC1B,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA;AAC3B,yEAAsE;AAA7D,oIAAA,uBAAuB,OAAA;AAChC,2DAAwD;AAA/C,sHAAA,gBAAgB,OAAA;AACzB,2DAAwD;AAA/C,sHAAA,gBAAgB,OAAA;AACzB,6DAA0D;AAAjD,wHAAA,iBAAiB,OAAA"}