@n8n/workflow-sdk 0.8.0 → 0.10.0

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/types/base.d.ts

@@ -24,6 +24,7 @@ export interface CredentialReference {
 export interface NewCredentialValue {
     readonly __newCredential: true;
     readonly name: string;
+    readonly id?: string;
 }
 export interface PlaceholderValue {
     readonly __placeholder: true;
@@ -69,6 +70,7 @@ export interface NodeJSON {
         id?: string;
         name: string;
     }>;
+    webhookId?: string;
     disabled?: boolean;
     notes?: string;
     notesInFlow?: boolean;
@@ -130,6 +132,7 @@ export interface NodeConfig<TParams = IDataObject> {
     credentials?: Record<string, CredentialReference | NewCredentialValue>;
     name?: string;
     position?: [number, number];
+    webhookId?: string;
     disabled?: boolean;
     notes?: string;
     notesInFlow?: boolean;
@@ -262,6 +265,9 @@ export interface SplitInBatchesBuilder<TOutput = unknown> {
 export interface GeneratePinDataOptions {
     beforeWorkflow?: WorkflowJSON;
 }
+export interface ToJSONOptions {
+    tidyUp?: boolean;
+}
 export interface WorkflowBuilder {
     readonly id: string;
     readonly name: string;
@@ -278,7 +284,7 @@ export interface WorkflowBuilder {
     connect(source: NodeInstance<string, string, unknown>, sourceOutput: number, target: NodeInstance<string, string, unknown>, targetInput: number): WorkflowBuilder;
     getNode(name: string): NodeInstance<string, string, unknown> | undefined;
     validate(options?: ValidationOptions): ValidationResult;
-    toJSON(): WorkflowJSON;
+    toJSON(options?: ToJSONOptions): WorkflowJSON;
     toFormat<T>(format: string): T;
     toString(): string;
     generatePinData(options?: GeneratePinDataOptions): WorkflowBuilder;
@@ -309,7 +315,7 @@ export type NodeFn = <TNode extends NodeInput>(input: TNode) => NodeInstance<TNo
 export type TriggerFn = <TTrigger extends TriggerInput>(input: TTrigger) => TriggerInstance<TTrigger['type'], `${TTrigger['version']}`, unknown>;
 export type StickyFn = (content: string, nodes?: Array<NodeInstance<string, string, unknown>>, config?: StickyNoteConfig) => NodeInstance<'n8n-nodes-base.stickyNote', 'v1', void>;
 export type PlaceholderFn = (hint: string) => PlaceholderValue;
-export type NewCredentialFn = (name: string) => NewCredentialValue;
+export type NewCredentialFn = (name: string, id?: string) => NewCredentialValue;
 export type IfElseFn = (branches: [
     NodeInstance<string, string, unknown> | null,
     NodeInstance<string, string, unknown> | null

package/dist/types/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/types/base.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/types/base.ts"],"names":[],"mappings":";;AAoKA,oDAqCC;AAUD,gDAQC;AAoUD,kCAWC;AAKD,wCAQC;AAnZD,SAAgB,oBAAoB,CAAC,WAAyB;IAC7D,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QACpD,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;gBAAE,SAAS;YACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACzC,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAY,CAAC;gBACnC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;oBAAE,SAAS;gBAEnC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE,CAAC;oBACxE,OAAO,CAAC,CAAC,CAAC,GAAG;wBACZ;4BACC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;4BACb,IAAI,EAAG,IAAI,CAAC,CAAC,CAAY,IAAI,MAAM;4BACnC,KAAK,EAAG,IAAI,CAAC,CAAC,CAAY,IAAI,CAAC;yBAC/B;qBACD,CAAC;gBACH,CAAC;YACF,CAAC;YACD,SAAS,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;QAC/B,CAAC;IACF,CAAC;IAID,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QACpD,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YAChD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;gBAAE,SAAS;YACtC,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;gBAC5B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;oBAAE,SAAS;gBACnC,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;oBACzB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;wBAC3E,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;oBAChB,CAAC;gBACF,CAAC;YACF,CAAC;QACF,CAAC;IACF,CAAC;AACF,CAAC;AAUD,SAAgB,kBAAkB,CAAC,QAAgB,EAAE,MAAiC;IACrF,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,UAAU,GAAG,GAAG,QAAQ,IAAI,OAAO,EAAE,CAAC;IAC1C,OAAO,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;QAC3B,OAAO,EAAE,CAAC;QACV,UAAU,GAAG,GAAG,QAAQ,IAAI,OAAO,EAAE,CAAC;IACvC,CAAC;IACD,OAAO,UAAU,CAAC;AACnB,CAAC;AAoUD,SAAgB,WAAW,CAC1B,KAAc;IAKd,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,CAAC,CAAC,UAAU,IAAI,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAEzC,MAAM,YAAY,GAAI,KAAiC,CAAC,QAAQ,CAAC;IACjE,OAAO,YAAY,KAAK,IAAI,CAAC;AAC9B,CAAC;AAKD,SAAgB,cAAc,CAAC,KAAc;IAC5C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,CAAC,CAAC,MAAM,IAAI,KAAK,IAAI,SAAS,IAAI,KAAK,IAAI,QAAQ,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;QACpF,OAAO,KAAK,CAAC;IACd,CAAC;IAED,MAAM,MAAM,GAAI,KAAiC,CAAC,EAAE,CAAC;IACrD,OAAO,OAAO,MAAM,KAAK,UAAU,CAAC;AACrC,CAAC"}

package/dist/workflow-builder/constants.d.ts

@@ -1,3 +1,16 @@
+export declare const GRID_SIZE = 16;
+export declare const DEFAULT_NODE_SIZE: [number, number];
+export declare const CONFIGURATION_NODE_RADIUS: number;
+export declare const CONFIGURATION_NODE_SIZE: [number, number];
+export declare const CONFIGURABLE_NODE_SIZE: [number, number];
+export declare const NODE_MIN_INPUT_ITEMS_COUNT = 4;
+export declare const NODE_X_SPACING: number;
+export declare const NODE_Y_SPACING: number;
+export declare const SUBGRAPH_SPACING: number;
+export declare const AI_X_SPACING: number;
+export declare const AI_Y_SPACING: number;
+export declare const STICKY_BOTTOM_PADDING: number;
+export declare const STICKY_NODE_TYPE = "n8n-nodes-base.stickyNote";
 export declare const NODE_SPACING_X = 200;
 export declare const DEFAULT_Y = 300;
 export declare const START_X = 100;

package/dist/workflow-builder/constants.js

@@ -1,6 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.START_X = exports.DEFAULT_Y = exports.NODE_SPACING_X = void 0;
+exports.START_X = exports.DEFAULT_Y = exports.NODE_SPACING_X = exports.STICKY_NODE_TYPE = exports.STICKY_BOTTOM_PADDING = exports.AI_Y_SPACING = exports.AI_X_SPACING = exports.SUBGRAPH_SPACING = exports.NODE_Y_SPACING = exports.NODE_X_SPACING = exports.NODE_MIN_INPUT_ITEMS_COUNT = exports.CONFIGURABLE_NODE_SIZE = exports.CONFIGURATION_NODE_SIZE = exports.CONFIGURATION_NODE_RADIUS = exports.DEFAULT_NODE_SIZE = exports.GRID_SIZE = void 0;
+exports.GRID_SIZE = 16;
+exports.DEFAULT_NODE_SIZE = [exports.GRID_SIZE * 6, exports.GRID_SIZE * 6];
+exports.CONFIGURATION_NODE_RADIUS = (exports.GRID_SIZE * 5) / 2;
+exports.CONFIGURATION_NODE_SIZE = [
+    exports.CONFIGURATION_NODE_RADIUS * 2,
+    exports.CONFIGURATION_NODE_RADIUS * 2,
+];
+exports.CONFIGURABLE_NODE_SIZE = [exports.GRID_SIZE * 16, exports.GRID_SIZE * 6];
+exports.NODE_MIN_INPUT_ITEMS_COUNT = 4;
+exports.NODE_X_SPACING = exports.GRID_SIZE * 8;
+exports.NODE_Y_SPACING = exports.GRID_SIZE * 6;
+exports.SUBGRAPH_SPACING = exports.GRID_SIZE * 8;
+exports.AI_X_SPACING = exports.GRID_SIZE * 3;
+exports.AI_Y_SPACING = exports.GRID_SIZE * 8;
+exports.STICKY_BOTTOM_PADDING = exports.GRID_SIZE * 4;
+exports.STICKY_NODE_TYPE = 'n8n-nodes-base.stickyNote';
 exports.NODE_SPACING_X = 200;
 exports.DEFAULT_Y = 300;
 exports.START_X = 100;

package/dist/workflow-builder/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/workflow-builder/constants.ts"],"names":[],"mappings":";;;AAOa,QAAA,cAAc,GAAG,GAAG,CAAC;AAKrB,QAAA,SAAS,GAAG,GAAG,CAAC;AAKhB,QAAA,OAAO,GAAG,GAAG,CAAC"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/workflow-builder/constants.ts"],"names":[],"mappings":";;;AAOa,QAAA,SAAS,GAAG,EAAE,CAAC;AAGf,QAAA,iBAAiB,GAAqB,CAAC,iBAAS,GAAG,CAAC,EAAE,iBAAS,GAAG,CAAC,CAAC,CAAC;AACrE,QAAA,yBAAyB,GAAG,CAAC,iBAAS,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;AAChD,QAAA,uBAAuB,GAAqB;IACxD,iCAAyB,GAAG,CAAC;IAC7B,iCAAyB,GAAG,CAAC;CAC7B,CAAC;AACW,QAAA,sBAAsB,GAAqB,CAAC,iBAAS,GAAG,EAAE,EAAE,iBAAS,GAAG,CAAC,CAAC,CAAC;AAC3E,QAAA,0BAA0B,GAAG,CAAC,CAAC;AAG/B,QAAA,cAAc,GAAG,iBAAS,GAAG,CAAC,CAAC;AAC/B,QAAA,cAAc,GAAG,iBAAS,GAAG,CAAC,CAAC;AAC/B,QAAA,gBAAgB,GAAG,iBAAS,GAAG,CAAC,CAAC;AACjC,QAAA,YAAY,GAAG,iBAAS,GAAG,CAAC,CAAC;AAC7B,QAAA,YAAY,GAAG,iBAAS,GAAG,CAAC,CAAC;AAC7B,QAAA,qBAAqB,GAAG,iBAAS,GAAG,CAAC,CAAC;AAEtC,QAAA,gBAAgB,GAAG,2BAA2B,CAAC;AAG/C,QAAA,cAAc,GAAG,GAAG,CAAC;AACrB,QAAA,SAAS,GAAG,GAAG,CAAC;AAChB,QAAA,OAAO,GAAG,GAAG,CAAC"}

package/dist/workflow-builder/layout-utils.d.ts

@@ -1,2 +1,8 @@
-import type { GraphNode } from '../types/base';
+import type { GraphNode, WorkflowJSON } from '../types/base';
 export declare function calculateNodePositions(nodes: ReadonlyMap<string, GraphNode>): Map<string, [number, number]>;
+export declare function getNodeDimensions(nodeName: string, aiParentNames: Set<string>, aiConfigNames: Set<string>, nodes: ReadonlyMap<string, GraphNode>): {
+    width: number;
+    height: number;
+};
+export declare function calculateNodePositionsDagre(nodes: ReadonlyMap<string, GraphNode>): Map<string, [number, number]>;
+export declare function layoutWorkflowJSON(json: WorkflowJSON): WorkflowJSON;