mirror of
https://github.com/czlonkowski/n8n-mcp.git
synced 2026-01-30 14:32:04 +00:00
Compare commits
2 Commits
v2.20.8
...
fix/memory
| Author | SHA1 | Date | |
|---|---|---|---|
|
14052b346e | ||
|
|
8f66964f0f |
746
CHANGELOG.md
746
CHANGELOG.md
@@ -5,752 +5,6 @@ All notable changes to this project will be documented in this file.
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
## [2.20.8] - 2025-10-22
|
||||
|
||||
### 🐛 Bug Fixes
|
||||
|
||||
**Sticky Notes Validation - Disconnected Node False Positives**
|
||||
|
||||
Fixed critical bug where sticky notes (UI-only annotation nodes) were incorrectly triggering "disconnected node" validation errors when updating workflows via MCP tools.
|
||||
|
||||
#### Problem
|
||||
- Workflows with sticky notes failed validation with "Node is disconnected" errors
|
||||
- `n8n_update_partial_workflow` and `n8n_update_full_workflow` tools blocked legitimate updates
|
||||
- Example error: "Validation Error: Node '📝 Webhook Trigger' is disconnected"
|
||||
- Sticky notes are UI-only annotations and should never trigger connection validation
|
||||
|
||||
#### Root Cause Analysis
|
||||
|
||||
**Inconsistent Validation Logic:**
|
||||
- `src/services/workflow-validator.ts` correctly excluded sticky notes using private `isStickyNote()` method
|
||||
- `src/services/n8n-validation.ts` lacked sticky note exclusion logic entirely
|
||||
- Code duplication led to divergent behavior between validators
|
||||
|
||||
**Missing Checks in n8n-validation.ts:**
|
||||
```typescript
|
||||
// BEFORE (Broken) - lines 246-257:
|
||||
const webhookTypes = new Set([
|
||||
'n8n-nodes-base.webhook',
|
||||
'n8n-nodes-base.webhookTrigger',
|
||||
'n8n-nodes-base.manualTrigger'
|
||||
]);
|
||||
// Only checked for webhooks, missed sticky notes entirely
|
||||
const disconnectedNodes = workflow.nodes.filter(node => {
|
||||
const isConnected = connectedNodes.has(node.name);
|
||||
const isTrigger = webhookTypes.has(node.type);
|
||||
// ...
|
||||
});
|
||||
```
|
||||
|
||||
#### Fixed
|
||||
|
||||
**1. Created Shared Utility Module** (`src/utils/node-classification.ts`)
|
||||
- Centralized node classification logic to ensure consistency
|
||||
- Four core functions:
|
||||
- `isStickyNote()`: Identifies all sticky note type variations
|
||||
- `isTriggerNode()`: Identifies trigger nodes (webhook, manual, cron, schedule)
|
||||
- `isNonExecutableNode()`: Identifies UI-only nodes
|
||||
- `requiresIncomingConnection()`: Determines if node needs incoming connections
|
||||
|
||||
**2. Updated n8n-validation.ts** (lines 198-259)
|
||||
- Added imports: `import { isNonExecutableNode, isTriggerNode } from '../utils/node-classification'`
|
||||
- Fixed disconnected nodes check to skip non-executable nodes:
|
||||
```typescript
|
||||
// AFTER (Fixed):
|
||||
const disconnectedNodes = workflow.nodes.filter(node => {
|
||||
// Skip non-executable nodes (sticky notes, etc.) - they're UI-only annotations
|
||||
if (isNonExecutableNode(node.type)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const isConnected = connectedNodes.has(node.name);
|
||||
const isTrigger = isTriggerNode(node.type);
|
||||
// ...
|
||||
});
|
||||
```
|
||||
- Added validation for workflows with only sticky notes
|
||||
- Fixed multi-node connection check to exclude sticky notes when counting executable nodes
|
||||
|
||||
**3. Updated workflow-validator.ts** (8 locations)
|
||||
- Removed private `isStickyNote()` method
|
||||
- Replaced all calls with `isNonExecutableNode()` from shared utilities
|
||||
- Eliminates code duplication
|
||||
|
||||
#### Testing
|
||||
|
||||
**New Test Files:**
|
||||
- `tests/unit/utils/node-classification.test.ts`: 44 tests, 100% coverage
|
||||
- Tests all classification functions
|
||||
- Tests all sticky note type variations
|
||||
- Tests trigger node identification
|
||||
- Integration scenarios
|
||||
|
||||
- `tests/unit/services/n8n-validation-sticky-notes.test.ts`: 10 comprehensive tests
|
||||
- Workflows with sticky notes and connected functional nodes
|
||||
- Multiple sticky notes (10+ notes)
|
||||
- All sticky note type variations
|
||||
- Complex real-world scenarios (simulates POST /auth/login workflow)
|
||||
- Detection of truly disconnected functional nodes
|
||||
- Regression tests matching n8n UI behavior
|
||||
|
||||
**Updated Test Files:**
|
||||
- `tests/unit/validation-fixes.test.ts`: Updated terminology to reflect shared utilities
|
||||
|
||||
**Test Results:**
|
||||
- All 54 new tests passing
|
||||
- 100% coverage on node-classification utilities
|
||||
- Zero regressions in existing test suite
|
||||
|
||||
#### Impact
|
||||
|
||||
**Workflow Updates:**
|
||||
- ✅ Sticky notes no longer block workflow updates
|
||||
- ✅ `n8n_update_partial_workflow` works correctly with annotated workflows
|
||||
- ✅ `n8n_update_full_workflow` accepts workflows with documentation notes
|
||||
- ✅ Matches n8n UI behavior exactly
|
||||
|
||||
**Code Quality:**
|
||||
- ✅ Eliminated code duplication between validators
|
||||
- ✅ Centralized node classification logic
|
||||
- ✅ Future node types can be added in one place
|
||||
- ✅ Consistent behavior across all validation paths
|
||||
|
||||
**Node Type Support:**
|
||||
- ✅ Handles all sticky note variations: `n8n-nodes-base.stickyNote`, `nodes-base.stickyNote`, `@n8n/n8n-nodes-base.stickyNote`
|
||||
- ✅ Proper trigger node detection: webhook, webhookTrigger, manualTrigger, cronTrigger, scheduleTrigger
|
||||
- ✅ Correct connection requirements for all node types
|
||||
|
||||
**Backward Compatibility:**
|
||||
- ✅ No breaking changes
|
||||
- ✅ All existing validations continue to work
|
||||
- ✅ API remains unchanged
|
||||
|
||||
Concieved by Romuald Członkowski - [www.aiadvisors.pl/en](https://www.aiadvisors.pl/en)
|
||||
|
||||
## [2.20.7] - 2025-10-22
|
||||
|
||||
### 🔄 Dependencies
|
||||
|
||||
**Updated n8n to v1.116.2**
|
||||
|
||||
Updated all n8n dependencies to the latest compatible versions:
|
||||
- `n8n`: 1.115.2 → 1.116.2
|
||||
- `n8n-core`: 1.114.0 → 1.115.1
|
||||
- `n8n-workflow`: 1.112.0 → 1.113.0
|
||||
- `@n8n/n8n-nodes-langchain`: 1.114.1 → 1.115.1
|
||||
|
||||
**Database Rebuild:**
|
||||
- Rebuilt node database with 542 nodes from updated n8n packages
|
||||
- All 542 nodes loaded successfully from both n8n-nodes-base (439 nodes) and @n8n/n8n-nodes-langchain (103 nodes)
|
||||
- Documentation mapping completed for all nodes
|
||||
|
||||
**Testing:**
|
||||
- Changes validated in CI/CD pipeline with full test suite (705 tests)
|
||||
- Critical nodes validated: httpRequest, code, slack, agent
|
||||
|
||||
### 🐛 Bug Fixes
|
||||
|
||||
**FTS5 Search Ranking - Exact Match Prioritization**
|
||||
|
||||
Fixed critical bug in production search where exact matches weren't appearing first in search results.
|
||||
|
||||
#### Problem
|
||||
- SQL ORDER BY clause was `ORDER BY rank, CASE ... END` (wrong order)
|
||||
- FTS5 rank sorted first, CASE statement only acted as tiebreaker
|
||||
- Since FTS5 ranks are always unique, CASE boosting never applied
|
||||
- Additionally, CASE used case-sensitive comparison failing to match nodes like "Webhook" when searching "webhook"
|
||||
- Result: Searching "webhook" returned "Webflow Trigger" first, actual "Webhook" node ranked 4th
|
||||
|
||||
#### Root Cause Analysis
|
||||
**SQL Ordering Issue:**
|
||||
```sql
|
||||
-- BEFORE (Broken):
|
||||
ORDER BY rank, CASE ... END -- rank first, CASE never used
|
||||
-- Result: webhook ranks 4th (-9.64 rank)
|
||||
-- Top 3: webflowTrigger (-10.20), vonage (-10.09), renameKeys (-10.01)
|
||||
|
||||
-- AFTER (Fixed):
|
||||
ORDER BY CASE ... END, rank -- CASE first, exact matches prioritized
|
||||
-- Result: webhook ranks 1st (CASE priority 0)
|
||||
```
|
||||
|
||||
**Case-Sensitivity Issue:**
|
||||
- Old: `WHEN n.display_name = ?` (case-sensitive, fails on "Webhook" vs "webhook")
|
||||
- New: `WHEN LOWER(n.display_name) = LOWER(?)` (case-insensitive, matches correctly)
|
||||
|
||||
#### Fixed
|
||||
|
||||
**1. Production Code** (`src/mcp/server.ts` lines 1278-1295)
|
||||
- Changed ORDER BY from: `rank, CASE ... END`
|
||||
- To: `CASE WHEN LOWER(n.display_name) = LOWER(?) ... END, rank`
|
||||
- Added case-insensitive comparison with LOWER() function
|
||||
- Exact matches now consistently appear first in search results
|
||||
|
||||
**2. Test Files Updated**
|
||||
- `tests/integration/database/node-fts5-search.test.ts` (lines 137-160)
|
||||
- `tests/integration/ci/database-population.test.ts` (lines 206-234)
|
||||
- Both updated to match corrected SQL logic with case-insensitive comparison
|
||||
- Tests now accurately validate production search behavior
|
||||
|
||||
#### Impact
|
||||
|
||||
**Search Quality:**
|
||||
- ✅ Exact matches now always rank first (webhook, http, code, etc.)
|
||||
- ✅ Case-insensitive matching works correctly (Webhook = webhook = WEBHOOK)
|
||||
- ✅ Better user experience - predictable search results
|
||||
- ✅ SQL query more efficient (correct ordering at database level)
|
||||
|
||||
**Performance:**
|
||||
- Same or better performance (less JavaScript sorting needed)
|
||||
- Database does the heavy lifting with correct ORDER BY
|
||||
- JavaScript sorting still provides additional relevance refinement
|
||||
|
||||
**Testing:**
|
||||
- All 705 tests passing (703 passed + 2 fixed)
|
||||
- Comprehensive testing by n8n-mcp-tester agent
|
||||
- Code review approved with minor optimization suggestions for future
|
||||
|
||||
**Verified Search Results:**
|
||||
- "webhook" → nodes-base.webhook (1st)
|
||||
- "http" → nodes-base.httpRequest (1st)
|
||||
- "code" → nodes-base.code (1st)
|
||||
- "slack" → nodes-base.slack (1st)
|
||||
- All case variations work correctly (WEBHOOK, Webhook, webhook)
|
||||
|
||||
## [2.20.6] - 2025-10-21
|
||||
|
||||
### 🐛 Bug Fixes
|
||||
|
||||
**Issue #342: Missing `tslib` Dependency Causing MODULE_NOT_FOUND on Windows**
|
||||
|
||||
Fixed critical dependency issue where `tslib` was missing from the published npm package, causing immediate failure when users ran `npx n8n-mcp@latest` on Windows (and potentially other platforms).
|
||||
|
||||
#### Problem
|
||||
|
||||
Users installing via `npx n8n-mcp@latest` experienced MODULE_NOT_FOUND errors:
|
||||
```
|
||||
Error: Cannot find module 'tslib'
|
||||
Require stack:
|
||||
- node_modules/@supabase/functions-js/dist/main/FunctionsClient.js
|
||||
- node_modules/@supabase/supabase-js/dist/main/index.js
|
||||
- node_modules/n8n-mcp/dist/telemetry/telemetry-manager.js
|
||||
```
|
||||
|
||||
**Root Cause Analysis:**
|
||||
- `@supabase/supabase-js` depends on `@supabase/functions-js` which requires `tslib` at runtime
|
||||
- `tslib` was NOT explicitly listed in `package.runtime.json` dependencies
|
||||
- The publish script (`scripts/publish-npm.sh`) copies `package.runtime.json` → `package.json` before publishing to npm
|
||||
- CI/CD workflow (`.github/workflows/release.yml` line 329) does the same: `cp package.runtime.json $PUBLISH_DIR/package.json`
|
||||
- Result: Published npm package had no `tslib` dependency
|
||||
- When users installed via `npx`, npm didn't install `tslib` → MODULE_NOT_FOUND error
|
||||
|
||||
**Why It Worked Locally:**
|
||||
- Local development uses main `package.json` which has full n8n package dependencies
|
||||
- `tslib` existed as a transitive dependency through AWS SDK packages
|
||||
- npm's hoisting made it available locally
|
||||
|
||||
**Why It Failed in Production:**
|
||||
- `npx` installations use the published package (which comes from `package.runtime.json`)
|
||||
- No transitive path to `tslib` in the minimal runtime dependencies
|
||||
- npm's dependency resolution on Windows didn't hoist it properly
|
||||
|
||||
**Why Docker Worked:**
|
||||
- Docker builds used `package-lock.json` which included all transitive dependencies
|
||||
- Or the base image already had `tslib` installed
|
||||
|
||||
#### Fixed
|
||||
|
||||
**1. Added `tslib` to Runtime Dependencies**
|
||||
- Added `"tslib": "^2.6.2"` to `package.runtime.json` dependencies (line 14)
|
||||
- This is the **critical fix** since `package.runtime.json` gets published to npm
|
||||
- Version `^2.6.2` matches existing transitive dependency versions
|
||||
|
||||
**2. Added `tslib` to Development Dependencies**
|
||||
- Added `"tslib": "^2.6.2"` to `package.json` dependencies (line 154)
|
||||
- Ensures consistency between development and production
|
||||
- Prevents confusion for developers
|
||||
|
||||
**3. Synced `package.runtime.json` Version**
|
||||
- Updated `package.runtime.json` version from `2.20.2` to `2.20.5`
|
||||
- Keeps runtime package version in sync with main package version
|
||||
|
||||
#### Technical Details
|
||||
|
||||
**Dependency Chain:**
|
||||
```
|
||||
n8n-mcp
|
||||
└── @supabase/supabase-js@2.57.4
|
||||
└── @supabase/functions-js@2.4.6
|
||||
└── tslib (MISSING) ❌
|
||||
```
|
||||
|
||||
**Publish Process:**
|
||||
```bash
|
||||
# CI/CD workflow (.github/workflows/release.yml:329)
|
||||
cp package.runtime.json $PUBLISH_DIR/package.json
|
||||
npm publish --access public
|
||||
|
||||
# Users install via npx
|
||||
npx n8n-mcp@latest
|
||||
# → Gets dependencies from package.runtime.json (now includes tslib ✅)
|
||||
```
|
||||
|
||||
**Files Modified:**
|
||||
- `package.json` line 154: Added `tslib: "^2.6.2"`
|
||||
- `package.runtime.json` line 14: Added `tslib: "^2.6.2"` (critical fix)
|
||||
- `package.runtime.json` line 3: Updated version `2.20.2` → `2.20.5`
|
||||
|
||||
#### Impact
|
||||
|
||||
**Before Fix:**
|
||||
- ❌ Package completely broken on Windows for `npx` users
|
||||
- ❌ Affected all platforms using `npx` (not just Windows)
|
||||
- ❌ 100% failure rate on fresh installations
|
||||
- ❌ Workaround: Use v2.19.6 or install with `npm install` + run locally
|
||||
|
||||
**After Fix:**
|
||||
- ✅ `npx n8n-mcp@latest` works on all platforms
|
||||
- ✅ `tslib` guaranteed to be installed with the package
|
||||
- ✅ No breaking changes (adding a dependency that was already in transitive tree)
|
||||
- ✅ Consistent behavior across Windows, macOS, Linux
|
||||
|
||||
#### Verification
|
||||
|
||||
**Build & Tests:**
|
||||
- ✅ TypeScript compilation passes
|
||||
- ✅ Type checking passes (`npm run typecheck`)
|
||||
- ✅ All tests pass
|
||||
- ✅ Build succeeds (`npm run build`)
|
||||
|
||||
**CI/CD Validation:**
|
||||
- ✅ Verified CI workflow copies `package.runtime.json` → `package.json` before publish
|
||||
- ✅ Confirmed `tslib` will be included in published package
|
||||
- ✅ No changes needed to CI/CD workflows
|
||||
|
||||
#### Related
|
||||
|
||||
- **Issue:** #342 - Missing `tslib` dependency in v2.20.3 causing MODULE_NOT_FOUND error on Windows
|
||||
- **Reporter:** @eddyc (thank you for the detailed bug report!)
|
||||
- **Severity:** CRITICAL - Package unusable via `npx` on Windows
|
||||
- **Affected Versions:** 2.20.0 - 2.20.5
|
||||
- **Fixed Version:** 2.20.6
|
||||
|
||||
Conceived by Romuald Członkowski - [www.aiadvisors.pl/en](https://www.aiadvisors.pl/en)
|
||||
|
||||
## [2.20.5] - 2025-10-21
|
||||
|
||||
### 🐛 Bug Fixes
|
||||
|
||||
**Validation False Positives Eliminated (80% → 0%)**
|
||||
|
||||
This release completely eliminates validation false positives on production workflows through comprehensive improvements to expression detection, webhook validation, and validation profile handling.
|
||||
|
||||
#### Problem Statement
|
||||
|
||||
Production workflows were experiencing an 80% false positive rate during validation:
|
||||
- Expression-based URLs flagged as invalid (e.g., `={{ $json.protocol }}://{{ $json.domain }}/api`)
|
||||
- Expression-based JSON flagged as invalid (e.g., `={{ { key: $json.value } }}`)
|
||||
- Webhook `onError` validation checking wrong property location (node-level vs parameters)
|
||||
- "Missing $ prefix" regex flagging valid property access (e.g., `item['json']`)
|
||||
- `respondToWebhook` nodes incorrectly warned about missing error handling
|
||||
- Hardcoded credential warnings appearing in all validation profiles
|
||||
|
||||
#### Solution Overview
|
||||
|
||||
**Phase 1: Centralized Expression Detection**
|
||||
- Created `src/utils/expression-utils.ts` with 5 core utilities:
|
||||
- `isExpression()`: Type predicate detecting `=` prefix
|
||||
- `containsExpression()`: Detects `{{ }}` markers (optimized with single regex)
|
||||
- `shouldSkipLiteralValidation()`: Main decision utility for validators
|
||||
- `extractExpressionContent()`: Extracts expression code
|
||||
- `hasMixedContent()`: Detects mixed text+expression patterns
|
||||
- Added comprehensive test suite with 75 tests (100% statement coverage)
|
||||
|
||||
**Phase 2: URL and JSON Validation Fixes**
|
||||
- Modified `config-validator.ts` to skip expression validation:
|
||||
- URL validation: Skip when `shouldSkipLiteralValidation()` returns true (lines 385-397)
|
||||
- JSON validation: Skip when value contains expressions (lines 424-439)
|
||||
- Improved error messages to include actual JSON parse errors
|
||||
|
||||
**Phase 3: Webhook Validation Improvements**
|
||||
- Fixed `onError` property location check in `workflow-validator.ts`:
|
||||
- Now checks node-level `onError` property, not `parameters.onError`
|
||||
- Added context-aware validation for webhook response modes
|
||||
- Created specialized `checkWebhookErrorHandling()` helper method (lines 1618-1662):
|
||||
- Skips validation for `respondToWebhook` nodes (response nodes)
|
||||
- Requires `onError` for `responseNode` mode
|
||||
- Provides warnings for regular webhook nodes
|
||||
- Moved responseNode validation from `node-specific-validators.ts` to `workflow-validator.ts`
|
||||
|
||||
**Phase 4: Regex Pattern Enhancement**
|
||||
- Updated missing prefix pattern in `expression-validator.ts` (line 217):
|
||||
- Old: `/(?<!\$|\.)\b(json|node)\b/`
|
||||
- New: `/(?<![.$\w['])\b(json|node|input|items|workflow|execution)\b(?!\s*[:''])/`
|
||||
- Now correctly excludes:
|
||||
- Dollar prefix: `$json` ✓
|
||||
- Dot access: `.json` ✓
|
||||
- Word chars: `myJson` ✓
|
||||
- Bracket notation: `item['json']` ✓
|
||||
- After quotes: `"json"` ✓
|
||||
|
||||
**Phase 5: Profile-Based Filtering**
|
||||
- Made hardcoded credential warnings configurable in `enhanced-config-validator.ts`:
|
||||
- Created `shouldFilterCredentialWarning()` helper method (lines 469-476)
|
||||
- Only show hardcoded credential warnings in `strict` profile
|
||||
- Filters warnings in `minimal`, `runtime`, and `ai-friendly` profiles
|
||||
- Replaced 3 instances of duplicate filtering code (lines 492, 510, 539)
|
||||
|
||||
**Phase 6: Code Quality Improvements**
|
||||
- Fixed type guard order in `hasMixedContent()` (line 90)
|
||||
- Added type predicate to `isExpression()` for better TypeScript narrowing
|
||||
- Extracted helper methods to reduce code duplication
|
||||
- Improved error messages with actual parsing details
|
||||
|
||||
**Phase 7: Comprehensive Testing**
|
||||
- Created `tests/unit/utils/expression-utils.test.ts` with 75 tests:
|
||||
- `isExpression()`: 18 tests (valid, invalid, edge cases, type narrowing)
|
||||
- `containsExpression()`: 14 tests (markers, edge cases)
|
||||
- `shouldSkipLiteralValidation()`: 12 tests (skip conditions, real-world)
|
||||
- `extractExpressionContent()`: 11 tests (extraction, edge cases)
|
||||
- `hasMixedContent()`: 19 tests (mixed content, type guards)
|
||||
- Integration scenarios: 4 tests (real workflow scenarios)
|
||||
- Performance test: 10k iterations in <100ms
|
||||
- Fixed CI test failure by skipping moved validation tests in `node-specific-validators.test.ts`
|
||||
|
||||
#### Results
|
||||
|
||||
**Validation Accuracy:**
|
||||
- Total Errors: 16 → 0 (100% elimination)
|
||||
- Total Warnings: 45 → 27 (40% reduction)
|
||||
- Valid Workflows: 0/6 → 6/6 (100% success rate)
|
||||
- False Positive Rate: 80% → 0%
|
||||
|
||||
**Test Coverage:**
|
||||
- New tests: 75 comprehensive test cases
|
||||
- Statement coverage: 100%
|
||||
- Line coverage: 100%
|
||||
- Branch coverage: 95.23%
|
||||
- All 143 tests passing ✓
|
||||
|
||||
**Files Changed:**
|
||||
- Modified: 7 files
|
||||
- `src/services/config-validator.ts`
|
||||
- `src/services/enhanced-config-validator.ts`
|
||||
- `src/services/expression-validator.ts`
|
||||
- `src/services/workflow-validator.ts`
|
||||
- `src/services/node-specific-validators.ts`
|
||||
- `tests/unit/services/node-specific-validators.test.ts`
|
||||
- Created: 2 files
|
||||
- `src/utils/expression-utils.ts`
|
||||
- `tests/unit/utils/expression-utils.test.ts`
|
||||
|
||||
**Code Review:**
|
||||
- ✅ READY TO MERGE
|
||||
- All phases implemented with critical warnings and suggestions addressed
|
||||
- Type safety improved with type predicates
|
||||
- Code duplication eliminated with helper methods
|
||||
- Comprehensive test coverage with real-world scenarios
|
||||
|
||||
**Related:**
|
||||
- PR #346
|
||||
- Branch: `feat/sticky-note-validation`
|
||||
|
||||
Conceived by Romuald Członkowski - [www.aiadvisors.pl/en](https://www.aiadvisors.pl/en)
|
||||
|
||||
## [2.20.4] - 2025-10-21
|
||||
|
||||
### 🛡️ Safety & Reliability Enhancements
|
||||
|
||||
**HTTP Server Validation Tools - Enhanced Safety Features (builds on PR #343)**
|
||||
|
||||
This release adds defensive safety measures to the HTTP server validation tools response handling, preventing potential memory issues and improving code quality.
|
||||
|
||||
#### Building on PR #343
|
||||
|
||||
PR #343 (merged 2025-10-21) successfully fixed the MCP protocol error -32600 by adding the required `structuredContent` field for validation tools via HTTP transport. This release enhances that fix with additional safety features to match STDIO server behavior.
|
||||
|
||||
#### Added
|
||||
|
||||
**1. TypeScript Interface for Type Safety**
|
||||
- Added `MCPToolResponse` interface (src/http-server.ts:26-35)
|
||||
- Replaced `any` type with proper interface for response objects
|
||||
- Improves IDE autocomplete, catches type errors at compile time
|
||||
- Better code maintainability and refactoring safety
|
||||
|
||||
**2. 1MB Response Size Validation**
|
||||
- Implements size check before adding `structuredContent` (src/http-server.ts:434-449)
|
||||
- Prevents memory exhaustion and potential DoS attacks
|
||||
- Matches STDIO server behavior (src/mcp/server.ts:515-520)
|
||||
- **Logic:**
|
||||
- Check response size: `responseText.length`
|
||||
- If > 1MB: Truncate and skip structuredContent
|
||||
- If <= 1MB: Include structuredContent (normal case)
|
||||
|
||||
**3. Warning Logs for Large Responses**
|
||||
- Logs warnings when validation responses exceed 1MB (src/http-server.ts:438-442)
|
||||
- Includes actual size in logs for debugging
|
||||
- Helps identify performance issues and potential problems
|
||||
- **Example:** `Validation tool validate_workflow response is very large (1500000 chars). Truncating for HTTP transport safety.`
|
||||
|
||||
**4. Response Truncation for Safety**
|
||||
- Truncates responses larger than 1MB to 999KB + message (src/http-server.ts:443-444)
|
||||
- Prevents HTTP transport issues with very large payloads
|
||||
- Ensures client stability even with pathological inputs
|
||||
- **Message:** `[Response truncated due to size limits]`
|
||||
|
||||
#### Technical Details
|
||||
|
||||
**Size Validation Flow:**
|
||||
```typescript
|
||||
// 1. Convert result to JSON
|
||||
let responseText = JSON.stringify(result, null, 2);
|
||||
|
||||
// 2. Check size for validation tools
|
||||
if (toolName.startsWith('validate_')) {
|
||||
const resultSize = responseText.length;
|
||||
|
||||
// 3. Apply 1MB limit
|
||||
if (resultSize > 1000000) {
|
||||
// Large response: truncate and warn
|
||||
logger.warn(`Validation tool ${toolName} response is very large...`);
|
||||
mcpResult.content[0].text = responseText.substring(0, 999000) +
|
||||
'\n\n[Response truncated due to size limits]';
|
||||
// Don't include structuredContent
|
||||
} else {
|
||||
// Normal case: include structured content
|
||||
mcpResult.structuredContent = result;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**STDIO Parity:**
|
||||
- HTTP server now matches STDIO server safety features
|
||||
- Same 1MB limit (STDIO: src/mcp/server.ts:516)
|
||||
- Same truncation behavior
|
||||
- Same warning logs (STDIO: src/mcp/server.ts:517)
|
||||
- **Result:** Consistent behavior across both transports
|
||||
|
||||
#### Benefits
|
||||
|
||||
1. **Prevents DoS Attacks** - Size limits prevent malicious large responses from exhausting memory
|
||||
2. **Improves HTTP Transport Stability** - Truncation prevents transport layer issues
|
||||
3. **Better Observability** - Warning logs help identify and debug problems
|
||||
4. **Type Safety** - Interface prevents type-related bugs during development
|
||||
5. **Full STDIO Parity** - Consistent safety features across all transports
|
||||
|
||||
#### Impact
|
||||
|
||||
- **Risk Level:** LOW (only adds safety checks, no logic changes)
|
||||
- **Breaking Changes:** NONE (backward compatible, only adds truncation for edge cases)
|
||||
- **Performance Impact:** Negligible (single length check: O(1))
|
||||
- **Memory Safety:** Significantly improved (prevents unbounded growth)
|
||||
|
||||
#### Testing
|
||||
|
||||
- ✅ TypeScript compilation passes
|
||||
- ✅ Type checking passes (`npm run typecheck`)
|
||||
- ✅ Build succeeds (`npm run build`)
|
||||
- ✅ No breaking changes to existing functionality
|
||||
- ✅ All HTTP validation tools continue working normally
|
||||
|
||||
#### Documentation
|
||||
|
||||
**New Documentation:**
|
||||
- `docs/CI_TEST_INFRASTRUCTURE.md` - Documents known CI test infrastructure issues
|
||||
- Explains why external contributor PRs have integration test failures
|
||||
- Clarifies that these are infrastructure issues, not code quality issues
|
||||
- Provides workarounds and testing strategies
|
||||
- References PR #343 as example
|
||||
|
||||
**Why CI Tests Fail for External PRs:**
|
||||
- GitHub Actions doesn't expose secrets to external contributor PRs (security)
|
||||
- MSW (Mock Service Worker) doesn't intercept requests properly in CI
|
||||
- Integration tests expect mock n8n server that isn't responding
|
||||
- **NOT a code quality issue** - the actual code changes are correct
|
||||
- Local tests work fine, CI infrastructure needs separate fix
|
||||
|
||||
#### Related
|
||||
|
||||
- **Builds on:** PR #343 - fix: add structuredContent to HTTP wrapper for validation tools
|
||||
- **Fixes:** None (enhancement only)
|
||||
- **References:** MCP protocol specification for tools with outputSchema
|
||||
- **CI Issue:** External PR integration test failures documented (infrastructure issue)
|
||||
|
||||
#### Files Changed
|
||||
|
||||
**Code (1 file):**
|
||||
- `src/http-server.ts` - Enhanced with safety features (interface, size validation, logging)
|
||||
|
||||
**Documentation (1 file):**
|
||||
- `docs/CI_TEST_INFRASTRUCTURE.md` - Documents CI test infrastructure known issues (NEW)
|
||||
|
||||
**Configuration (1 file):**
|
||||
- `package.json` - Version bump to 2.20.4
|
||||
|
||||
---
|
||||
|
||||
## [2.20.3] - 2025-10-19
|
||||
|
||||
### 🔍 Enhanced Error Messages & Documentation
|
||||
|
||||
**Issue #331: Enhanced Workflow Validation Error Messages**
|
||||
|
||||
Significantly improved error messages and recovery guidance for workflow validation failures, making it easier for AI agents to diagnose and fix workflow issues.
|
||||
|
||||
#### Problem
|
||||
|
||||
When workflow validation failed after applying diff operations, error messages were generic and unhelpful:
|
||||
- Simple "Workflow validation failed after applying operations" message
|
||||
- No categorization of error types
|
||||
- No recovery guidance for AI agents
|
||||
- Difficult to understand what went wrong and how to fix it
|
||||
|
||||
#### Fixed
|
||||
|
||||
**1. Enhanced Error Messages (handlers-workflow-diff.ts:130-193)**
|
||||
- **Error Categorization**: Analyzes errors and categorizes them by type (operator issues, connection issues, missing metadata, branch mismatches)
|
||||
- **Targeted Recovery Guidance**: Provides specific, actionable steps based on error type
|
||||
- **Clear Error Messages**: Shows single error or count with detailed context
|
||||
- **Auto-Sanitization Notes**: Explains what auto-sanitization can and cannot fix
|
||||
|
||||
**Example Error Response**:
|
||||
```json
|
||||
{
|
||||
"success": false,
|
||||
"error": "Workflow validation failed: Disconnected nodes detected: \"Node Name\" (node-type)",
|
||||
"details": {
|
||||
"errors": ["Disconnected nodes detected..."],
|
||||
"errorCount": 1,
|
||||
"recoveryGuidance": [
|
||||
"Connection validation failed. Check all node connections reference existing nodes.",
|
||||
"Use cleanStaleConnections operation to remove connections to non-existent nodes."
|
||||
],
|
||||
"note": "Operations were applied but workflow was NOT saved to prevent UI errors.",
|
||||
"autoSanitizationNote": "Auto-sanitization runs on all nodes to fix operators/metadata..."
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**2. Comprehensive Documentation Updates**
|
||||
|
||||
Updated 4 tool documentation files to explain auto-sanitization system:
|
||||
|
||||
- **n8n-update-partial-workflow.ts**: Added comprehensive "Auto-Sanitization System" section
|
||||
- Explains what gets auto-fixed (operator structures, missing metadata)
|
||||
- Describes sanitization scope (runs on ALL nodes)
|
||||
- Lists limitations (cannot fix broken connections, branch mismatches)
|
||||
- Provides recovery guidance for issues beyond auto-sanitization
|
||||
|
||||
- **n8n-create-workflow.ts**: Added tips and pitfalls about auto-sanitization during workflow creation
|
||||
|
||||
- **validate-node-operation.ts**: Added guidance for IF/Switch operator validation
|
||||
- Binary vs unary operator rules
|
||||
- conditions.options metadata requirements
|
||||
- Operator type field usage
|
||||
|
||||
- **validate-workflow.ts**: Added best practices about auto-sanitization and validation
|
||||
|
||||
#### Impact
|
||||
|
||||
**AI Agent Experience**:
|
||||
- ✅ **Clear Error Messages**: Specific errors with exact problem identification
|
||||
- ✅ **Actionable Recovery**: Step-by-step guidance to fix issues
|
||||
- ✅ **Error Categorization**: Understand error type immediately
|
||||
- ✅ **Example Code**: Error responses include fix suggestions with code snippets
|
||||
|
||||
**Documentation Quality**:
|
||||
- ✅ **Comprehensive**: Auto-sanitization system fully documented
|
||||
- ✅ **Accurate**: All technical claims verified by tests
|
||||
- ✅ **Helpful**: Clear explanations of what can/cannot be auto-fixed
|
||||
|
||||
**Error Response Structure**:
|
||||
- `details.errors` - Array of specific error messages
|
||||
- `details.errorCount` - Number of errors found
|
||||
- `details.recoveryGuidance` - Actionable steps to fix issues
|
||||
- `details.note` - Explanation of what happened
|
||||
- `details.autoSanitizationNote` - Auto-sanitization limitations
|
||||
|
||||
#### Testing
|
||||
|
||||
- ✅ All 26 update-partial-workflow tests passing
|
||||
- ✅ All 14 node-sanitizer tests passing
|
||||
- ✅ Backward compatibility maintained (details.errors field preserved)
|
||||
- ✅ Integration tested with n8n-mcp-tester agent
|
||||
- ✅ Code review approved (no critical issues)
|
||||
|
||||
#### Files Changed
|
||||
|
||||
**Code (1 file)**:
|
||||
- `src/mcp/handlers-workflow-diff.ts` - Enhanced error messages with categorization and recovery guidance
|
||||
|
||||
**Documentation (4 files)**:
|
||||
- `src/mcp/tool-docs/workflow_management/n8n-update-partial-workflow.ts` - Auto-sanitization section
|
||||
- `src/mcp/tool-docs/workflow_management/n8n-create-workflow.ts` - Auto-sanitization tips
|
||||
- `src/mcp/tool-docs/validation/validate-node-operation.ts` - Operator validation guidance
|
||||
- `src/mcp/tool-docs/validation/validate-workflow.ts` - Auto-sanitization best practices
|
||||
|
||||
---
|
||||
|
||||
## [2.20.2] - 2025-10-18
|
||||
|
||||
### 🐛 Bug Fixes
|
||||
|
||||
**Issue #331: Prevent Broken Workflows via Partial Updates (Enhanced)**
|
||||
|
||||
Fixed critical issue where `n8n_update_partial_workflow` could create corrupted workflows that n8n API accepts but UI cannot render. **Enhanced validation to detect ALL disconnected nodes**, not just workflows with zero connections.
|
||||
|
||||
#### Problem
|
||||
- Partial workflow updates validated individual operations but not final workflow structure
|
||||
- Users could inadvertently create invalid workflows:
|
||||
- Multi-node workflows with no connections
|
||||
- Single non-webhook node workflows
|
||||
- **Disconnected nodes when building incrementally** (original fix missed this)
|
||||
- Workflows with broken connection graphs
|
||||
- Result: Workflows existed in API but showed "Workflow not found" in UI
|
||||
|
||||
#### Solution (Two-Phase Fix)
|
||||
|
||||
**Phase 1 - Basic Validation**:
|
||||
- ✅ Added final workflow structure validation after applying all diff operations
|
||||
- ✅ Improved error messages with actionable examples showing correct syntax
|
||||
- ✅ Reject updates that would create invalid workflows with clear feedback
|
||||
- ✅ Updated tests to create valid workflows and verify prevention of invalid ones
|
||||
|
||||
**Phase 2 - Enhanced Validation** (discovered via real-world testing):
|
||||
- ✅ Detects ALL disconnected nodes, not just empty connection objects
|
||||
- ✅ Identifies each disconnected node by name and type
|
||||
- ✅ Provides specific fix suggestions naming the actual nodes
|
||||
- ✅ Handles webhook/trigger nodes correctly (can be source-only)
|
||||
- ✅ Tested against real incremental workflow building scenarios
|
||||
|
||||
#### Changes
|
||||
- `src/mcp/handlers-workflow-diff.ts`: Added `validateWorkflowStructure()` call after diff application
|
||||
- `src/services/n8n-validation.ts`:
|
||||
- Enhanced error messages with operation examples
|
||||
- **Added comprehensive disconnected node detection** (Phase 2)
|
||||
- Builds connection graph and identifies orphaned nodes
|
||||
- Suggests specific connection operations with actual node names
|
||||
- Tests:
|
||||
- Fixed 3 existing tests creating invalid workflows
|
||||
- Added 4 new validation tests (3 in Phase 1, 1 in Phase 2)
|
||||
- Test for incremental node addition without connections
|
||||
|
||||
#### Real-World Testing
|
||||
Tested against actual workflow building scenario (`chat_workflows_phase1.md`):
|
||||
- Agent building 28-node workflow incrementally
|
||||
- Validation correctly detected node added without connection
|
||||
- Error message provided exact fix with node names
|
||||
- Prevents UI from showing "Workflow not found" error
|
||||
|
||||
#### Impact
|
||||
- 🎯 **Prevention**: Impossible to create workflows that UI cannot render
|
||||
- 📝 **Feedback**: Clear error messages explaining why workflow is invalid
|
||||
- ✅ **Compatibility**: All existing valid workflows continue to work
|
||||
- 🔒 **Safety**: Validates before API call, prevents corruption at source
|
||||
- 🏗️ **Incremental Building**: Safe to build workflows step-by-step with validation at each step
|
||||
|
||||
## [2.20.2] - 2025-10-18
|
||||
|
||||
### 🐛 Critical Bug Fixes
|
||||
|
||||
@@ -192,5 +192,4 @@ NEVER proactively create documentation files (*.md) or README files. Only create
|
||||
- When the user asks to review issues, you should use GH CLI to get the issue and all the comments
|
||||
- When the task can be divided into separated subtasks, you should spawn separate sub-agents to handle them in paralel
|
||||
- Use the best sub-agent for the task as per their descriptions
|
||||
- Do not use hyperbolic or dramatic language in comments and documentation
|
||||
- Add to every commit and PR: Concieved by Romuald Członkowski - and then link to www.aiadvisors.pl/en. Don't add it in conversations
|
||||
- Do not use hyperbolic or dramatic language in comments and documentation
|
||||
101
README.md
101
README.md
@@ -5,7 +5,7 @@
|
||||
[](https://www.npmjs.com/package/n8n-mcp)
|
||||
[](https://codecov.io/gh/czlonkowski/n8n-mcp)
|
||||
[](https://github.com/czlonkowski/n8n-mcp/actions)
|
||||
[](https://github.com/n8n-io/n8n)
|
||||
[](https://github.com/n8n-io/n8n)
|
||||
[](https://github.com/czlonkowski/n8n-mcp/pkgs/container/n8n-mcp)
|
||||
[](https://railway.com/deploy/n8n-mcp?referralCode=n8n-mcp)
|
||||
|
||||
@@ -501,14 +501,6 @@ Complete guide for integrating n8n-MCP with Windsurf using project rules.
|
||||
### [Codex](./docs/CODEX_SETUP.md)
|
||||
Complete guide for integrating n8n-MCP with Codex.
|
||||
|
||||
## 🎓 Add Claude Skills (Optional)
|
||||
|
||||
Supercharge your n8n workflow building with specialized skills that teach AI how to build production-ready workflows!
|
||||
|
||||
[](https://www.youtube.com/watch?v=e6VvRqmUY2Y)
|
||||
|
||||
Learn more: [n8n-skills repository](https://github.com/czlonkowski/n8n-skills)
|
||||
|
||||
## 🤖 Claude Project Setup
|
||||
|
||||
For the best results when using n8n-MCP with Claude Projects, use these enhanced system instructions:
|
||||
@@ -674,97 +666,6 @@ n8n_update_partial_workflow({id: "wf-123", operations: [{...}]})
|
||||
n8n_update_partial_workflow({id: "wf-123", operations: [{...}]})
|
||||
```
|
||||
|
||||
### CRITICAL: addConnection Syntax
|
||||
|
||||
The `addConnection` operation requires **four separate string parameters**. Common mistakes cause misleading errors.
|
||||
|
||||
❌ WRONG - Object format (fails with "Expected string, received object"):
|
||||
```json
|
||||
{
|
||||
"type": "addConnection",
|
||||
"connection": {
|
||||
"source": {"nodeId": "node-1", "outputIndex": 0},
|
||||
"destination": {"nodeId": "node-2", "inputIndex": 0}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
❌ WRONG - Combined string (fails with "Source node not found"):
|
||||
```json
|
||||
{
|
||||
"type": "addConnection",
|
||||
"source": "node-1:main:0",
|
||||
"target": "node-2:main:0"
|
||||
}
|
||||
```
|
||||
|
||||
✅ CORRECT - Four separate string parameters:
|
||||
```json
|
||||
{
|
||||
"type": "addConnection",
|
||||
"source": "node-id-string",
|
||||
"target": "target-node-id-string",
|
||||
"sourcePort": "main",
|
||||
"targetPort": "main"
|
||||
}
|
||||
```
|
||||
|
||||
**Reference**: [GitHub Issue #327](https://github.com/czlonkowski/n8n-mcp/issues/327)
|
||||
|
||||
### ⚠️ CRITICAL: IF Node Multi-Output Routing
|
||||
|
||||
IF nodes have **two outputs** (TRUE and FALSE). Use the **`branch` parameter** to route to the correct output:
|
||||
|
||||
✅ CORRECT - Route to TRUE branch (when condition is met):
|
||||
```json
|
||||
{
|
||||
"type": "addConnection",
|
||||
"source": "if-node-id",
|
||||
"target": "success-handler-id",
|
||||
"sourcePort": "main",
|
||||
"targetPort": "main",
|
||||
"branch": "true"
|
||||
}
|
||||
```
|
||||
|
||||
✅ CORRECT - Route to FALSE branch (when condition is NOT met):
|
||||
```json
|
||||
{
|
||||
"type": "addConnection",
|
||||
"source": "if-node-id",
|
||||
"target": "failure-handler-id",
|
||||
"sourcePort": "main",
|
||||
"targetPort": "main",
|
||||
"branch": "false"
|
||||
}
|
||||
```
|
||||
|
||||
**Common Pattern** - Complete IF node routing:
|
||||
```json
|
||||
n8n_update_partial_workflow({
|
||||
id: "workflow-id",
|
||||
operations: [
|
||||
{type: "addConnection", source: "If Node", target: "True Handler", sourcePort: "main", targetPort: "main", branch: "true"},
|
||||
{type: "addConnection", source: "If Node", target: "False Handler", sourcePort: "main", targetPort: "main", branch: "false"}
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
**Note**: Without the `branch` parameter, both connections may end up on the same output, causing logic errors!
|
||||
|
||||
### removeConnection Syntax
|
||||
|
||||
Use the same four-parameter format:
|
||||
```json
|
||||
{
|
||||
"type": "removeConnection",
|
||||
"source": "source-node-id",
|
||||
"target": "target-node-id",
|
||||
"sourcePort": "main",
|
||||
"targetPort": "main"
|
||||
}
|
||||
```
|
||||
|
||||
## Example Workflow
|
||||
|
||||
### Template-First Approach
|
||||
|
||||
BIN
data/nodes.db
BIN
data/nodes.db
Binary file not shown.
@@ -1,111 +0,0 @@
|
||||
# CI Test Infrastructure - Known Issues
|
||||
|
||||
## Integration Test Failures for External Contributor PRs
|
||||
|
||||
### Issue Summary
|
||||
|
||||
Integration tests fail for external contributor PRs with "No response from n8n server" errors, despite the code changes being correct. This is a **test infrastructure issue**, not a code quality issue.
|
||||
|
||||
### Root Cause
|
||||
|
||||
1. **GitHub Actions Security**: External contributor PRs don't get access to repository secrets (`N8N_API_URL`, `N8N_API_KEY`, etc.)
|
||||
2. **MSW Mock Server**: Mock Service Worker (MSW) is not properly intercepting HTTP requests in the CI environment
|
||||
3. **Test Configuration**: Integration tests expect `http://localhost:3001/mock-api` but the mock server isn't responding
|
||||
|
||||
### Evidence
|
||||
|
||||
From CI logs (PR #343):
|
||||
```
|
||||
[CI-DEBUG] Global setup complete, N8N_API_URL: http://localhost:3001/mock-api
|
||||
❌ No response from n8n server (repeated 60+ times across 20 tests)
|
||||
```
|
||||
|
||||
The tests ARE using the correct mock URL, but MSW isn't intercepting the requests.
|
||||
|
||||
### Why This Happens
|
||||
|
||||
**For External PRs:**
|
||||
- GitHub Actions doesn't expose repository secrets for security reasons
|
||||
- Prevents malicious PRs from exfiltrating secrets
|
||||
- MSW setup runs but requests don't get intercepted in CI
|
||||
|
||||
**Test Configuration:**
|
||||
- `.env.test` line 19: `N8N_API_URL=http://localhost:3001/mock-api`
|
||||
- `.env.test` line 67: `MSW_ENABLED=true`
|
||||
- CI workflow line 75-80: Secrets set but empty for external PRs
|
||||
|
||||
### Impact
|
||||
|
||||
- ✅ **Code Quality**: NOT affected - the actual code changes are correct
|
||||
- ✅ **Local Testing**: Works fine - MSW intercepts requests locally
|
||||
- ❌ **CI for External PRs**: Integration tests fail (infrastructure issue)
|
||||
- ✅ **CI for Internal PRs**: Works fine (has access to secrets)
|
||||
|
||||
### Current Workarounds
|
||||
|
||||
1. **For Maintainers**: Use `--admin` flag to merge despite failing tests when code is verified correct
|
||||
2. **For Contributors**: Run tests locally where MSW works properly
|
||||
3. **For CI**: Unit tests pass (don't require n8n API), integration tests fail
|
||||
|
||||
### Files Affected
|
||||
|
||||
- `tests/integration/setup/integration-setup.ts` - MSW server setup
|
||||
- `tests/setup/msw-setup.ts` - MSW configuration
|
||||
- `tests/mocks/n8n-api/handlers.ts` - Mock request handlers
|
||||
- `.github/workflows/test.yml` - CI configuration
|
||||
- `.env.test` - Test environment configuration
|
||||
|
||||
### Potential Solutions (Not Implemented)
|
||||
|
||||
1. **Separate Unit/Integration Runs**
|
||||
- Run integration tests only for internal PRs
|
||||
- Skip integration tests for external PRs
|
||||
- Rely on unit tests for external PR validation
|
||||
|
||||
2. **MSW CI Debugging**
|
||||
- Add extensive logging to MSW setup
|
||||
- Check if MSW server actually starts in CI
|
||||
- Verify request interception is working
|
||||
|
||||
3. **Mock Server Process**
|
||||
- Start actual HTTP server in CI instead of MSW
|
||||
- More reliable but adds complexity
|
||||
- Would require test infrastructure refactoring
|
||||
|
||||
4. **Public Test Instance**
|
||||
- Use publicly accessible test n8n instance
|
||||
- Exposes test data, security concerns
|
||||
- Would work for external PRs
|
||||
|
||||
### Decision
|
||||
|
||||
**Status**: Documented but not fixed
|
||||
|
||||
**Rationale**:
|
||||
- Integration test infrastructure refactoring is separate concern from code quality
|
||||
- External PRs are relatively rare compared to internal development
|
||||
- Unit tests provide sufficient coverage for most changes
|
||||
- Maintainers can verify integration tests locally before merging
|
||||
|
||||
### Testing Strategy
|
||||
|
||||
**For External Contributor PRs:**
|
||||
1. ✅ Unit tests must pass
|
||||
2. ✅ TypeScript compilation must pass
|
||||
3. ✅ Build must succeed
|
||||
4. ⚠️ Integration test failures are expected (infrastructure issue)
|
||||
5. ✅ Maintainer verifies locally before merge
|
||||
|
||||
**For Internal PRs:**
|
||||
1. ✅ All tests must pass (unit + integration)
|
||||
2. ✅ Full CI validation
|
||||
|
||||
### References
|
||||
|
||||
- PR #343: First occurrence of this issue
|
||||
- PR #345: Documented the infrastructure issue
|
||||
- Issue: External PRs don't get secrets (GitHub Actions security)
|
||||
|
||||
### Last Updated
|
||||
|
||||
2025-10-21 - Documented as part of PR #345 investigation
|
||||
@@ -80,53 +80,6 @@ Remove the server:
|
||||
claude mcp remove n8n-mcp
|
||||
```
|
||||
|
||||
## 🎓 Add Claude Skills (Optional)
|
||||
|
||||
Supercharge your n8n workflow building with specialized Claude Code skills! The [n8n-skills](https://github.com/czlonkowski/n8n-skills) repository provides 7 complementary skills that teach AI assistants how to build production-ready n8n workflows.
|
||||
|
||||
### What You Get
|
||||
|
||||
- ✅ **n8n Expression Syntax** - Correct {{}} patterns and common mistakes
|
||||
- ✅ **n8n MCP Tools Expert** - How to use n8n-mcp tools effectively
|
||||
- ✅ **n8n Workflow Patterns** - 5 proven architectural patterns
|
||||
- ✅ **n8n Validation Expert** - Interpret and fix validation errors
|
||||
- ✅ **n8n Node Configuration** - Operation-aware setup guidance
|
||||
- ✅ **n8n Code JavaScript** - Write effective JavaScript in Code nodes
|
||||
- ✅ **n8n Code Python** - Python patterns with limitation awareness
|
||||
|
||||
### Installation
|
||||
|
||||
**Method 1: Plugin Installation** (Recommended)
|
||||
```bash
|
||||
/plugin install czlonkowski/n8n-skills
|
||||
```
|
||||
|
||||
**Method 2: Via Marketplace**
|
||||
```bash
|
||||
# Add as marketplace, then browse and install
|
||||
/plugin marketplace add czlonkowski/n8n-skills
|
||||
|
||||
# Then browse available plugins
|
||||
/plugin install
|
||||
# Select "n8n-mcp-skills" from the list
|
||||
```
|
||||
|
||||
**Method 3: Manual Installation**
|
||||
```bash
|
||||
# 1. Clone the repository
|
||||
git clone https://github.com/czlonkowski/n8n-skills.git
|
||||
|
||||
# 2. Copy skills to your Claude Code skills directory
|
||||
cp -r n8n-skills/skills/* ~/.claude/skills/
|
||||
|
||||
# 3. Reload Claude Code
|
||||
# Skills will activate automatically
|
||||
```
|
||||
|
||||
For complete installation instructions, configuration options, and usage examples, see the [n8n-skills README](https://github.com/czlonkowski/n8n-skills#-installation).
|
||||
|
||||
Skills work seamlessly with n8n-mcp to provide expert guidance throughout the workflow building process!
|
||||
|
||||
## Project Instructions
|
||||
|
||||
For optimal results, create a `CLAUDE.md` file in your project root with the instructions from the [main README's Claude Project Setup section](../README.md#-claude-project-setup).
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 430 KiB |
5997
package-lock.json
generated
5997
package-lock.json
generated
File diff suppressed because it is too large
Load Diff
11
package.json
11
package.json
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "n8n-mcp",
|
||||
"version": "2.20.8",
|
||||
"version": "2.20.2",
|
||||
"description": "Integration between n8n workflow automation and Model Context Protocol (MCP)",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
@@ -140,18 +140,17 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"@modelcontextprotocol/sdk": "^1.20.1",
|
||||
"@n8n/n8n-nodes-langchain": "^1.115.1",
|
||||
"@n8n/n8n-nodes-langchain": "^1.114.1",
|
||||
"@supabase/supabase-js": "^2.57.4",
|
||||
"dotenv": "^16.5.0",
|
||||
"express": "^5.1.0",
|
||||
"express-rate-limit": "^7.1.5",
|
||||
"lru-cache": "^11.2.1",
|
||||
"n8n": "^1.116.2",
|
||||
"n8n-core": "^1.115.1",
|
||||
"n8n-workflow": "^1.113.0",
|
||||
"n8n": "^1.115.2",
|
||||
"n8n-core": "^1.114.0",
|
||||
"n8n-workflow": "^1.112.0",
|
||||
"openai": "^4.77.0",
|
||||
"sql.js": "^1.13.0",
|
||||
"tslib": "^2.6.2",
|
||||
"uuid": "^10.0.0",
|
||||
"zod": "^3.24.1"
|
||||
},
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "n8n-mcp-runtime",
|
||||
"version": "2.20.7",
|
||||
"version": "2.20.2",
|
||||
"description": "n8n MCP Server Runtime Dependencies Only",
|
||||
"private": true,
|
||||
"dependencies": {
|
||||
@@ -11,7 +11,6 @@
|
||||
"dotenv": "^16.5.0",
|
||||
"lru-cache": "^11.2.1",
|
||||
"sql.js": "^1.13.0",
|
||||
"tslib": "^2.6.2",
|
||||
"uuid": "^10.0.0",
|
||||
"axios": "^1.7.7"
|
||||
},
|
||||
|
||||
@@ -23,17 +23,6 @@ import {
|
||||
|
||||
dotenv.config();
|
||||
|
||||
/**
|
||||
* MCP tool response format with optional structured content
|
||||
*/
|
||||
interface MCPToolResponse {
|
||||
content: Array<{
|
||||
type: 'text';
|
||||
text: string;
|
||||
}>;
|
||||
structuredContent?: unknown;
|
||||
}
|
||||
|
||||
let expressServer: any;
|
||||
let authToken: string | null = null;
|
||||
|
||||
@@ -412,46 +401,19 @@ export async function startFixedHTTPServer() {
|
||||
// Delegate to the MCP server
|
||||
const toolName = jsonRpcRequest.params?.name;
|
||||
const toolArgs = jsonRpcRequest.params?.arguments || {};
|
||||
|
||||
|
||||
try {
|
||||
const result = await mcpServer.executeTool(toolName, toolArgs);
|
||||
|
||||
// Convert result to JSON text for content field
|
||||
let responseText = JSON.stringify(result, null, 2);
|
||||
|
||||
// Build MCP-compliant response with structuredContent for validation tools
|
||||
const mcpResult: MCPToolResponse = {
|
||||
content: [
|
||||
{
|
||||
type: 'text',
|
||||
text: responseText
|
||||
}
|
||||
]
|
||||
};
|
||||
|
||||
// Add structuredContent for validation tools (they have outputSchema)
|
||||
// Apply 1MB safety limit to prevent memory issues (matches STDIO server behavior)
|
||||
if (toolName.startsWith('validate_')) {
|
||||
const resultSize = responseText.length;
|
||||
|
||||
if (resultSize > 1000000) {
|
||||
// Response is too large - truncate and warn
|
||||
logger.warn(
|
||||
`Validation tool ${toolName} response is very large (${resultSize} chars). ` +
|
||||
`Truncating for HTTP transport safety.`
|
||||
);
|
||||
mcpResult.content[0].text = responseText.substring(0, 999000) +
|
||||
'\n\n[Response truncated due to size limits]';
|
||||
// Don't include structuredContent for truncated responses
|
||||
} else {
|
||||
// Normal case - include structured content for MCP protocol compliance
|
||||
mcpResult.structuredContent = result;
|
||||
}
|
||||
}
|
||||
|
||||
response = {
|
||||
jsonrpc: '2.0',
|
||||
result: mcpResult,
|
||||
result: {
|
||||
content: [
|
||||
{
|
||||
type: 'text',
|
||||
text: JSON.stringify(result, null, 2)
|
||||
}
|
||||
]
|
||||
},
|
||||
id: jsonRpcRequest.id
|
||||
};
|
||||
} catch (error) {
|
||||
|
||||
@@ -11,7 +11,6 @@ import { getN8nApiClient } from './handlers-n8n-manager';
|
||||
import { N8nApiError, getUserFriendlyErrorMessage } from '../utils/n8n-errors';
|
||||
import { logger } from '../utils/logger';
|
||||
import { InstanceContext } from '../types/instance-context';
|
||||
import { validateWorkflowStructure } from '../services/n8n-validation';
|
||||
|
||||
// Zod schema for the diff request
|
||||
const workflowDiffSchema = z.object({
|
||||
@@ -126,87 +125,7 @@ export async function handleUpdatePartialWorkflow(args: unknown, context?: Insta
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Validate final workflow structure after applying all operations
|
||||
// This prevents creating workflows that pass operation-level validation
|
||||
// but fail workflow-level validation (e.g., UI can't render them)
|
||||
//
|
||||
// Validation can be skipped for specific integration tests that need to test
|
||||
// n8n API behavior with edge case workflows by setting SKIP_WORKFLOW_VALIDATION=true
|
||||
if (diffResult.workflow) {
|
||||
const structureErrors = validateWorkflowStructure(diffResult.workflow);
|
||||
if (structureErrors.length > 0) {
|
||||
const skipValidation = process.env.SKIP_WORKFLOW_VALIDATION === 'true';
|
||||
|
||||
logger.warn('Workflow structure validation failed after applying diff operations', {
|
||||
workflowId: input.id,
|
||||
errors: structureErrors,
|
||||
blocking: !skipValidation
|
||||
});
|
||||
|
||||
// Analyze error types to provide targeted recovery guidance
|
||||
const errorTypes = new Set<string>();
|
||||
structureErrors.forEach(err => {
|
||||
if (err.includes('operator') || err.includes('singleValue')) errorTypes.add('operator_issues');
|
||||
if (err.includes('connection') || err.includes('referenced')) errorTypes.add('connection_issues');
|
||||
if (err.includes('Missing') || err.includes('missing')) errorTypes.add('missing_metadata');
|
||||
if (err.includes('branch') || err.includes('output')) errorTypes.add('branch_mismatch');
|
||||
});
|
||||
|
||||
// Build recovery guidance based on error types
|
||||
const recoverySteps = [];
|
||||
if (errorTypes.has('operator_issues')) {
|
||||
recoverySteps.push('Operator structure issue detected. Use validate_node_operation to check specific nodes.');
|
||||
recoverySteps.push('Binary operators (equals, contains, greaterThan, etc.) must NOT have singleValue:true');
|
||||
recoverySteps.push('Unary operators (isEmpty, isNotEmpty, true, false) REQUIRE singleValue:true');
|
||||
}
|
||||
if (errorTypes.has('connection_issues')) {
|
||||
recoverySteps.push('Connection validation failed. Check all node connections reference existing nodes.');
|
||||
recoverySteps.push('Use cleanStaleConnections operation to remove connections to non-existent nodes.');
|
||||
}
|
||||
if (errorTypes.has('missing_metadata')) {
|
||||
recoverySteps.push('Missing metadata detected. Ensure filter-based nodes (IF v2.2+, Switch v3.2+) have complete conditions.options.');
|
||||
recoverySteps.push('Required options: {version: 2, leftValue: "", caseSensitive: true, typeValidation: "strict"}');
|
||||
}
|
||||
if (errorTypes.has('branch_mismatch')) {
|
||||
recoverySteps.push('Branch count mismatch. Ensure Switch nodes have outputs for all rules (e.g., 3 rules = 3 output branches).');
|
||||
}
|
||||
|
||||
// Add generic recovery steps if no specific guidance
|
||||
if (recoverySteps.length === 0) {
|
||||
recoverySteps.push('Review the validation errors listed above');
|
||||
recoverySteps.push('Fix issues using updateNode or cleanStaleConnections operations');
|
||||
recoverySteps.push('Run validate_workflow again to verify fixes');
|
||||
}
|
||||
|
||||
const errorMessage = structureErrors.length === 1
|
||||
? `Workflow validation failed: ${structureErrors[0]}`
|
||||
: `Workflow validation failed with ${structureErrors.length} structural issues`;
|
||||
|
||||
// If validation is not skipped, return error and block the save
|
||||
if (!skipValidation) {
|
||||
return {
|
||||
success: false,
|
||||
error: errorMessage,
|
||||
details: {
|
||||
errors: structureErrors,
|
||||
errorCount: structureErrors.length,
|
||||
operationsApplied: diffResult.operationsApplied,
|
||||
applied: diffResult.applied,
|
||||
recoveryGuidance: recoverySteps,
|
||||
note: 'Operations were applied but created an invalid workflow structure. The workflow was NOT saved to n8n to prevent UI rendering errors.',
|
||||
autoSanitizationNote: 'Auto-sanitization runs on all nodes during updates to fix operator structures and add missing metadata. However, it cannot fix all issues (e.g., broken connections, branch mismatches). Use the recovery guidance above to resolve remaining issues.'
|
||||
}
|
||||
};
|
||||
}
|
||||
// Validation skipped: log warning but continue (for specific integration tests)
|
||||
logger.info('Workflow validation skipped (SKIP_WORKFLOW_VALIDATION=true): Allowing workflow with validation warnings to proceed', {
|
||||
workflowId: input.id,
|
||||
warningCount: structureErrors.length
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Update workflow via API
|
||||
try {
|
||||
const updatedWorkflow = await client.updateWorkflow(input.id, diffResult.workflow!);
|
||||
|
||||
@@ -1276,20 +1276,20 @@ export class N8NDocumentationMCPServer {
|
||||
try {
|
||||
// Use FTS5 with ranking
|
||||
const nodes = this.db.prepare(`
|
||||
SELECT
|
||||
SELECT
|
||||
n.*,
|
||||
rank
|
||||
FROM nodes n
|
||||
JOIN nodes_fts ON n.rowid = nodes_fts.rowid
|
||||
WHERE nodes_fts MATCH ?
|
||||
ORDER BY
|
||||
CASE
|
||||
WHEN LOWER(n.display_name) = LOWER(?) THEN 0
|
||||
WHEN LOWER(n.display_name) LIKE LOWER(?) THEN 1
|
||||
WHEN LOWER(n.node_type) LIKE LOWER(?) THEN 2
|
||||
ORDER BY
|
||||
rank,
|
||||
CASE
|
||||
WHEN n.display_name = ? THEN 0
|
||||
WHEN n.display_name LIKE ? THEN 1
|
||||
WHEN n.node_type LIKE ? THEN 2
|
||||
ELSE 3
|
||||
END,
|
||||
rank,
|
||||
n.display_name
|
||||
LIMIT ?
|
||||
`).all(ftsQuery, cleanedQuery, `%${cleanedQuery}%`, `%${cleanedQuery}%`, limit) as (NodeRow & { rank: number })[];
|
||||
|
||||
@@ -11,8 +11,7 @@ export const validateNodeOperationDoc: ToolDocumentation = {
|
||||
tips: [
|
||||
'Profile choices: minimal (editing), runtime (execution), ai-friendly (balanced), strict (deployment)',
|
||||
'Returns fixes you can apply directly',
|
||||
'Operation-aware - knows Slack post needs text',
|
||||
'Validates operator structures for IF v2.2+ and Switch v3.2+ nodes'
|
||||
'Operation-aware - knows Slack post needs text'
|
||||
]
|
||||
},
|
||||
full: {
|
||||
@@ -72,9 +71,7 @@ export const validateNodeOperationDoc: ToolDocumentation = {
|
||||
'Validate configuration before workflow execution',
|
||||
'Debug why a node isn\'t working as expected',
|
||||
'Generate configuration fixes automatically',
|
||||
'Different validation for editing vs production',
|
||||
'Check IF/Switch operator structures (binary vs unary operators)',
|
||||
'Validate conditions.options metadata for filter-based nodes'
|
||||
'Different validation for editing vs production'
|
||||
],
|
||||
performance: '<100ms for most nodes, <200ms for complex nodes with many conditions',
|
||||
bestPractices: [
|
||||
@@ -88,10 +85,7 @@ export const validateNodeOperationDoc: ToolDocumentation = {
|
||||
pitfalls: [
|
||||
'Must include operation fields for multi-operation nodes',
|
||||
'Fixes are suggestions - review before applying',
|
||||
'Profile affects what\'s validated - minimal skips many checks',
|
||||
'**Binary vs Unary operators**: Binary operators (equals, contains, greaterThan) must NOT have singleValue:true. Unary operators (isEmpty, isNotEmpty, true, false) REQUIRE singleValue:true',
|
||||
'**IF v2.2+ and Switch v3.2+ nodes**: Must have complete conditions.options structure: {version: 2, leftValue: "", caseSensitive: true/false, typeValidation: "strict"}',
|
||||
'**Operator type field**: Must be data type (string/number/boolean/dateTime/array/object), NOT operation name (e.g., use type:"string" operation:"equals", not type:"equals")'
|
||||
'Profile affects what\'s validated - minimal skips many checks'
|
||||
],
|
||||
relatedTools: ['validate_node_minimal for quick checks', 'get_node_essentials for valid examples', 'validate_workflow for complete workflow validation']
|
||||
}
|
||||
|
||||
@@ -11,8 +11,7 @@ export const validateWorkflowDoc: ToolDocumentation = {
|
||||
tips: [
|
||||
'Always validate before n8n_create_workflow to catch errors early',
|
||||
'Use options.profile="minimal" for quick checks during development',
|
||||
'AI tool connections are automatically validated for proper node references',
|
||||
'Detects operator structure issues (binary vs unary, singleValue requirements)'
|
||||
'AI tool connections are automatically validated for proper node references'
|
||||
]
|
||||
},
|
||||
full: {
|
||||
@@ -68,9 +67,7 @@ export const validateWorkflowDoc: ToolDocumentation = {
|
||||
'Use minimal profile during development, strict profile before production',
|
||||
'Pay attention to warnings - they often indicate potential runtime issues',
|
||||
'Validate after any workflow modifications, especially connection changes',
|
||||
'Check statistics to understand workflow complexity',
|
||||
'**Auto-sanitization runs during create/update**: Operator structures and missing metadata are automatically fixed when workflows are created or updated, but validation helps catch issues before they reach n8n',
|
||||
'If validation detects operator issues, they will be auto-fixed during n8n_create_workflow or n8n_update_partial_workflow'
|
||||
'Check statistics to understand workflow complexity'
|
||||
],
|
||||
pitfalls: [
|
||||
'Large workflows (100+ nodes) may take longer to validate',
|
||||
|
||||
@@ -11,8 +11,7 @@ export const n8nCreateWorkflowDoc: ToolDocumentation = {
|
||||
tips: [
|
||||
'Workflow created inactive',
|
||||
'Returns ID for future updates',
|
||||
'Validate first with validate_workflow',
|
||||
'Auto-sanitization fixes operator structures and missing metadata during creation'
|
||||
'Validate first with validate_workflow'
|
||||
]
|
||||
},
|
||||
full: {
|
||||
@@ -91,9 +90,7 @@ n8n_create_workflow({
|
||||
'Workflows created in INACTIVE state - must activate separately',
|
||||
'Node IDs must be unique within workflow',
|
||||
'Credentials must be configured separately in n8n',
|
||||
'Node type names must include package prefix (e.g., "n8n-nodes-base.slack")',
|
||||
'**Auto-sanitization runs on creation**: All nodes sanitized before workflow created (operator structures fixed, missing metadata added)',
|
||||
'**Auto-sanitization cannot prevent all failures**: Broken connections or invalid node configurations may still cause creation to fail'
|
||||
'Node type names must include package prefix (e.g., "n8n-nodes-base.slack")'
|
||||
],
|
||||
relatedTools: ['validate_workflow', 'n8n_update_partial_workflow', 'n8n_trigger_webhook_workflow']
|
||||
}
|
||||
|
||||
@@ -17,8 +17,7 @@ export const n8nUpdatePartialWorkflowDoc: ToolDocumentation = {
|
||||
'Use continueOnError mode for best-effort bulk operations',
|
||||
'Validate with validateOnly first',
|
||||
'For AI connections, specify sourceOutput type (ai_languageModel, ai_tool, etc.)',
|
||||
'Batch AI component connections for atomic updates',
|
||||
'Auto-sanitization: ALL nodes auto-fixed during updates (operator structures, missing metadata)'
|
||||
'Batch AI component connections for atomic updates'
|
||||
]
|
||||
},
|
||||
full: {
|
||||
@@ -95,41 +94,7 @@ The **cleanStaleConnections** operation automatically removes broken connection
|
||||
Set **continueOnError: true** to apply valid operations even if some fail. Returns detailed results showing which operations succeeded/failed. Perfect for bulk cleanup operations.
|
||||
|
||||
### Graceful Error Handling
|
||||
Add **ignoreErrors: true** to removeConnection operations to prevent failures when connections don't exist.
|
||||
|
||||
## Auto-Sanitization System
|
||||
|
||||
### What Gets Auto-Fixed
|
||||
When ANY workflow update is made, ALL nodes in the workflow are automatically sanitized to ensure complete metadata and correct structure:
|
||||
|
||||
1. **Operator Structure Fixes**:
|
||||
- Binary operators (equals, contains, greaterThan, etc.) automatically have \`singleValue\` removed
|
||||
- Unary operators (isEmpty, isNotEmpty, true, false) automatically get \`singleValue: true\` added
|
||||
- Invalid operator structures (e.g., \`{type: "isNotEmpty"}\`) are corrected to \`{type: "boolean", operation: "isNotEmpty"}\`
|
||||
|
||||
2. **Missing Metadata Added**:
|
||||
- IF v2.2+ nodes get complete \`conditions.options\` structure if missing
|
||||
- Switch v3.2+ nodes get complete \`conditions.options\` for all rules
|
||||
- Required fields: \`{version: 2, leftValue: "", caseSensitive: true, typeValidation: "strict"}\`
|
||||
|
||||
### Sanitization Scope
|
||||
- Runs on **ALL nodes** in the workflow, not just modified ones
|
||||
- Triggered by ANY update operation (addNode, updateNode, addConnection, etc.)
|
||||
- Prevents workflow corruption that would make UI unrenderable
|
||||
|
||||
### Limitations
|
||||
Auto-sanitization CANNOT fix:
|
||||
- Broken connections (connections referencing non-existent nodes) - use \`cleanStaleConnections\`
|
||||
- Branch count mismatches (e.g., Switch with 3 rules but only 2 outputs) - requires manual connection fixes
|
||||
- Workflows in paradoxical corrupt states (API returns corrupt data, API rejects updates) - must recreate workflow
|
||||
|
||||
### Recovery Guidance
|
||||
If validation still fails after auto-sanitization:
|
||||
1. Check error details for specific issues
|
||||
2. Use \`validate_workflow\` to see all validation errors
|
||||
3. For connection issues, use \`cleanStaleConnections\` operation
|
||||
4. For branch mismatches, add missing output connections
|
||||
5. For paradoxical corrupted workflows, create new workflow and migrate nodes`,
|
||||
Add **ignoreErrors: true** to removeConnection operations to prevent failures when connections don't exist.`,
|
||||
parameters: {
|
||||
id: { type: 'string', required: true, description: 'Workflow ID to update' },
|
||||
operations: {
|
||||
@@ -216,11 +181,7 @@ If validation still fails after auto-sanitization:
|
||||
'Smart parameters (branch, case) only work with IF and Switch nodes - ignored for other node types',
|
||||
'Explicit sourceIndex overrides smart parameters (branch, case) if both provided',
|
||||
'cleanStaleConnections removes ALL broken connections - cannot be selective',
|
||||
'replaceConnections overwrites entire connections object - all previous connections lost',
|
||||
'**Auto-sanitization behavior**: Binary operators (equals, contains) automatically have singleValue removed; unary operators (isEmpty, isNotEmpty) automatically get singleValue:true added',
|
||||
'**Auto-sanitization runs on ALL nodes**: When ANY update is made, ALL nodes in the workflow are sanitized (not just modified ones)',
|
||||
'**Auto-sanitization cannot fix everything**: It fixes operator structures and missing metadata, but cannot fix broken connections or branch mismatches',
|
||||
'**Corrupted workflows beyond repair**: Workflows in paradoxical states (API returns corrupt, API rejects updates) cannot be fixed via API - must be recreated'
|
||||
'replaceConnections overwrites entire connections object - all previous connections lost'
|
||||
],
|
||||
relatedTools: ['n8n_update_full_workflow', 'n8n_get_workflow', 'validate_workflow', 'tools_documentation']
|
||||
}
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
/**
|
||||
* Configuration Validator Service
|
||||
*
|
||||
*
|
||||
* Validates node configurations to catch errors before execution.
|
||||
* Provides helpful suggestions and identifies missing or misconfigured properties.
|
||||
*/
|
||||
|
||||
import { shouldSkipLiteralValidation } from '../utils/expression-utils.js';
|
||||
|
||||
export interface ValidationResult {
|
||||
valid: boolean;
|
||||
errors: ValidationError[];
|
||||
@@ -383,16 +381,13 @@ export class ConfigValidator {
|
||||
): void {
|
||||
// URL validation
|
||||
if (config.url && typeof config.url === 'string') {
|
||||
// Skip validation for expressions - they will be evaluated at runtime
|
||||
if (!shouldSkipLiteralValidation(config.url)) {
|
||||
if (!config.url.startsWith('http://') && !config.url.startsWith('https://')) {
|
||||
errors.push({
|
||||
type: 'invalid_value',
|
||||
property: 'url',
|
||||
message: 'URL must start with http:// or https://',
|
||||
fix: 'Add https:// to the beginning of your URL'
|
||||
});
|
||||
}
|
||||
if (!config.url.startsWith('http://') && !config.url.startsWith('https://')) {
|
||||
errors.push({
|
||||
type: 'invalid_value',
|
||||
property: 'url',
|
||||
message: 'URL must start with http:// or https://',
|
||||
fix: 'Add https:// to the beginning of your URL'
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -422,19 +417,15 @@ export class ConfigValidator {
|
||||
|
||||
// JSON body validation
|
||||
if (config.sendBody && config.contentType === 'json' && config.jsonBody) {
|
||||
// Skip validation for expressions - they will be evaluated at runtime
|
||||
if (!shouldSkipLiteralValidation(config.jsonBody)) {
|
||||
try {
|
||||
JSON.parse(config.jsonBody);
|
||||
} catch (e) {
|
||||
const errorMsg = e instanceof Error ? e.message : 'Unknown parsing error';
|
||||
errors.push({
|
||||
type: 'invalid_value',
|
||||
property: 'jsonBody',
|
||||
message: `jsonBody contains invalid JSON: ${errorMsg}`,
|
||||
fix: 'Fix JSON syntax error and ensure valid JSON format'
|
||||
});
|
||||
}
|
||||
try {
|
||||
JSON.parse(config.jsonBody);
|
||||
} catch (e) {
|
||||
errors.push({
|
||||
type: 'invalid_value',
|
||||
property: 'jsonBody',
|
||||
message: 'jsonBody contains invalid JSON',
|
||||
fix: 'Ensure jsonBody contains valid JSON syntax'
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -466,15 +466,6 @@ export class EnhancedConfigValidator extends ConfigValidator {
|
||||
return Array.from(seen.values());
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a warning should be filtered out (hardcoded credentials shown only in strict mode)
|
||||
*/
|
||||
private static shouldFilterCredentialWarning(warning: ValidationWarning): boolean {
|
||||
return warning.type === 'security' &&
|
||||
warning.message !== undefined &&
|
||||
warning.message.includes('Hardcoded nodeCredentialType');
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply profile-based filtering to validation results
|
||||
*/
|
||||
@@ -487,13 +478,9 @@ export class EnhancedConfigValidator extends ConfigValidator {
|
||||
// Only keep missing required errors
|
||||
result.errors = result.errors.filter(e => e.type === 'missing_required');
|
||||
// Keep ONLY critical warnings (security and deprecated)
|
||||
// But filter out hardcoded credential type warnings (only show in strict mode)
|
||||
result.warnings = result.warnings.filter(w => {
|
||||
if (this.shouldFilterCredentialWarning(w)) {
|
||||
return false;
|
||||
}
|
||||
return w.type === 'security' || w.type === 'deprecated';
|
||||
});
|
||||
result.warnings = result.warnings.filter(w =>
|
||||
w.type === 'security' || w.type === 'deprecated'
|
||||
);
|
||||
result.suggestions = [];
|
||||
break;
|
||||
|
||||
@@ -506,10 +493,6 @@ export class EnhancedConfigValidator extends ConfigValidator {
|
||||
);
|
||||
// Keep security and deprecated warnings, REMOVE property visibility warnings
|
||||
result.warnings = result.warnings.filter(w => {
|
||||
// Filter out hardcoded credential type warnings (only show in strict mode)
|
||||
if (this.shouldFilterCredentialWarning(w)) {
|
||||
return false;
|
||||
}
|
||||
if (w.type === 'security' || w.type === 'deprecated') return true;
|
||||
// FILTER OUT property visibility warnings (too noisy)
|
||||
if (w.type === 'inefficient' && w.message && w.message.includes('not visible')) {
|
||||
@@ -535,10 +518,6 @@ export class EnhancedConfigValidator extends ConfigValidator {
|
||||
// Current behavior - balanced for AI agents
|
||||
// Filter out noise but keep helpful warnings
|
||||
result.warnings = result.warnings.filter(w => {
|
||||
// Filter out hardcoded credential type warnings (only show in strict mode)
|
||||
if (this.shouldFilterCredentialWarning(w)) {
|
||||
return false;
|
||||
}
|
||||
// Keep security and deprecated warnings
|
||||
if (w.type === 'security' || w.type === 'deprecated') return true;
|
||||
// Keep missing common properties
|
||||
|
||||
@@ -207,14 +207,8 @@ export class ExpressionValidator {
|
||||
expr: string,
|
||||
result: ExpressionValidationResult
|
||||
): void {
|
||||
// Check for missing $ prefix - but exclude cases where $ is already present OR it's property access (e.g., .json)
|
||||
// The pattern now excludes:
|
||||
// - Immediately preceded by $ (e.g., $json) - handled by (?<!\$)
|
||||
// - Preceded by a dot (e.g., .json in $('Node').item.json.field) - handled by (?<!\.)
|
||||
// - Inside word characters (e.g., myJson) - handled by (?<!\w)
|
||||
// - Inside bracket notation (e.g., ['json']) - handled by (?<![)
|
||||
// - After opening bracket or quote (e.g., "json" or ['json'])
|
||||
const missingPrefixPattern = /(?<![.$\w['])\b(json|node|input|items|workflow|execution)\b(?!\s*[:''])/;
|
||||
// Check for missing $ prefix - but exclude cases where $ is already present
|
||||
const missingPrefixPattern = /(?<!\$)\b(json|node|input|items|workflow|execution)\b(?!\s*:)/;
|
||||
if (expr.match(missingPrefixPattern)) {
|
||||
result.warnings.push(
|
||||
'Possible missing $ prefix for variable (e.g., use $json instead of json)'
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
import { z } from 'zod';
|
||||
import { WorkflowNode, WorkflowConnection, Workflow } from '../types/n8n-api';
|
||||
import { isNonExecutableNode, isTriggerNode } from '../utils/node-classification';
|
||||
|
||||
// Zod schemas for n8n API validation
|
||||
|
||||
@@ -195,14 +194,6 @@ export function validateWorkflowStructure(workflow: Partial<Workflow>): string[]
|
||||
errors.push('Workflow must have at least one node');
|
||||
}
|
||||
|
||||
// Check if workflow has only non-executable nodes (sticky notes)
|
||||
if (workflow.nodes && workflow.nodes.length > 0) {
|
||||
const hasExecutableNodes = workflow.nodes.some(node => !isNonExecutableNode(node.type));
|
||||
if (!hasExecutableNodes) {
|
||||
errors.push('Workflow must have at least one executable node. Sticky notes alone cannot form a valid workflow.');
|
||||
}
|
||||
}
|
||||
|
||||
if (!workflow.connections) {
|
||||
errors.push('Workflow connections are required');
|
||||
}
|
||||
@@ -210,71 +201,20 @@ export function validateWorkflowStructure(workflow: Partial<Workflow>): string[]
|
||||
// Check for minimum viable workflow
|
||||
if (workflow.nodes && workflow.nodes.length === 1) {
|
||||
const singleNode = workflow.nodes[0];
|
||||
const isWebhookOnly = singleNode.type === 'n8n-nodes-base.webhook' ||
|
||||
const isWebhookOnly = singleNode.type === 'n8n-nodes-base.webhook' ||
|
||||
singleNode.type === 'n8n-nodes-base.webhookTrigger';
|
||||
|
||||
|
||||
if (!isWebhookOnly) {
|
||||
errors.push(`Single non-webhook node workflow is invalid. Current node: "${singleNode.name}" (${singleNode.type}). Add another node using: {type: 'addNode', node: {name: 'Process Data', type: 'n8n-nodes-base.set', typeVersion: 3.4, position: [450, 300], parameters: {}}}`);
|
||||
errors.push('Single-node workflows are only valid for webhooks. Add at least one more node and connect them. Example: Manual Trigger → Set node');
|
||||
}
|
||||
}
|
||||
|
||||
// Check for disconnected nodes in multi-node workflows
|
||||
// Check for empty connections in multi-node workflows
|
||||
if (workflow.nodes && workflow.nodes.length > 1 && workflow.connections) {
|
||||
// Filter out non-executable nodes (sticky notes) when counting nodes
|
||||
const executableNodes = workflow.nodes.filter(node => !isNonExecutableNode(node.type));
|
||||
const connectionCount = Object.keys(workflow.connections).length;
|
||||
|
||||
// First check: workflow has no connections at all (only check if there are multiple executable nodes)
|
||||
if (connectionCount === 0 && executableNodes.length > 1) {
|
||||
const nodeNames = executableNodes.slice(0, 2).map(n => n.name);
|
||||
errors.push(`Multi-node workflow has no connections between nodes. Add a connection using: {type: 'addConnection', source: '${nodeNames[0]}', target: '${nodeNames[1]}', sourcePort: 'main', targetPort: 'main'}`);
|
||||
} else if (connectionCount > 0 || executableNodes.length > 1) {
|
||||
// Second check: detect disconnected nodes (nodes with no incoming or outgoing connections)
|
||||
const connectedNodes = new Set<string>();
|
||||
|
||||
// Collect all nodes that appear in connections (as source or target)
|
||||
Object.entries(workflow.connections).forEach(([sourceName, connection]) => {
|
||||
connectedNodes.add(sourceName); // Node has outgoing connection
|
||||
|
||||
if (connection.main && Array.isArray(connection.main)) {
|
||||
connection.main.forEach((outputs) => {
|
||||
if (Array.isArray(outputs)) {
|
||||
outputs.forEach((target) => {
|
||||
connectedNodes.add(target.node); // Node has incoming connection
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// Find disconnected nodes (excluding non-executable nodes and triggers)
|
||||
// Non-executable nodes (sticky notes) are UI-only and don't need connections
|
||||
// Trigger nodes only need outgoing connections
|
||||
const disconnectedNodes = workflow.nodes.filter(node => {
|
||||
// Skip non-executable nodes (sticky notes, etc.) - they're UI-only annotations
|
||||
if (isNonExecutableNode(node.type)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const isConnected = connectedNodes.has(node.name);
|
||||
const isTrigger = isTriggerNode(node.type);
|
||||
|
||||
// Trigger nodes only need outgoing connections
|
||||
if (isTrigger) {
|
||||
return !workflow.connections?.[node.name]; // Disconnected if no outgoing connections
|
||||
}
|
||||
|
||||
// Regular nodes need at least one connection (incoming or outgoing)
|
||||
return !isConnected;
|
||||
});
|
||||
|
||||
if (disconnectedNodes.length > 0) {
|
||||
const disconnectedList = disconnectedNodes.map(n => `"${n.name}" (${n.type})`).join(', ');
|
||||
const firstDisconnected = disconnectedNodes[0];
|
||||
const suggestedSource = workflow.nodes.find(n => connectedNodes.has(n.name))?.name || workflow.nodes[0].name;
|
||||
|
||||
errors.push(`Disconnected nodes detected: ${disconnectedList}. Each node must have at least one connection. Add a connection: {type: 'addConnection', source: '${suggestedSource}', target: '${firstDisconnected.name}', sourcePort: 'main', targetPort: 'main'}`);
|
||||
}
|
||||
|
||||
if (connectionCount === 0) {
|
||||
errors.push('Multi-node workflow has empty connections. Connect nodes like this: connections: { "Node1 Name": { "main": [[{ "node": "Node2 Name", "type": "main", "index": 0 }]] } }');
|
||||
}
|
||||
}
|
||||
|
||||
@@ -296,16 +236,6 @@ export function validateWorkflowStructure(workflow: Partial<Workflow>): string[]
|
||||
});
|
||||
}
|
||||
|
||||
// Validate filter-based nodes (IF v2.2+, Switch v3.2+) have complete metadata
|
||||
if (workflow.nodes) {
|
||||
workflow.nodes.forEach((node, index) => {
|
||||
const filterErrors = validateFilterBasedNodeMetadata(node);
|
||||
if (filterErrors.length > 0) {
|
||||
errors.push(...filterErrors.map(err => `Node "${node.name}" (index ${index}): ${err}`));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Validate connections
|
||||
if (workflow.connections) {
|
||||
try {
|
||||
@@ -315,66 +245,12 @@ export function validateWorkflowStructure(workflow: Partial<Workflow>): string[]
|
||||
}
|
||||
}
|
||||
|
||||
// Validate Switch and IF node connection structures match their rules
|
||||
if (workflow.nodes && workflow.connections) {
|
||||
const switchNodes = workflow.nodes.filter(n => {
|
||||
if (n.type !== 'n8n-nodes-base.switch') return false;
|
||||
const mode = (n.parameters as any)?.mode;
|
||||
return !mode || mode === 'rules'; // Default mode is 'rules'
|
||||
});
|
||||
|
||||
for (const switchNode of switchNodes) {
|
||||
const params = switchNode.parameters as any;
|
||||
const rules = params?.rules?.rules || [];
|
||||
const nodeConnections = workflow.connections[switchNode.name];
|
||||
|
||||
if (rules.length > 0 && nodeConnections?.main) {
|
||||
const outputBranches = nodeConnections.main.length;
|
||||
|
||||
// Switch nodes in "rules" mode need output branches matching rules count
|
||||
if (outputBranches !== rules.length) {
|
||||
const ruleNames = rules.map((r: any, i: number) =>
|
||||
r.outputKey ? `"${r.outputKey}" (index ${i})` : `Rule ${i}`
|
||||
).join(', ');
|
||||
|
||||
errors.push(
|
||||
`Switch node "${switchNode.name}" has ${rules.length} rules [${ruleNames}] ` +
|
||||
`but only ${outputBranches} output branch${outputBranches !== 1 ? 'es' : ''} in connections. ` +
|
||||
`Each rule needs its own output branch. When connecting to Switch outputs, specify sourceIndex: ` +
|
||||
rules.map((_: any, i: number) => i).join(', ') +
|
||||
` (or use case parameter for clarity).`
|
||||
);
|
||||
}
|
||||
|
||||
// Check for empty output branches (except trailing ones)
|
||||
const nonEmptyBranches = nodeConnections.main.filter((branch: any[]) => branch.length > 0).length;
|
||||
if (nonEmptyBranches < rules.length) {
|
||||
const emptyIndices = nodeConnections.main
|
||||
.map((branch: any[], i: number) => branch.length === 0 ? i : -1)
|
||||
.filter((i: number) => i !== -1 && i < rules.length);
|
||||
|
||||
if (emptyIndices.length > 0) {
|
||||
const ruleInfo = emptyIndices.map((i: number) => {
|
||||
const rule = rules[i];
|
||||
return rule.outputKey ? `"${rule.outputKey}" (index ${i})` : `Rule ${i}`;
|
||||
}).join(', ');
|
||||
|
||||
errors.push(
|
||||
`Switch node "${switchNode.name}" has unconnected output${emptyIndices.length !== 1 ? 's' : ''}: ${ruleInfo}. ` +
|
||||
`Add connection${emptyIndices.length !== 1 ? 's' : ''} using sourceIndex: ${emptyIndices.join(' or ')}.`
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Validate that all connection references exist and use node NAMES (not IDs)
|
||||
if (workflow.nodes && workflow.connections) {
|
||||
const nodeNames = new Set(workflow.nodes.map(node => node.name));
|
||||
const nodeIds = new Set(workflow.nodes.map(node => node.id));
|
||||
const nodeIdToName = new Map(workflow.nodes.map(node => [node.id, node.name]));
|
||||
|
||||
|
||||
Object.entries(workflow.connections).forEach(([sourceName, connection]) => {
|
||||
// Check if source exists by name (correct)
|
||||
if (!nodeNames.has(sourceName)) {
|
||||
@@ -413,177 +289,12 @@ export function validateWorkflowStructure(workflow: Partial<Workflow>): string[]
|
||||
|
||||
// Check if workflow has webhook trigger
|
||||
export function hasWebhookTrigger(workflow: Workflow): boolean {
|
||||
return workflow.nodes.some(node =>
|
||||
node.type === 'n8n-nodes-base.webhook' ||
|
||||
return workflow.nodes.some(node =>
|
||||
node.type === 'n8n-nodes-base.webhook' ||
|
||||
node.type === 'n8n-nodes-base.webhookTrigger'
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate filter-based node metadata (IF v2.2+, Switch v3.2+)
|
||||
* Returns array of error messages
|
||||
*/
|
||||
export function validateFilterBasedNodeMetadata(node: WorkflowNode): string[] {
|
||||
const errors: string[] = [];
|
||||
|
||||
// Check if node is filter-based
|
||||
const isIFNode = node.type === 'n8n-nodes-base.if' && node.typeVersion >= 2.2;
|
||||
const isSwitchNode = node.type === 'n8n-nodes-base.switch' && node.typeVersion >= 3.2;
|
||||
|
||||
if (!isIFNode && !isSwitchNode) {
|
||||
return errors; // Not a filter-based node
|
||||
}
|
||||
|
||||
// Validate IF node
|
||||
if (isIFNode) {
|
||||
const conditions = (node.parameters.conditions as any);
|
||||
|
||||
// Check conditions.options exists
|
||||
if (!conditions?.options) {
|
||||
errors.push(
|
||||
'Missing required "conditions.options". ' +
|
||||
'IF v2.2+ requires: {version: 2, leftValue: "", caseSensitive: true, typeValidation: "strict"}'
|
||||
);
|
||||
} else {
|
||||
// Validate required fields
|
||||
const requiredFields = {
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: 'boolean',
|
||||
typeValidation: 'strict'
|
||||
};
|
||||
|
||||
for (const [field, expectedValue] of Object.entries(requiredFields)) {
|
||||
if (!(field in conditions.options)) {
|
||||
errors.push(
|
||||
`Missing required field "conditions.options.${field}". ` +
|
||||
`Expected value: ${typeof expectedValue === 'string' ? `"${expectedValue}"` : expectedValue}`
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Validate operators in conditions
|
||||
if (conditions?.conditions && Array.isArray(conditions.conditions)) {
|
||||
conditions.conditions.forEach((condition: any, i: number) => {
|
||||
const operatorErrors = validateOperatorStructure(condition.operator, `conditions.conditions[${i}].operator`);
|
||||
errors.push(...operatorErrors);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Validate Switch node
|
||||
if (isSwitchNode) {
|
||||
const rules = (node.parameters.rules as any);
|
||||
|
||||
if (rules?.rules && Array.isArray(rules.rules)) {
|
||||
rules.rules.forEach((rule: any, ruleIndex: number) => {
|
||||
// Check rule.conditions.options
|
||||
if (!rule.conditions?.options) {
|
||||
errors.push(
|
||||
`Missing required "rules.rules[${ruleIndex}].conditions.options". ` +
|
||||
'Switch v3.2+ requires: {version: 2, leftValue: "", caseSensitive: true, typeValidation: "strict"}'
|
||||
);
|
||||
} else {
|
||||
// Validate required fields
|
||||
const requiredFields = {
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: 'boolean',
|
||||
typeValidation: 'strict'
|
||||
};
|
||||
|
||||
for (const [field, expectedValue] of Object.entries(requiredFields)) {
|
||||
if (!(field in rule.conditions.options)) {
|
||||
errors.push(
|
||||
`Missing required field "rules.rules[${ruleIndex}].conditions.options.${field}". ` +
|
||||
`Expected value: ${typeof expectedValue === 'string' ? `"${expectedValue}"` : expectedValue}`
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Validate operators in rule conditions
|
||||
if (rule.conditions?.conditions && Array.isArray(rule.conditions.conditions)) {
|
||||
rule.conditions.conditions.forEach((condition: any, condIndex: number) => {
|
||||
const operatorErrors = validateOperatorStructure(
|
||||
condition.operator,
|
||||
`rules.rules[${ruleIndex}].conditions.conditions[${condIndex}].operator`
|
||||
);
|
||||
errors.push(...operatorErrors);
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate operator structure
|
||||
* Ensures operator has correct format: {type, operation, singleValue?}
|
||||
*/
|
||||
export function validateOperatorStructure(operator: any, path: string): string[] {
|
||||
const errors: string[] = [];
|
||||
|
||||
if (!operator || typeof operator !== 'object') {
|
||||
errors.push(`${path}: operator is missing or not an object`);
|
||||
return errors;
|
||||
}
|
||||
|
||||
// Check required field: type (data type, not operation name)
|
||||
if (!operator.type) {
|
||||
errors.push(
|
||||
`${path}: missing required field "type". ` +
|
||||
'Must be a data type: "string", "number", "boolean", "dateTime", "array", or "object"'
|
||||
);
|
||||
} else {
|
||||
const validTypes = ['string', 'number', 'boolean', 'dateTime', 'array', 'object'];
|
||||
if (!validTypes.includes(operator.type)) {
|
||||
errors.push(
|
||||
`${path}: invalid type "${operator.type}". ` +
|
||||
`Type must be a data type (${validTypes.join(', ')}), not an operation name. ` +
|
||||
'Did you mean to use the "operation" field?'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Check required field: operation
|
||||
if (!operator.operation) {
|
||||
errors.push(
|
||||
`${path}: missing required field "operation". ` +
|
||||
'Operation specifies the comparison type (e.g., "equals", "contains", "isNotEmpty")'
|
||||
);
|
||||
}
|
||||
|
||||
// Check singleValue based on operator type
|
||||
if (operator.operation) {
|
||||
const unaryOperators = ['isEmpty', 'isNotEmpty', 'true', 'false', 'isNumeric'];
|
||||
const isUnary = unaryOperators.includes(operator.operation);
|
||||
|
||||
if (isUnary) {
|
||||
// Unary operators MUST have singleValue: true
|
||||
if (operator.singleValue !== true) {
|
||||
errors.push(
|
||||
`${path}: unary operator "${operator.operation}" requires "singleValue: true". ` +
|
||||
'Unary operators do not use rightValue.'
|
||||
);
|
||||
}
|
||||
} else {
|
||||
// Binary operators should NOT have singleValue: true
|
||||
if (operator.singleValue === true) {
|
||||
errors.push(
|
||||
`${path}: binary operator "${operator.operation}" should not have "singleValue: true". ` +
|
||||
'Only unary operators (isEmpty, isNotEmpty, true, false, isNumeric) need this property.'
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return errors;
|
||||
}
|
||||
|
||||
// Get webhook URL from workflow
|
||||
export function getWebhookUrl(workflow: Workflow): string | null {
|
||||
const webhookNode = workflow.nodes.find(node =>
|
||||
|
||||
@@ -1,361 +0,0 @@
|
||||
/**
|
||||
* Node Sanitizer Service
|
||||
*
|
||||
* Ensures nodes have complete metadata required by n8n UI.
|
||||
* Based on n8n AI Workflow Builder patterns:
|
||||
* - Merges node type defaults with user parameters
|
||||
* - Auto-adds required metadata for filter-based nodes (IF v2.2+, Switch v3.2+)
|
||||
* - Fixes operator structure
|
||||
* - Prevents "Could not find property option" errors
|
||||
*/
|
||||
|
||||
import { INodeParameters } from 'n8n-workflow';
|
||||
import { logger } from '../utils/logger';
|
||||
import { WorkflowNode } from '../types/n8n-api';
|
||||
|
||||
/**
|
||||
* Sanitize a single node by adding required metadata
|
||||
*/
|
||||
export function sanitizeNode(node: WorkflowNode): WorkflowNode {
|
||||
const sanitized = { ...node };
|
||||
|
||||
// Apply node-specific sanitization
|
||||
if (isFilterBasedNode(node.type, node.typeVersion)) {
|
||||
sanitized.parameters = sanitizeFilterBasedNode(
|
||||
sanitized.parameters as INodeParameters,
|
||||
node.type,
|
||||
node.typeVersion
|
||||
);
|
||||
}
|
||||
|
||||
return sanitized;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sanitize all nodes in a workflow
|
||||
*/
|
||||
export function sanitizeWorkflowNodes(workflow: any): any {
|
||||
if (!workflow.nodes || !Array.isArray(workflow.nodes)) {
|
||||
return workflow;
|
||||
}
|
||||
|
||||
return {
|
||||
...workflow,
|
||||
nodes: workflow.nodes.map((node: any) => sanitizeNode(node))
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if node is filter-based (IF v2.2+, Switch v3.2+)
|
||||
*/
|
||||
function isFilterBasedNode(nodeType: string, typeVersion: number): boolean {
|
||||
if (nodeType === 'n8n-nodes-base.if') {
|
||||
return typeVersion >= 2.2;
|
||||
}
|
||||
if (nodeType === 'n8n-nodes-base.switch') {
|
||||
return typeVersion >= 3.2;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sanitize filter-based nodes (IF v2.2+, Switch v3.2+)
|
||||
* Ensures conditions.options has complete structure
|
||||
*/
|
||||
function sanitizeFilterBasedNode(
|
||||
parameters: INodeParameters,
|
||||
nodeType: string,
|
||||
typeVersion: number
|
||||
): INodeParameters {
|
||||
const sanitized = { ...parameters };
|
||||
|
||||
// Handle IF node
|
||||
if (nodeType === 'n8n-nodes-base.if' && typeVersion >= 2.2) {
|
||||
sanitized.conditions = sanitizeFilterConditions(sanitized.conditions as any);
|
||||
}
|
||||
|
||||
// Handle Switch node
|
||||
if (nodeType === 'n8n-nodes-base.switch' && typeVersion >= 3.2) {
|
||||
if (sanitized.rules && typeof sanitized.rules === 'object') {
|
||||
const rules = sanitized.rules as any;
|
||||
if (rules.rules && Array.isArray(rules.rules)) {
|
||||
rules.rules = rules.rules.map((rule: any) => ({
|
||||
...rule,
|
||||
conditions: sanitizeFilterConditions(rule.conditions)
|
||||
}));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return sanitized;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sanitize filter conditions structure
|
||||
*/
|
||||
function sanitizeFilterConditions(conditions: any): any {
|
||||
if (!conditions || typeof conditions !== 'object') {
|
||||
return conditions;
|
||||
}
|
||||
|
||||
const sanitized = { ...conditions };
|
||||
|
||||
// Ensure options has complete structure
|
||||
if (!sanitized.options) {
|
||||
sanitized.options = {};
|
||||
}
|
||||
|
||||
// Add required filter options metadata
|
||||
const requiredOptions = {
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: true,
|
||||
typeValidation: 'strict'
|
||||
};
|
||||
|
||||
// Merge with existing options, preserving user values
|
||||
sanitized.options = {
|
||||
...requiredOptions,
|
||||
...sanitized.options
|
||||
};
|
||||
|
||||
// Sanitize conditions array
|
||||
if (sanitized.conditions && Array.isArray(sanitized.conditions)) {
|
||||
sanitized.conditions = sanitized.conditions.map((condition: any) =>
|
||||
sanitizeCondition(condition)
|
||||
);
|
||||
}
|
||||
|
||||
return sanitized;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sanitize a single condition
|
||||
*/
|
||||
function sanitizeCondition(condition: any): any {
|
||||
if (!condition || typeof condition !== 'object') {
|
||||
return condition;
|
||||
}
|
||||
|
||||
const sanitized = { ...condition };
|
||||
|
||||
// Ensure condition has an ID
|
||||
if (!sanitized.id) {
|
||||
sanitized.id = generateConditionId();
|
||||
}
|
||||
|
||||
// Sanitize operator structure
|
||||
if (sanitized.operator) {
|
||||
sanitized.operator = sanitizeOperator(sanitized.operator);
|
||||
}
|
||||
|
||||
return sanitized;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sanitize operator structure
|
||||
* Ensures operator has correct format: {type, operation, singleValue?}
|
||||
*/
|
||||
function sanitizeOperator(operator: any): any {
|
||||
if (!operator || typeof operator !== 'object') {
|
||||
return operator;
|
||||
}
|
||||
|
||||
const sanitized = { ...operator };
|
||||
|
||||
// Fix common mistake: type field used for operation name
|
||||
// WRONG: {type: "isNotEmpty"}
|
||||
// RIGHT: {type: "string", operation: "isNotEmpty"}
|
||||
if (sanitized.type && !sanitized.operation) {
|
||||
// Check if type value looks like an operation (lowercase, no dots)
|
||||
const typeValue = sanitized.type as string;
|
||||
if (isOperationName(typeValue)) {
|
||||
logger.debug(`Fixing operator structure: converting type="${typeValue}" to operation`);
|
||||
|
||||
// Infer data type from operation
|
||||
const dataType = inferDataType(typeValue);
|
||||
sanitized.type = dataType;
|
||||
sanitized.operation = typeValue;
|
||||
}
|
||||
}
|
||||
|
||||
// Set singleValue based on operator type
|
||||
if (sanitized.operation) {
|
||||
if (isUnaryOperator(sanitized.operation)) {
|
||||
// Unary operators require singleValue: true
|
||||
sanitized.singleValue = true;
|
||||
} else {
|
||||
// Binary operators should NOT have singleValue (or it should be false/undefined)
|
||||
// Remove it to prevent UI errors
|
||||
delete sanitized.singleValue;
|
||||
}
|
||||
}
|
||||
|
||||
return sanitized;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if string looks like an operation name (not a data type)
|
||||
*/
|
||||
function isOperationName(value: string): boolean {
|
||||
// Operation names are lowercase and don't contain dots
|
||||
// Data types are: string, number, boolean, dateTime, array, object
|
||||
const dataTypes = ['string', 'number', 'boolean', 'dateTime', 'array', 'object'];
|
||||
return !dataTypes.includes(value) && /^[a-z][a-zA-Z]*$/.test(value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Infer data type from operation name
|
||||
*/
|
||||
function inferDataType(operation: string): string {
|
||||
// Boolean operations
|
||||
const booleanOps = ['true', 'false', 'isEmpty', 'isNotEmpty'];
|
||||
if (booleanOps.includes(operation)) {
|
||||
return 'boolean';
|
||||
}
|
||||
|
||||
// Number operations
|
||||
const numberOps = ['isNumeric', 'gt', 'gte', 'lt', 'lte'];
|
||||
if (numberOps.some(op => operation.includes(op))) {
|
||||
return 'number';
|
||||
}
|
||||
|
||||
// Date operations
|
||||
const dateOps = ['after', 'before', 'afterDate', 'beforeDate'];
|
||||
if (dateOps.some(op => operation.includes(op))) {
|
||||
return 'dateTime';
|
||||
}
|
||||
|
||||
// Default to string
|
||||
return 'string';
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if operator is unary (requires singleValue: true)
|
||||
*/
|
||||
function isUnaryOperator(operation: string): boolean {
|
||||
const unaryOps = [
|
||||
'isEmpty',
|
||||
'isNotEmpty',
|
||||
'true',
|
||||
'false',
|
||||
'isNumeric'
|
||||
];
|
||||
return unaryOps.includes(operation);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate unique condition ID
|
||||
*/
|
||||
function generateConditionId(): string {
|
||||
return `condition-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate that a node has complete metadata
|
||||
* Returns array of issues found
|
||||
*/
|
||||
export function validateNodeMetadata(node: WorkflowNode): string[] {
|
||||
const issues: string[] = [];
|
||||
|
||||
if (!isFilterBasedNode(node.type, node.typeVersion)) {
|
||||
return issues; // Not a filter-based node
|
||||
}
|
||||
|
||||
// Check IF node
|
||||
if (node.type === 'n8n-nodes-base.if') {
|
||||
const conditions = (node.parameters.conditions as any);
|
||||
if (!conditions?.options) {
|
||||
issues.push('Missing conditions.options');
|
||||
} else {
|
||||
const required = ['version', 'leftValue', 'typeValidation', 'caseSensitive'];
|
||||
for (const field of required) {
|
||||
if (!(field in conditions.options)) {
|
||||
issues.push(`Missing conditions.options.${field}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check operators
|
||||
if (conditions?.conditions && Array.isArray(conditions.conditions)) {
|
||||
for (let i = 0; i < conditions.conditions.length; i++) {
|
||||
const condition = conditions.conditions[i];
|
||||
const operatorIssues = validateOperator(condition.operator, `conditions.conditions[${i}].operator`);
|
||||
issues.push(...operatorIssues);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check Switch node
|
||||
if (node.type === 'n8n-nodes-base.switch') {
|
||||
const rules = (node.parameters.rules as any);
|
||||
if (rules?.rules && Array.isArray(rules.rules)) {
|
||||
for (let i = 0; i < rules.rules.length; i++) {
|
||||
const rule = rules.rules[i];
|
||||
if (!rule.conditions?.options) {
|
||||
issues.push(`Missing rules.rules[${i}].conditions.options`);
|
||||
} else {
|
||||
const required = ['version', 'leftValue', 'typeValidation', 'caseSensitive'];
|
||||
for (const field of required) {
|
||||
if (!(field in rule.conditions.options)) {
|
||||
issues.push(`Missing rules.rules[${i}].conditions.options.${field}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check operators
|
||||
if (rule.conditions?.conditions && Array.isArray(rule.conditions.conditions)) {
|
||||
for (let j = 0; j < rule.conditions.conditions.length; j++) {
|
||||
const condition = rule.conditions.conditions[j];
|
||||
const operatorIssues = validateOperator(
|
||||
condition.operator,
|
||||
`rules.rules[${i}].conditions.conditions[${j}].operator`
|
||||
);
|
||||
issues.push(...operatorIssues);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return issues;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate operator structure
|
||||
*/
|
||||
function validateOperator(operator: any, path: string): string[] {
|
||||
const issues: string[] = [];
|
||||
|
||||
if (!operator || typeof operator !== 'object') {
|
||||
issues.push(`${path}: operator is missing or not an object`);
|
||||
return issues;
|
||||
}
|
||||
|
||||
if (!operator.type) {
|
||||
issues.push(`${path}: missing required field 'type'`);
|
||||
} else if (!['string', 'number', 'boolean', 'dateTime', 'array', 'object'].includes(operator.type)) {
|
||||
issues.push(`${path}: invalid type "${operator.type}" (must be data type, not operation)`);
|
||||
}
|
||||
|
||||
if (!operator.operation) {
|
||||
issues.push(`${path}: missing required field 'operation'`);
|
||||
}
|
||||
|
||||
// Check singleValue based on operator type
|
||||
if (operator.operation) {
|
||||
if (isUnaryOperator(operator.operation)) {
|
||||
// Unary operators MUST have singleValue: true
|
||||
if (operator.singleValue !== true) {
|
||||
issues.push(`${path}: unary operator "${operator.operation}" requires singleValue: true`);
|
||||
}
|
||||
} else {
|
||||
// Binary operators should NOT have singleValue
|
||||
if (operator.singleValue === true) {
|
||||
issues.push(`${path}: binary operator "${operator.operation}" should not have singleValue: true (only unary operators need this)`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return issues;
|
||||
}
|
||||
@@ -1038,9 +1038,16 @@ export class NodeSpecificValidators {
|
||||
delete autofix.continueOnFail;
|
||||
}
|
||||
|
||||
// Note: responseNode mode validation moved to workflow-validator.ts
|
||||
// where it has access to node-level onError property (not just config/parameters)
|
||||
|
||||
// Response mode validation
|
||||
if (responseMode === 'responseNode' && !config.onError && !config.continueOnFail) {
|
||||
errors.push({
|
||||
type: 'invalid_configuration',
|
||||
property: 'responseMode',
|
||||
message: 'responseNode mode requires onError: "continueRegularOutput"',
|
||||
fix: 'Set onError to ensure response is always sent'
|
||||
});
|
||||
}
|
||||
|
||||
// Always output data for debugging
|
||||
if (!config.alwaysOutputData) {
|
||||
suggestions.push('Enable alwaysOutputData to debug webhook payloads');
|
||||
|
||||
@@ -31,7 +31,6 @@ import {
|
||||
import { Workflow, WorkflowNode, WorkflowConnection } from '../types/n8n-api';
|
||||
import { Logger } from '../utils/logger';
|
||||
import { validateWorkflowNode, validateWorkflowConnections } from './n8n-validation';
|
||||
import { sanitizeNode, sanitizeWorkflowNodes } from './node-sanitizer';
|
||||
|
||||
const logger = new Logger({ prefix: '[WorkflowDiffEngine]' });
|
||||
|
||||
@@ -175,13 +174,6 @@ export class WorkflowDiffEngine {
|
||||
}
|
||||
}
|
||||
|
||||
// Sanitize ALL nodes in the workflow after operations are applied
|
||||
// This ensures existing invalid nodes (e.g., binary operators with singleValue: true)
|
||||
// are fixed automatically when any update is made to the workflow
|
||||
workflowCopy.nodes = workflowCopy.nodes.map((node: WorkflowNode) => sanitizeNode(node));
|
||||
|
||||
logger.debug('Applied full-workflow sanitization to all nodes');
|
||||
|
||||
// If validateOnly flag is set, return success without applying
|
||||
if (request.validateOnly) {
|
||||
return {
|
||||
@@ -534,11 +526,8 @@ export class WorkflowDiffEngine {
|
||||
alwaysOutputData: operation.node.alwaysOutputData,
|
||||
executeOnce: operation.node.executeOnce
|
||||
};
|
||||
|
||||
// Sanitize node to ensure complete metadata (filter options, operator structure, etc.)
|
||||
const sanitizedNode = sanitizeNode(newNode);
|
||||
|
||||
workflow.nodes.push(sanitizedNode);
|
||||
|
||||
workflow.nodes.push(newNode);
|
||||
}
|
||||
|
||||
private applyRemoveNode(workflow: Workflow, operation: RemoveNodeOperation): void {
|
||||
@@ -578,17 +567,11 @@ export class WorkflowDiffEngine {
|
||||
private applyUpdateNode(workflow: Workflow, operation: UpdateNodeOperation): void {
|
||||
const node = this.findNode(workflow, operation.nodeId, operation.nodeName);
|
||||
if (!node) return;
|
||||
|
||||
|
||||
// Apply updates using dot notation
|
||||
Object.entries(operation.updates).forEach(([path, value]) => {
|
||||
this.setNestedProperty(node, path, value);
|
||||
});
|
||||
|
||||
// Sanitize node after updates to ensure metadata is complete
|
||||
const sanitized = sanitizeNode(node);
|
||||
|
||||
// Update the node in-place
|
||||
Object.assign(node, sanitized);
|
||||
}
|
||||
|
||||
private applyMoveNode(workflow: Workflow, operation: MoveNodeOperation): void {
|
||||
|
||||
@@ -11,7 +11,6 @@ import { NodeSimilarityService, NodeSuggestion } from './node-similarity-service
|
||||
import { NodeTypeNormalizer } from '../utils/node-type-normalizer';
|
||||
import { Logger } from '../utils/logger';
|
||||
import { validateAISpecificNodes, hasAINodes } from './ai-node-validator';
|
||||
import { isNonExecutableNode } from '../utils/node-classification';
|
||||
const logger = new Logger({ prefix: '[WorkflowValidator]' });
|
||||
|
||||
interface WorkflowNode {
|
||||
@@ -86,8 +85,17 @@ export class WorkflowValidator {
|
||||
this.similarityService = new NodeSimilarityService(nodeRepository);
|
||||
}
|
||||
|
||||
// Note: isStickyNote logic moved to shared utility: src/utils/node-classification.ts
|
||||
// Use isNonExecutableNode(node.type) instead
|
||||
/**
|
||||
* Check if a node is a Sticky Note or other non-executable node
|
||||
*/
|
||||
private isStickyNote(node: WorkflowNode): boolean {
|
||||
const stickyNoteTypes = [
|
||||
'n8n-nodes-base.stickyNote',
|
||||
'nodes-base.stickyNote',
|
||||
'@n8n/n8n-nodes-base.stickyNote'
|
||||
];
|
||||
return stickyNoteTypes.includes(node.type);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate a complete workflow
|
||||
@@ -138,7 +146,7 @@ export class WorkflowValidator {
|
||||
}
|
||||
|
||||
// Update statistics after null check (exclude sticky notes from counts)
|
||||
const executableNodes = Array.isArray(workflow.nodes) ? workflow.nodes.filter(n => !isNonExecutableNode(n.type)) : [];
|
||||
const executableNodes = Array.isArray(workflow.nodes) ? workflow.nodes.filter(n => !this.isStickyNote(n)) : [];
|
||||
result.statistics.totalNodes = executableNodes.length;
|
||||
result.statistics.enabledNodes = executableNodes.filter(n => !n.disabled).length;
|
||||
|
||||
@@ -348,7 +356,7 @@ export class WorkflowValidator {
|
||||
profile: string
|
||||
): Promise<void> {
|
||||
for (const node of workflow.nodes) {
|
||||
if (node.disabled || isNonExecutableNode(node.type)) continue;
|
||||
if (node.disabled || this.isStickyNote(node)) continue;
|
||||
|
||||
try {
|
||||
// Validate node name length
|
||||
@@ -624,7 +632,7 @@ export class WorkflowValidator {
|
||||
|
||||
// Check for orphaned nodes (exclude sticky notes)
|
||||
for (const node of workflow.nodes) {
|
||||
if (node.disabled || isNonExecutableNode(node.type)) continue;
|
||||
if (node.disabled || this.isStickyNote(node)) continue;
|
||||
|
||||
const normalizedType = NodeTypeNormalizer.normalizeToFullForm(node.type);
|
||||
const isTrigger = normalizedType.toLowerCase().includes('trigger') ||
|
||||
@@ -869,7 +877,7 @@ export class WorkflowValidator {
|
||||
|
||||
// Build node type map (exclude sticky notes)
|
||||
workflow.nodes.forEach(node => {
|
||||
if (!isNonExecutableNode(node.type)) {
|
||||
if (!this.isStickyNote(node)) {
|
||||
nodeTypeMap.set(node.name, node.type);
|
||||
}
|
||||
});
|
||||
@@ -937,7 +945,7 @@ export class WorkflowValidator {
|
||||
|
||||
// Check from all executable nodes (exclude sticky notes)
|
||||
for (const node of workflow.nodes) {
|
||||
if (!isNonExecutableNode(node.type) && !visited.has(node.name)) {
|
||||
if (!this.isStickyNote(node) && !visited.has(node.name)) {
|
||||
if (hasCycleDFS(node.name)) return true;
|
||||
}
|
||||
}
|
||||
@@ -956,7 +964,7 @@ export class WorkflowValidator {
|
||||
const nodeNames = workflow.nodes.map(n => n.name);
|
||||
|
||||
for (const node of workflow.nodes) {
|
||||
if (node.disabled || isNonExecutableNode(node.type)) continue;
|
||||
if (node.disabled || this.isStickyNote(node)) continue;
|
||||
|
||||
// Skip expression validation for langchain nodes
|
||||
// They have AI-specific validators and different expression rules
|
||||
@@ -1103,7 +1111,7 @@ export class WorkflowValidator {
|
||||
|
||||
// Check node-level error handling properties for ALL executable nodes
|
||||
for (const node of workflow.nodes) {
|
||||
if (!isNonExecutableNode(node.type)) {
|
||||
if (!this.isStickyNote(node)) {
|
||||
this.checkNodeErrorHandling(node, workflow, result);
|
||||
}
|
||||
}
|
||||
@@ -1284,15 +1292,6 @@ export class WorkflowValidator {
|
||||
|
||||
/**
|
||||
* Check node-level error handling configuration for a single node
|
||||
*
|
||||
* Validates error handling properties (onError, continueOnFail, retryOnFail)
|
||||
* and provides warnings for error-prone nodes (HTTP, webhooks, databases)
|
||||
* that lack proper error handling. Delegates webhook-specific validation
|
||||
* to checkWebhookErrorHandling() for clearer logic.
|
||||
*
|
||||
* @param node - The workflow node to validate
|
||||
* @param workflow - The complete workflow for context
|
||||
* @param result - Validation result to add errors/warnings to
|
||||
*/
|
||||
private checkNodeErrorHandling(
|
||||
node: WorkflowNode,
|
||||
@@ -1503,8 +1502,12 @@ export class WorkflowValidator {
|
||||
message: 'HTTP Request node without error handling. Consider adding "onError: \'continueRegularOutput\'" for non-critical requests or "retryOnFail: true" for transient failures.'
|
||||
});
|
||||
} else if (normalizedType.includes('webhook')) {
|
||||
// Delegate to specialized webhook validation helper
|
||||
this.checkWebhookErrorHandling(node, normalizedType, result);
|
||||
result.warnings.push({
|
||||
type: 'warning',
|
||||
nodeId: node.id,
|
||||
nodeName: node.name,
|
||||
message: 'Webhook node without error handling. Consider adding "onError: \'continueRegularOutput\'" to prevent workflow failures from blocking webhook responses.'
|
||||
});
|
||||
} else if (errorProneNodeTypes.some(db => normalizedType.includes(db) && ['postgres', 'mysql', 'mongodb'].includes(db))) {
|
||||
result.warnings.push({
|
||||
type: 'warning',
|
||||
@@ -1595,52 +1598,6 @@ export class WorkflowValidator {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Check webhook-specific error handling requirements
|
||||
*
|
||||
* Webhooks have special error handling requirements:
|
||||
* - respondToWebhook nodes (response nodes) don't need error handling
|
||||
* - Webhook nodes with responseNode mode REQUIRE onError to ensure responses
|
||||
* - Regular webhook nodes should have error handling to prevent blocking
|
||||
*
|
||||
* @param node - The webhook node to check
|
||||
* @param normalizedType - Normalized node type for comparison
|
||||
* @param result - Validation result to add errors/warnings to
|
||||
*/
|
||||
private checkWebhookErrorHandling(
|
||||
node: WorkflowNode,
|
||||
normalizedType: string,
|
||||
result: WorkflowValidationResult
|
||||
): void {
|
||||
// respondToWebhook nodes are response nodes (endpoints), not triggers
|
||||
// They're the END of execution, not controllers of flow - skip error handling check
|
||||
if (normalizedType.includes('respondtowebhook')) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Check for responseNode mode specifically
|
||||
// responseNode mode requires onError to ensure response is sent even on error
|
||||
if (node.parameters?.responseMode === 'responseNode') {
|
||||
if (!node.onError && !node.continueOnFail) {
|
||||
result.errors.push({
|
||||
type: 'error',
|
||||
nodeId: node.id,
|
||||
nodeName: node.name,
|
||||
message: 'responseNode mode requires onError: "continueRegularOutput"'
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Regular webhook nodes without responseNode mode
|
||||
result.warnings.push({
|
||||
type: 'warning',
|
||||
nodeId: node.id,
|
||||
nodeName: node.name,
|
||||
message: 'Webhook node without error handling. Consider adding "onError: \'continueRegularOutput\'" to prevent workflow failures from blocking webhook responses.'
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate error handling suggestions based on all nodes
|
||||
*/
|
||||
|
||||
@@ -1,109 +0,0 @@
|
||||
/**
|
||||
* Utility functions for detecting and handling n8n expressions
|
||||
*/
|
||||
|
||||
/**
|
||||
* Detects if a value is an n8n expression
|
||||
*
|
||||
* n8n expressions can be:
|
||||
* - Pure expression: `={{ $json.value }}`
|
||||
* - Mixed content: `=https://api.com/{{ $json.id }}/data`
|
||||
* - Prefix-only: `=$json.value`
|
||||
*
|
||||
* @param value - The value to check
|
||||
* @returns true if the value is an expression (starts with =)
|
||||
*/
|
||||
export function isExpression(value: unknown): value is string {
|
||||
return typeof value === 'string' && value.startsWith('=');
|
||||
}
|
||||
|
||||
/**
|
||||
* Detects if a string contains n8n expression syntax {{ }}
|
||||
*
|
||||
* This checks for expression markers within the string,
|
||||
* regardless of whether it has the = prefix.
|
||||
*
|
||||
* @param value - The value to check
|
||||
* @returns true if the value contains {{ }} markers
|
||||
*/
|
||||
export function containsExpression(value: unknown): boolean {
|
||||
if (typeof value !== 'string') {
|
||||
return false;
|
||||
}
|
||||
// Use single regex for better performance than two includes()
|
||||
return /\{\{.*\}\}/s.test(value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Detects if a value should skip literal validation
|
||||
*
|
||||
* This is the main utility to use before validating values like URLs, JSON, etc.
|
||||
* It returns true if:
|
||||
* - The value is an expression (starts with =)
|
||||
* - OR the value contains expression markers {{ }}
|
||||
*
|
||||
* @param value - The value to check
|
||||
* @returns true if validation should be skipped
|
||||
*/
|
||||
export function shouldSkipLiteralValidation(value: unknown): boolean {
|
||||
return isExpression(value) || containsExpression(value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Extracts the expression content from a value
|
||||
*
|
||||
* If value is `={{ $json.value }}`, returns `$json.value`
|
||||
* If value is `=$json.value`, returns `$json.value`
|
||||
* If value is not an expression, returns the original value
|
||||
*
|
||||
* @param value - The value to extract from
|
||||
* @returns The expression content or original value
|
||||
*/
|
||||
export function extractExpressionContent(value: string): string {
|
||||
if (!isExpression(value)) {
|
||||
return value;
|
||||
}
|
||||
|
||||
const withoutPrefix = value.substring(1); // Remove =
|
||||
|
||||
// Check if it's wrapped in {{ }}
|
||||
const match = withoutPrefix.match(/^\{\{(.+)\}\}$/s);
|
||||
if (match) {
|
||||
return match[1].trim();
|
||||
}
|
||||
|
||||
return withoutPrefix;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a value is a mixed content expression
|
||||
*
|
||||
* Mixed content has both literal text and expressions:
|
||||
* - `Hello {{ $json.name }}!`
|
||||
* - `https://api.com/{{ $json.id }}/data`
|
||||
*
|
||||
* @param value - The value to check
|
||||
* @returns true if the value has mixed content
|
||||
*/
|
||||
export function hasMixedContent(value: unknown): boolean {
|
||||
// Type guard first to avoid calling containsExpression on non-strings
|
||||
if (typeof value !== 'string') {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!containsExpression(value)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// If it's wrapped entirely in {{ }}, it's not mixed
|
||||
const trimmed = value.trim();
|
||||
if (trimmed.startsWith('={{') && trimmed.endsWith('}}')) {
|
||||
// Check if there's only one pair of {{ }}
|
||||
const count = (trimmed.match(/\{\{/g) || []).length;
|
||||
if (count === 1) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -1,121 +0,0 @@
|
||||
/**
|
||||
* Node Classification Utilities
|
||||
*
|
||||
* Provides shared classification logic for workflow nodes.
|
||||
* Used by validators to consistently identify node types across the codebase.
|
||||
*
|
||||
* This module centralizes node type classification to ensure consistent behavior
|
||||
* between WorkflowValidator and n8n-validation.ts, preventing bugs like sticky
|
||||
* notes being incorrectly flagged as disconnected nodes.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Check if a node type is a sticky note (documentation-only node)
|
||||
*
|
||||
* Sticky notes are UI-only annotation nodes that:
|
||||
* - Do not participate in workflow execution
|
||||
* - Never have connections (by design)
|
||||
* - Should be excluded from connection validation
|
||||
* - Serve purely as visual documentation in the workflow canvas
|
||||
*
|
||||
* Example sticky note types:
|
||||
* - 'n8n-nodes-base.stickyNote' (standard format)
|
||||
* - 'nodes-base.stickyNote' (normalized format)
|
||||
* - '@n8n/n8n-nodes-base.stickyNote' (scoped format)
|
||||
*
|
||||
* @param nodeType - The node type to check (e.g., 'n8n-nodes-base.stickyNote')
|
||||
* @returns true if the node is a sticky note, false otherwise
|
||||
*/
|
||||
export function isStickyNote(nodeType: string): boolean {
|
||||
const stickyNoteTypes = [
|
||||
'n8n-nodes-base.stickyNote',
|
||||
'nodes-base.stickyNote',
|
||||
'@n8n/n8n-nodes-base.stickyNote'
|
||||
];
|
||||
return stickyNoteTypes.includes(nodeType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a node type is a trigger node
|
||||
*
|
||||
* Trigger nodes:
|
||||
* - Start workflow execution
|
||||
* - Only need outgoing connections (no incoming connections required)
|
||||
* - Include webhooks, manual triggers, schedule triggers, etc.
|
||||
* - Are the entry points for workflow execution
|
||||
*
|
||||
* Examples:
|
||||
* - Webhooks: Listen for HTTP requests
|
||||
* - Manual triggers: Started manually by user
|
||||
* - Schedule/Cron triggers: Run on a schedule
|
||||
*
|
||||
* @param nodeType - The node type to check
|
||||
* @returns true if the node is a trigger, false otherwise
|
||||
*/
|
||||
export function isTriggerNode(nodeType: string): boolean {
|
||||
const triggerTypes = [
|
||||
'n8n-nodes-base.webhook',
|
||||
'n8n-nodes-base.webhookTrigger',
|
||||
'n8n-nodes-base.manualTrigger',
|
||||
'n8n-nodes-base.cronTrigger',
|
||||
'n8n-nodes-base.scheduleTrigger'
|
||||
];
|
||||
return triggerTypes.includes(nodeType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a node type is non-executable (UI-only)
|
||||
*
|
||||
* Non-executable nodes:
|
||||
* - Do not participate in workflow execution
|
||||
* - Serve documentation/annotation purposes only
|
||||
* - Should be excluded from all execution-related validation
|
||||
* - Should be excluded from statistics like "total executable nodes"
|
||||
* - Should be excluded from connection validation
|
||||
*
|
||||
* Currently includes: sticky notes
|
||||
*
|
||||
* Future: May include other annotation/comment nodes if n8n adds them
|
||||
*
|
||||
* @param nodeType - The node type to check
|
||||
* @returns true if the node is non-executable, false otherwise
|
||||
*/
|
||||
export function isNonExecutableNode(nodeType: string): boolean {
|
||||
return isStickyNote(nodeType);
|
||||
// Future: Add other non-executable node types here
|
||||
// Example: || isCommentNode(nodeType) || isAnnotationNode(nodeType)
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a node type requires incoming connections
|
||||
*
|
||||
* Most nodes require at least one incoming connection to receive data,
|
||||
* but there are two categories of exceptions:
|
||||
*
|
||||
* 1. Trigger nodes: Only need outgoing connections
|
||||
* - They start workflow execution
|
||||
* - They generate their own data
|
||||
* - Examples: webhook, manualTrigger, scheduleTrigger
|
||||
*
|
||||
* 2. Non-executable nodes: Don't need any connections
|
||||
* - They are UI-only annotations
|
||||
* - They don't participate in execution
|
||||
* - Examples: stickyNote
|
||||
*
|
||||
* @param nodeType - The node type to check
|
||||
* @returns true if the node requires incoming connections, false otherwise
|
||||
*/
|
||||
export function requiresIncomingConnection(nodeType: string): boolean {
|
||||
// Non-executable nodes don't need any connections
|
||||
if (isNonExecutableNode(nodeType)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Trigger nodes only need outgoing connections
|
||||
if (isTriggerNode(nodeType)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Regular nodes need incoming connections
|
||||
return true;
|
||||
}
|
||||
@@ -205,20 +205,9 @@ describe.skipIf(!dbExists)('Database Content Validation', () => {
|
||||
|
||||
it('MUST have FTS5 index properly ranked', () => {
|
||||
const results = db.prepare(`
|
||||
SELECT
|
||||
n.node_type,
|
||||
rank
|
||||
FROM nodes n
|
||||
JOIN nodes_fts ON n.rowid = nodes_fts.rowid
|
||||
SELECT node_type, rank FROM nodes_fts
|
||||
WHERE nodes_fts MATCH 'webhook'
|
||||
ORDER BY
|
||||
CASE
|
||||
WHEN LOWER(n.display_name) = LOWER('webhook') THEN 0
|
||||
WHEN LOWER(n.display_name) LIKE LOWER('%webhook%') THEN 1
|
||||
WHEN LOWER(n.node_type) LIKE LOWER('%webhook%') THEN 2
|
||||
ELSE 3
|
||||
END,
|
||||
rank
|
||||
ORDER BY rank
|
||||
LIMIT 5
|
||||
`).all();
|
||||
|
||||
@@ -226,7 +215,7 @@ describe.skipIf(!dbExists)('Database Content Validation', () => {
|
||||
'CRITICAL: FTS5 ranking not working. Search quality will be degraded.'
|
||||
).toBeGreaterThan(0);
|
||||
|
||||
// Exact match should be in top results (using production boosting logic with CASE-first ordering)
|
||||
// Exact match should be in top results
|
||||
const topNodes = results.slice(0, 3).map((r: any) => r.node_type);
|
||||
expect(topNodes,
|
||||
'WARNING: Exact match "nodes-base.webhook" not in top 3 ranked results'
|
||||
|
||||
@@ -136,25 +136,14 @@ describe('Node FTS5 Search Integration Tests', () => {
|
||||
describe('FTS5 Search Quality', () => {
|
||||
it('should rank exact matches higher', () => {
|
||||
const results = db.prepare(`
|
||||
SELECT
|
||||
n.node_type,
|
||||
rank
|
||||
FROM nodes n
|
||||
JOIN nodes_fts ON n.rowid = nodes_fts.rowid
|
||||
SELECT node_type, rank FROM nodes_fts
|
||||
WHERE nodes_fts MATCH 'webhook'
|
||||
ORDER BY
|
||||
CASE
|
||||
WHEN LOWER(n.display_name) = LOWER('webhook') THEN 0
|
||||
WHEN LOWER(n.display_name) LIKE LOWER('%webhook%') THEN 1
|
||||
WHEN LOWER(n.node_type) LIKE LOWER('%webhook%') THEN 2
|
||||
ELSE 3
|
||||
END,
|
||||
rank
|
||||
ORDER BY rank
|
||||
LIMIT 10
|
||||
`).all();
|
||||
|
||||
expect(results.length).toBeGreaterThan(0);
|
||||
// Exact match should be in top results (using production boosting logic with CASE-first ordering)
|
||||
// Exact match should be in top results
|
||||
const topResults = results.slice(0, 3).map((r: any) => r.node_type);
|
||||
expect(topResults).toContain('nodes-base.webhook');
|
||||
});
|
||||
|
||||
@@ -33,14 +33,10 @@ describe('Integration: Smart Parameters with Real n8n API', () => {
|
||||
context = createTestContext();
|
||||
client = getTestN8nClient();
|
||||
mcpContext = createMcpContext();
|
||||
// Skip workflow validation for these tests - they test n8n API behavior with edge cases
|
||||
process.env.SKIP_WORKFLOW_VALIDATION = 'true';
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await context.cleanup();
|
||||
// Clean up environment variable
|
||||
delete process.env.SKIP_WORKFLOW_VALIDATION;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
@@ -137,7 +133,6 @@ describe('Integration: Smart Parameters with Real n8n API', () => {
|
||||
mcpContext
|
||||
);
|
||||
|
||||
if (!result.success) console.log("VALIDATION ERROR:", JSON.stringify(result, null, 2));
|
||||
expect(result.success).toBe(true);
|
||||
|
||||
// Fetch actual workflow from n8n API
|
||||
|
||||
@@ -56,7 +56,7 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
if (!created.id) throw new Error('Workflow ID is missing');
|
||||
context.trackWorkflow(created.id);
|
||||
|
||||
// Add a Set node and connect it to maintain workflow validity
|
||||
// Add a Set node
|
||||
const response = await handleUpdatePartialWorkflow(
|
||||
{
|
||||
id: created.id,
|
||||
@@ -81,13 +81,6 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
type: 'addConnection',
|
||||
source: 'Webhook',
|
||||
target: 'Set',
|
||||
sourcePort: 'main',
|
||||
targetPort: 'main'
|
||||
}
|
||||
]
|
||||
},
|
||||
@@ -461,7 +454,7 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
});
|
||||
|
||||
describe('removeConnection', () => {
|
||||
it('should reject removal of last connection (creates invalid workflow)', async () => {
|
||||
it('should remove connection between nodes', async () => {
|
||||
const workflow = {
|
||||
...SIMPLE_HTTP_WORKFLOW,
|
||||
name: createTestWorkflowName('Partial - Remove Connection'),
|
||||
@@ -473,7 +466,6 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
if (!created.id) throw new Error('Workflow ID is missing');
|
||||
context.trackWorkflow(created.id);
|
||||
|
||||
// Try to remove the only connection - should be rejected (leaves 2 nodes with no connections)
|
||||
const response = await handleUpdatePartialWorkflow(
|
||||
{
|
||||
id: created.id,
|
||||
@@ -481,18 +473,16 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
{
|
||||
type: 'removeConnection',
|
||||
source: 'Webhook',
|
||||
target: 'HTTP Request',
|
||||
sourcePort: 'main',
|
||||
targetPort: 'main'
|
||||
target: 'HTTP Request'
|
||||
}
|
||||
]
|
||||
},
|
||||
mcpContext
|
||||
);
|
||||
|
||||
// Should fail validation - multi-node workflow needs connections
|
||||
expect(response.success).toBe(false);
|
||||
expect(response.error).toContain('Workflow validation failed');
|
||||
expect(response.success).toBe(true);
|
||||
const updated = response.data as any;
|
||||
expect(Object.keys(updated.connections || {})).toHaveLength(0);
|
||||
});
|
||||
|
||||
it('should ignore error for non-existent connection with ignoreErrors flag', async () => {
|
||||
@@ -528,7 +518,7 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
});
|
||||
|
||||
describe('replaceConnections', () => {
|
||||
it('should reject replacing with empty connections (creates invalid workflow)', async () => {
|
||||
it('should replace all connections', async () => {
|
||||
const workflow = {
|
||||
...SIMPLE_HTTP_WORKFLOW,
|
||||
name: createTestWorkflowName('Partial - Replace Connections'),
|
||||
@@ -540,7 +530,7 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
if (!created.id) throw new Error('Workflow ID is missing');
|
||||
context.trackWorkflow(created.id);
|
||||
|
||||
// Try to replace with empty connections - should be rejected (leaves 2 nodes with no connections)
|
||||
// Replace with empty connections
|
||||
const response = await handleUpdatePartialWorkflow(
|
||||
{
|
||||
id: created.id,
|
||||
@@ -554,9 +544,9 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
mcpContext
|
||||
);
|
||||
|
||||
// Should fail validation - multi-node workflow needs connections
|
||||
expect(response.success).toBe(false);
|
||||
expect(response.error).toContain('Workflow validation failed');
|
||||
expect(response.success).toBe(true);
|
||||
const updated = response.data as any;
|
||||
expect(Object.keys(updated.connections || {})).toHaveLength(0);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -877,190 +867,4 @@ describe('Integration: handleUpdatePartialWorkflow', () => {
|
||||
expect(response.details?.failed).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
// ======================================================================
|
||||
// WORKFLOW STRUCTURE VALIDATION (prevents corrupted workflows)
|
||||
// ======================================================================
|
||||
|
||||
describe('Workflow Structure Validation', () => {
|
||||
it('should reject removal of all connections in multi-node workflow', async () => {
|
||||
// Create workflow with 2 nodes and 1 connection
|
||||
const workflow = {
|
||||
...SIMPLE_HTTP_WORKFLOW,
|
||||
name: createTestWorkflowName('Partial - Reject Empty Connections'),
|
||||
tags: ['mcp-integration-test']
|
||||
};
|
||||
|
||||
const created = await client.createWorkflow(workflow);
|
||||
expect(created.id).toBeTruthy();
|
||||
if (!created.id) throw new Error('Workflow ID is missing');
|
||||
context.trackWorkflow(created.id);
|
||||
|
||||
// Try to remove the only connection - should be rejected
|
||||
const response = await handleUpdatePartialWorkflow(
|
||||
{
|
||||
id: created.id,
|
||||
operations: [
|
||||
{
|
||||
type: 'removeConnection',
|
||||
source: 'Webhook',
|
||||
target: 'HTTP Request',
|
||||
sourcePort: 'main',
|
||||
targetPort: 'main'
|
||||
}
|
||||
]
|
||||
},
|
||||
mcpContext
|
||||
);
|
||||
|
||||
// Should fail validation
|
||||
expect(response.success).toBe(false);
|
||||
expect(response.error).toContain('Workflow validation failed');
|
||||
expect(response.details?.errors).toBeDefined();
|
||||
expect(Array.isArray(response.details?.errors)).toBe(true);
|
||||
expect((response.details?.errors as string[])[0]).toContain('no connections');
|
||||
});
|
||||
|
||||
it('should reject removal of all nodes except one non-webhook node', async () => {
|
||||
// Create workflow with 4 nodes: Webhook, Set 1, Set 2, Merge
|
||||
const workflow = {
|
||||
...MULTI_NODE_WORKFLOW,
|
||||
name: createTestWorkflowName('Partial - Reject Single Non-Webhook'),
|
||||
tags: ['mcp-integration-test']
|
||||
};
|
||||
|
||||
const created = await client.createWorkflow(workflow);
|
||||
expect(created.id).toBeTruthy();
|
||||
if (!created.id) throw new Error('Workflow ID is missing');
|
||||
context.trackWorkflow(created.id);
|
||||
|
||||
// Try to remove all nodes except Merge node (non-webhook) - should be rejected
|
||||
const response = await handleUpdatePartialWorkflow(
|
||||
{
|
||||
id: created.id,
|
||||
operations: [
|
||||
{
|
||||
type: 'removeNode',
|
||||
nodeName: 'Webhook'
|
||||
},
|
||||
{
|
||||
type: 'removeNode',
|
||||
nodeName: 'Set 1'
|
||||
},
|
||||
{
|
||||
type: 'removeNode',
|
||||
nodeName: 'Set 2'
|
||||
}
|
||||
]
|
||||
},
|
||||
mcpContext
|
||||
);
|
||||
|
||||
// Should fail validation
|
||||
expect(response.success).toBe(false);
|
||||
expect(response.error).toContain('Workflow validation failed');
|
||||
expect(response.details?.errors).toBeDefined();
|
||||
expect(Array.isArray(response.details?.errors)).toBe(true);
|
||||
expect((response.details?.errors as string[])[0]).toContain('Single non-webhook node');
|
||||
});
|
||||
|
||||
it('should allow valid partial updates that maintain workflow integrity', async () => {
|
||||
// Create workflow with 4 nodes
|
||||
const workflow = {
|
||||
...MULTI_NODE_WORKFLOW,
|
||||
name: createTestWorkflowName('Partial - Valid Update'),
|
||||
tags: ['mcp-integration-test']
|
||||
};
|
||||
|
||||
const created = await client.createWorkflow(workflow);
|
||||
expect(created.id).toBeTruthy();
|
||||
if (!created.id) throw new Error('Workflow ID is missing');
|
||||
context.trackWorkflow(created.id);
|
||||
|
||||
// Valid update: add a node and connect it
|
||||
const response = await handleUpdatePartialWorkflow(
|
||||
{
|
||||
id: created.id,
|
||||
operations: [
|
||||
{
|
||||
type: 'addNode',
|
||||
node: {
|
||||
name: 'Process Data',
|
||||
type: 'n8n-nodes-base.set',
|
||||
typeVersion: 3.4,
|
||||
position: [850, 300],
|
||||
parameters: {
|
||||
assignments: {
|
||||
assignments: []
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
type: 'addConnection',
|
||||
source: 'Merge',
|
||||
target: 'Process Data',
|
||||
sourcePort: 'main',
|
||||
targetPort: 'main'
|
||||
}
|
||||
]
|
||||
},
|
||||
mcpContext
|
||||
);
|
||||
|
||||
// Should succeed
|
||||
expect(response.success).toBe(true);
|
||||
const updated = response.data as any;
|
||||
expect(updated.nodes).toHaveLength(5); // Original 4 + 1 new
|
||||
expect(updated.nodes.find((n: any) => n.name === 'Process Data')).toBeDefined();
|
||||
});
|
||||
|
||||
it('should reject adding node without connecting it (disconnected node)', async () => {
|
||||
// Create workflow with 2 connected nodes
|
||||
const workflow = {
|
||||
...SIMPLE_HTTP_WORKFLOW,
|
||||
name: createTestWorkflowName('Partial - Reject Disconnected Node'),
|
||||
tags: ['mcp-integration-test']
|
||||
};
|
||||
|
||||
const created = await client.createWorkflow(workflow);
|
||||
expect(created.id).toBeTruthy();
|
||||
if (!created.id) throw new Error('Workflow ID is missing');
|
||||
context.trackWorkflow(created.id);
|
||||
|
||||
// Try to add a third node WITHOUT connecting it - should be rejected
|
||||
const response = await handleUpdatePartialWorkflow(
|
||||
{
|
||||
id: created.id,
|
||||
operations: [
|
||||
{
|
||||
type: 'addNode',
|
||||
node: {
|
||||
name: 'Disconnected Set',
|
||||
type: 'n8n-nodes-base.set',
|
||||
typeVersion: 3.4,
|
||||
position: [800, 300],
|
||||
parameters: {
|
||||
assignments: {
|
||||
assignments: []
|
||||
}
|
||||
}
|
||||
}
|
||||
// Note: No connection operation - this creates a disconnected node
|
||||
}
|
||||
]
|
||||
},
|
||||
mcpContext
|
||||
);
|
||||
|
||||
// Should fail validation - disconnected node detected
|
||||
expect(response.success).toBe(false);
|
||||
expect(response.error).toContain('Workflow validation failed');
|
||||
expect(response.details?.errors).toBeDefined();
|
||||
expect(Array.isArray(response.details?.errors)).toBe(true);
|
||||
const errorMessage = (response.details?.errors as string[])[0];
|
||||
expect(errorMessage).toContain('Disconnected nodes detected');
|
||||
expect(errorMessage).toContain('Disconnected Set');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -53,8 +53,8 @@ describe('handlers-workflow-diff', () => {
|
||||
},
|
||||
],
|
||||
connections: {
|
||||
'Start': {
|
||||
main: [[{ node: 'HTTP Request', type: 'main', index: 0 }]],
|
||||
node1: {
|
||||
main: [[{ node: 'node2', type: 'main', index: 0 }]],
|
||||
},
|
||||
},
|
||||
createdAt: '2024-01-01T00:00:00Z',
|
||||
@@ -104,12 +104,6 @@ describe('handlers-workflow-diff', () => {
|
||||
parameters: {},
|
||||
},
|
||||
],
|
||||
connections: {
|
||||
...testWorkflow.connections,
|
||||
'HTTP Request': {
|
||||
main: [[{ node: 'New Node', type: 'main', index: 0 }]],
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
const diffRequest = {
|
||||
@@ -233,27 +227,7 @@ describe('handlers-workflow-diff', () => {
|
||||
mockApiClient.getWorkflow.mockResolvedValue(testWorkflow);
|
||||
mockDiffEngine.applyDiff.mockResolvedValue({
|
||||
success: true,
|
||||
workflow: {
|
||||
...testWorkflow,
|
||||
nodes: [
|
||||
{ ...testWorkflow.nodes[0], name: 'Updated Start' },
|
||||
testWorkflow.nodes[1],
|
||||
{
|
||||
id: 'node3',
|
||||
name: 'Set Node',
|
||||
type: 'n8n-nodes-base.set',
|
||||
typeVersion: 1,
|
||||
position: [500, 100],
|
||||
parameters: {},
|
||||
}
|
||||
],
|
||||
connections: {
|
||||
'Updated Start': testWorkflow.connections['Start'],
|
||||
'HTTP Request': {
|
||||
main: [[{ node: 'Set Node', type: 'main', index: 0 }]],
|
||||
},
|
||||
},
|
||||
},
|
||||
workflow: { ...testWorkflow, nodes: [...testWorkflow.nodes, {}] },
|
||||
operationsApplied: 3,
|
||||
message: 'Successfully applied 3 operations',
|
||||
errors: [],
|
||||
|
||||
@@ -1,532 +0,0 @@
|
||||
import { describe, test, expect } from 'vitest';
|
||||
import { validateWorkflowStructure } from '@/services/n8n-validation';
|
||||
import type { Workflow } from '@/types/n8n-api';
|
||||
|
||||
describe('n8n-validation - Sticky Notes Bug Fix', () => {
|
||||
describe('sticky notes should be excluded from disconnected nodes validation', () => {
|
||||
test('should allow workflow with sticky notes and connected functional nodes', () => {
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Test Workflow',
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/test' }
|
||||
},
|
||||
{
|
||||
id: '2',
|
||||
name: 'HTTP Request',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
typeVersion: 3,
|
||||
position: [450, 300],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'sticky1',
|
||||
name: 'Documentation Note',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [250, 100],
|
||||
parameters: { content: 'This is a documentation note' }
|
||||
}
|
||||
],
|
||||
connections: {
|
||||
'Webhook': {
|
||||
main: [[{ node: 'HTTP Request', type: 'main', index: 0 }]]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Should have no errors - sticky note should be ignored
|
||||
expect(errors).toEqual([]);
|
||||
});
|
||||
|
||||
test('should handle multiple sticky notes without errors', () => {
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Documented Workflow',
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/test' }
|
||||
},
|
||||
{
|
||||
id: '2',
|
||||
name: 'Process',
|
||||
type: 'n8n-nodes-base.set',
|
||||
typeVersion: 3,
|
||||
position: [450, 300],
|
||||
parameters: {}
|
||||
},
|
||||
// 10 sticky notes for documentation
|
||||
...Array.from({ length: 10 }, (_, i) => ({
|
||||
id: `sticky${i}`,
|
||||
name: `📝 Note ${i}`,
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [100 + i * 50, 100] as [number, number],
|
||||
parameters: { content: `Documentation note ${i}` }
|
||||
}))
|
||||
],
|
||||
connections: {
|
||||
'Webhook': {
|
||||
main: [[{ node: 'Process', type: 'main', index: 0 }]]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
expect(errors).toEqual([]);
|
||||
});
|
||||
|
||||
test('should handle all sticky note type variations', () => {
|
||||
const stickyTypes = [
|
||||
'n8n-nodes-base.stickyNote',
|
||||
'nodes-base.stickyNote',
|
||||
'@n8n/n8n-nodes-base.stickyNote'
|
||||
];
|
||||
|
||||
stickyTypes.forEach((stickyType, index) => {
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Test Workflow',
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/test' }
|
||||
},
|
||||
{
|
||||
id: `sticky${index}`,
|
||||
name: `Note ${index}`,
|
||||
type: stickyType,
|
||||
typeVersion: 1,
|
||||
position: [250, 100],
|
||||
parameters: { content: `Note ${index}` }
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Sticky note should be ignored regardless of type variation
|
||||
expect(errors.every(e => !e.includes(`Note ${index}`))).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
test('should handle complex workflow with multiple sticky notes (real-world scenario)', () => {
|
||||
// Simulates workflow like "POST /auth/login" with 4 sticky notes
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'POST /auth/login',
|
||||
nodes: [
|
||||
{
|
||||
id: 'webhook1',
|
||||
name: 'Webhook Trigger',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/auth/login', httpMethod: 'POST' }
|
||||
},
|
||||
{
|
||||
id: 'http1',
|
||||
name: 'Authenticate',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
typeVersion: 3,
|
||||
position: [450, 300],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'respond1',
|
||||
name: 'Return Success',
|
||||
type: 'n8n-nodes-base.respondToWebhook',
|
||||
typeVersion: 1,
|
||||
position: [650, 250],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'respond2',
|
||||
name: 'Return Error',
|
||||
type: 'n8n-nodes-base.respondToWebhook',
|
||||
typeVersion: 1,
|
||||
position: [650, 350],
|
||||
parameters: {}
|
||||
},
|
||||
// 4 sticky notes for documentation
|
||||
{
|
||||
id: 'sticky1',
|
||||
name: '📝 Webhook Trigger',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [250, 150],
|
||||
parameters: { content: 'Receives login request' }
|
||||
},
|
||||
{
|
||||
id: 'sticky2',
|
||||
name: '📝 Authenticate with Supabase',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [450, 150],
|
||||
parameters: { content: 'Validates credentials' }
|
||||
},
|
||||
{
|
||||
id: 'sticky3',
|
||||
name: '📝 Return Tokens',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [650, 150],
|
||||
parameters: { content: 'Returns access and refresh tokens' }
|
||||
},
|
||||
{
|
||||
id: 'sticky4',
|
||||
name: '📝 Return Error',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [650, 450],
|
||||
parameters: { content: 'Returns error message' }
|
||||
}
|
||||
],
|
||||
connections: {
|
||||
'Webhook Trigger': {
|
||||
main: [[{ node: 'Authenticate', type: 'main', index: 0 }]]
|
||||
},
|
||||
'Authenticate': {
|
||||
main: [
|
||||
[{ node: 'Return Success', type: 'main', index: 0 }],
|
||||
[{ node: 'Return Error', type: 'main', index: 0 }]
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Should have no errors - all sticky notes should be ignored
|
||||
expect(errors).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('validation should still detect truly disconnected functional nodes', () => {
|
||||
test('should detect disconnected HTTP node but ignore sticky note', () => {
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Test Workflow',
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/test' }
|
||||
},
|
||||
{
|
||||
id: '2',
|
||||
name: 'Disconnected HTTP',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
typeVersion: 3,
|
||||
position: [450, 300],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'sticky1',
|
||||
name: 'Sticky Note',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [250, 100],
|
||||
parameters: { content: 'Note' }
|
||||
}
|
||||
],
|
||||
connections: {} // No connections
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Should error on HTTP node, but NOT on sticky note
|
||||
expect(errors.length).toBeGreaterThan(0);
|
||||
const disconnectedError = errors.find(e => e.includes('Disconnected'));
|
||||
expect(disconnectedError).toBeDefined();
|
||||
expect(disconnectedError).toContain('Disconnected HTTP');
|
||||
expect(disconnectedError).not.toContain('Sticky Note');
|
||||
});
|
||||
|
||||
test('should detect multiple disconnected functional nodes but ignore sticky notes', () => {
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Test Workflow',
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/test' }
|
||||
},
|
||||
{
|
||||
id: '2',
|
||||
name: 'Disconnected HTTP',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
typeVersion: 3,
|
||||
position: [450, 300],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: '3',
|
||||
name: 'Disconnected Set',
|
||||
type: 'n8n-nodes-base.set',
|
||||
typeVersion: 3,
|
||||
position: [650, 300],
|
||||
parameters: {}
|
||||
},
|
||||
// Multiple sticky notes that should be ignored
|
||||
{
|
||||
id: 'sticky1',
|
||||
name: 'Note 1',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [250, 100],
|
||||
parameters: { content: 'Note 1' }
|
||||
},
|
||||
{
|
||||
id: 'sticky2',
|
||||
name: 'Note 2',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [450, 100],
|
||||
parameters: { content: 'Note 2' }
|
||||
}
|
||||
],
|
||||
connections: {} // No connections
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Should error because there are no connections
|
||||
// When there are NO connections, validation shows "Multi-node workflow has no connections"
|
||||
// This is the expected behavior - it suggests connecting any two executable nodes
|
||||
expect(errors.length).toBeGreaterThan(0);
|
||||
const connectionError = errors.find(e => e.includes('no connections') || e.includes('Disconnected'));
|
||||
expect(connectionError).toBeDefined();
|
||||
// Error should NOT mention sticky notes
|
||||
expect(connectionError).not.toContain('Note 1');
|
||||
expect(connectionError).not.toContain('Note 2');
|
||||
});
|
||||
|
||||
test('should allow sticky notes but still validate functional node connections', () => {
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Test Workflow',
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/test' }
|
||||
},
|
||||
{
|
||||
id: '2',
|
||||
name: 'Connected HTTP',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
typeVersion: 3,
|
||||
position: [450, 300],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: '3',
|
||||
name: 'Disconnected Set',
|
||||
type: 'n8n-nodes-base.set',
|
||||
typeVersion: 3,
|
||||
position: [650, 300],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'sticky1',
|
||||
name: 'Sticky Note',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [250, 100],
|
||||
parameters: { content: 'Note' }
|
||||
}
|
||||
],
|
||||
connections: {
|
||||
'Webhook': {
|
||||
main: [[{ node: 'Connected HTTP', type: 'main', index: 0 }]]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Should error only on disconnected Set node
|
||||
expect(errors.length).toBeGreaterThan(0);
|
||||
const disconnectedError = errors.find(e => e.includes('Disconnected'));
|
||||
expect(disconnectedError).toBeDefined();
|
||||
expect(disconnectedError).toContain('Disconnected Set');
|
||||
expect(disconnectedError).not.toContain('Connected HTTP');
|
||||
expect(disconnectedError).not.toContain('Sticky Note');
|
||||
});
|
||||
});
|
||||
|
||||
describe('regression tests - ensure sticky notes work like in n8n UI', () => {
|
||||
test('single webhook with sticky notes should be valid (matches n8n UI behavior)', () => {
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Webhook Only with Notes',
|
||||
nodes: [
|
||||
{
|
||||
id: '1',
|
||||
name: 'Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/test' }
|
||||
},
|
||||
{
|
||||
id: 'sticky1',
|
||||
name: 'Usage Instructions',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [250, 100],
|
||||
parameters: { content: 'Call this webhook to trigger the workflow' }
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Webhook-only workflows are valid in n8n
|
||||
// Sticky notes should not affect this
|
||||
expect(errors).toEqual([]);
|
||||
});
|
||||
|
||||
test('workflow with only sticky notes should be invalid (no executable nodes)', () => {
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Only Notes',
|
||||
nodes: [
|
||||
{
|
||||
id: 'sticky1',
|
||||
name: 'Note 1',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [250, 100],
|
||||
parameters: { content: 'Note 1' }
|
||||
},
|
||||
{
|
||||
id: 'sticky2',
|
||||
name: 'Note 2',
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [450, 100],
|
||||
parameters: { content: 'Note 2' }
|
||||
}
|
||||
],
|
||||
connections: {}
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Should fail because there are no executable nodes
|
||||
expect(errors.length).toBeGreaterThan(0);
|
||||
expect(errors.some(e => e.includes('at least one executable node'))).toBe(true);
|
||||
});
|
||||
|
||||
test('complex production workflow structure should validate correctly', () => {
|
||||
// Tests a realistic production workflow structure
|
||||
const workflow: Partial<Workflow> = {
|
||||
name: 'Production API Endpoint',
|
||||
nodes: [
|
||||
// Functional nodes
|
||||
{
|
||||
id: 'webhook1',
|
||||
name: 'API Webhook',
|
||||
type: 'n8n-nodes-base.webhook',
|
||||
typeVersion: 1,
|
||||
position: [250, 300],
|
||||
parameters: { path: '/api/endpoint' }
|
||||
},
|
||||
{
|
||||
id: 'validate1',
|
||||
name: 'Validate Input',
|
||||
type: 'n8n-nodes-base.code',
|
||||
typeVersion: 2,
|
||||
position: [450, 300],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'branch1',
|
||||
name: 'Check Valid',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2,
|
||||
position: [650, 300],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'process1',
|
||||
name: 'Process Request',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
typeVersion: 3,
|
||||
position: [850, 250],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'success1',
|
||||
name: 'Return Success',
|
||||
type: 'n8n-nodes-base.respondToWebhook',
|
||||
typeVersion: 1,
|
||||
position: [1050, 250],
|
||||
parameters: {}
|
||||
},
|
||||
{
|
||||
id: 'error1',
|
||||
name: 'Return Error',
|
||||
type: 'n8n-nodes-base.respondToWebhook',
|
||||
typeVersion: 1,
|
||||
position: [850, 350],
|
||||
parameters: {}
|
||||
},
|
||||
// Documentation sticky notes (11 notes like in real workflow)
|
||||
...Array.from({ length: 11 }, (_, i) => ({
|
||||
id: `sticky${i}`,
|
||||
name: `📝 Documentation ${i}`,
|
||||
type: 'n8n-nodes-base.stickyNote',
|
||||
typeVersion: 1,
|
||||
position: [250 + i * 100, 100] as [number, number],
|
||||
parameters: { content: `Documentation section ${i}` }
|
||||
}))
|
||||
],
|
||||
connections: {
|
||||
'API Webhook': {
|
||||
main: [[{ node: 'Validate Input', type: 'main', index: 0 }]]
|
||||
},
|
||||
'Validate Input': {
|
||||
main: [[{ node: 'Check Valid', type: 'main', index: 0 }]]
|
||||
},
|
||||
'Check Valid': {
|
||||
main: [
|
||||
[{ node: 'Process Request', type: 'main', index: 0 }],
|
||||
[{ node: 'Return Error', type: 'main', index: 0 }]
|
||||
]
|
||||
},
|
||||
'Process Request': {
|
||||
main: [[{ node: 'Return Success', type: 'main', index: 0 }]]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
|
||||
// Should be valid - all functional nodes connected, sticky notes ignored
|
||||
expect(errors).toEqual([]);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -540,7 +540,7 @@ describe('n8n-validation', () => {
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
expect(errors.some(e => e.includes('Single non-webhook node workflow is invalid'))).toBe(true);
|
||||
expect(errors).toContain('Single-node workflows are only valid for webhooks. Add at least one more node and connect them. Example: Manual Trigger → Set node');
|
||||
});
|
||||
|
||||
it('should detect empty connections in multi-node workflow', () => {
|
||||
@@ -568,7 +568,7 @@ describe('n8n-validation', () => {
|
||||
};
|
||||
|
||||
const errors = validateWorkflowStructure(workflow);
|
||||
expect(errors.some(e => e.includes('Multi-node workflow has no connections between nodes'))).toBe(true);
|
||||
expect(errors).toContain('Multi-node workflow has empty connections. Connect nodes like this: connections: { "Node1 Name": { "main": [[{ "node": "Node2 Name", "type": "main", "index": 0 }]] } }');
|
||||
});
|
||||
|
||||
it('should validate node type format - missing package prefix', () => {
|
||||
|
||||
@@ -1,461 +0,0 @@
|
||||
/**
|
||||
* Node Sanitizer Tests
|
||||
* Tests for auto-adding required metadata to filter-based nodes
|
||||
*/
|
||||
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import { sanitizeNode, validateNodeMetadata } from '../../../src/services/node-sanitizer';
|
||||
import { WorkflowNode } from '../../../src/types/n8n-api';
|
||||
|
||||
describe('Node Sanitizer', () => {
|
||||
describe('sanitizeNode', () => {
|
||||
it('should add complete filter options to IF v2.2 node', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test-if',
|
||||
name: 'IF Node',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
conditions: [
|
||||
{
|
||||
id: 'condition1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: '',
|
||||
operator: {
|
||||
type: 'string',
|
||||
operation: 'isNotEmpty'
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const sanitized = sanitizeNode(node);
|
||||
|
||||
// Check that options were added
|
||||
expect(sanitized.parameters.conditions).toHaveProperty('options');
|
||||
const options = (sanitized.parameters.conditions as any).options;
|
||||
|
||||
expect(options).toEqual({
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: true,
|
||||
typeValidation: 'strict'
|
||||
});
|
||||
});
|
||||
|
||||
it('should preserve existing options while adding missing fields', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test-if-partial',
|
||||
name: 'IF Node Partial',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
options: {
|
||||
caseSensitive: false // User-provided value
|
||||
},
|
||||
conditions: []
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const sanitized = sanitizeNode(node);
|
||||
const options = (sanitized.parameters.conditions as any).options;
|
||||
|
||||
// Should preserve user value
|
||||
expect(options.caseSensitive).toBe(false);
|
||||
|
||||
// Should add missing fields
|
||||
expect(options.version).toBe(2);
|
||||
expect(options.leftValue).toBe('');
|
||||
expect(options.typeValidation).toBe('strict');
|
||||
});
|
||||
|
||||
it('should fix invalid operator structure (type field misuse)', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test-if-bad-operator',
|
||||
name: 'IF Bad Operator',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
conditions: [
|
||||
{
|
||||
id: 'condition1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: '',
|
||||
operator: {
|
||||
type: 'isNotEmpty' // WRONG: type should be data type, not operation
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const sanitized = sanitizeNode(node);
|
||||
const condition = (sanitized.parameters.conditions as any).conditions[0];
|
||||
|
||||
// Should fix operator structure
|
||||
expect(condition.operator.type).toBe('boolean'); // Inferred data type (isEmpty/isNotEmpty are boolean ops)
|
||||
expect(condition.operator.operation).toBe('isNotEmpty'); // Moved to operation field
|
||||
});
|
||||
|
||||
it('should add singleValue for unary operators', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test-if-unary',
|
||||
name: 'IF Unary',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
conditions: [
|
||||
{
|
||||
id: 'condition1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: '',
|
||||
operator: {
|
||||
type: 'string',
|
||||
operation: 'isNotEmpty'
|
||||
// Missing singleValue
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const sanitized = sanitizeNode(node);
|
||||
const condition = (sanitized.parameters.conditions as any).conditions[0];
|
||||
|
||||
expect(condition.operator.singleValue).toBe(true);
|
||||
});
|
||||
|
||||
it('should sanitize Switch v3.2 node rules', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test-switch',
|
||||
name: 'Switch Node',
|
||||
type: 'n8n-nodes-base.switch',
|
||||
typeVersion: 3.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
mode: 'rules',
|
||||
rules: {
|
||||
rules: [
|
||||
{
|
||||
outputKey: 'audio',
|
||||
conditions: {
|
||||
conditions: [
|
||||
{
|
||||
id: 'cond1',
|
||||
leftValue: '={{ $json.fileType }}',
|
||||
rightValue: 'audio',
|
||||
operator: {
|
||||
type: 'string',
|
||||
operation: 'equals'
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const sanitized = sanitizeNode(node);
|
||||
const rule = (sanitized.parameters.rules as any).rules[0];
|
||||
|
||||
// Check that options were added to rule conditions
|
||||
expect(rule.conditions).toHaveProperty('options');
|
||||
expect(rule.conditions.options).toEqual({
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: true,
|
||||
typeValidation: 'strict'
|
||||
});
|
||||
});
|
||||
|
||||
it('should not modify non-filter nodes', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test-http',
|
||||
name: 'HTTP Request',
|
||||
type: 'n8n-nodes-base.httpRequest',
|
||||
typeVersion: 4.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
method: 'GET',
|
||||
url: 'https://example.com'
|
||||
}
|
||||
};
|
||||
|
||||
const sanitized = sanitizeNode(node);
|
||||
|
||||
// Should return unchanged
|
||||
expect(sanitized).toEqual(node);
|
||||
});
|
||||
|
||||
it('should not modify old IF versions', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test-if-old',
|
||||
name: 'Old IF',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.0, // Pre-filter version
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: []
|
||||
}
|
||||
};
|
||||
|
||||
const sanitized = sanitizeNode(node);
|
||||
|
||||
// Should return unchanged
|
||||
expect(sanitized).toEqual(node);
|
||||
});
|
||||
|
||||
it('should remove singleValue from binary operators like "equals"', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test-if-binary',
|
||||
name: 'IF Binary Operator',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
conditions: [
|
||||
{
|
||||
id: 'condition1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: 'test',
|
||||
operator: {
|
||||
type: 'string',
|
||||
operation: 'equals',
|
||||
singleValue: true // WRONG: equals is binary, not unary
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const sanitized = sanitizeNode(node);
|
||||
const condition = (sanitized.parameters.conditions as any).conditions[0];
|
||||
|
||||
// Should remove singleValue from binary operator
|
||||
expect(condition.operator.singleValue).toBeUndefined();
|
||||
expect(condition.operator.type).toBe('string');
|
||||
expect(condition.operator.operation).toBe('equals');
|
||||
});
|
||||
});
|
||||
|
||||
describe('validateNodeMetadata', () => {
|
||||
it('should detect missing conditions.options', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test',
|
||||
name: 'IF Missing Options',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
conditions: []
|
||||
// Missing options
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const issues = validateNodeMetadata(node);
|
||||
|
||||
expect(issues.length).toBeGreaterThan(0);
|
||||
expect(issues[0]).toBe('Missing conditions.options');
|
||||
});
|
||||
|
||||
it('should detect missing operator.type', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test',
|
||||
name: 'IF Bad Operator',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
options: {
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: true,
|
||||
typeValidation: 'strict'
|
||||
},
|
||||
conditions: [
|
||||
{
|
||||
id: 'cond1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: '',
|
||||
operator: {
|
||||
operation: 'equals'
|
||||
// Missing type
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const issues = validateNodeMetadata(node);
|
||||
|
||||
expect(issues.length).toBeGreaterThan(0);
|
||||
expect(issues.some(issue => issue.includes("missing required field 'type'"))).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect invalid operator.type value', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test',
|
||||
name: 'IF Invalid Type',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
options: {
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: true,
|
||||
typeValidation: 'strict'
|
||||
},
|
||||
conditions: [
|
||||
{
|
||||
id: 'cond1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: '',
|
||||
operator: {
|
||||
type: 'isNotEmpty', // WRONG: operation name, not data type
|
||||
operation: 'isNotEmpty'
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const issues = validateNodeMetadata(node);
|
||||
|
||||
expect(issues.some(issue => issue.includes('invalid type "isNotEmpty"'))).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect missing singleValue for unary operators', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test',
|
||||
name: 'IF Missing SingleValue',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
options: {
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: true,
|
||||
typeValidation: 'strict'
|
||||
},
|
||||
conditions: [
|
||||
{
|
||||
id: 'cond1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: '',
|
||||
operator: {
|
||||
type: 'string',
|
||||
operation: 'isNotEmpty'
|
||||
// Missing singleValue: true
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const issues = validateNodeMetadata(node);
|
||||
|
||||
expect(issues.length).toBeGreaterThan(0);
|
||||
expect(issues.some(issue => issue.includes('requires singleValue: true'))).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect singleValue on binary operators', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test',
|
||||
name: 'IF Binary with SingleValue',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
options: {
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: true,
|
||||
typeValidation: 'strict'
|
||||
},
|
||||
conditions: [
|
||||
{
|
||||
id: 'cond1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: 'test',
|
||||
operator: {
|
||||
type: 'string',
|
||||
operation: 'equals',
|
||||
singleValue: true // WRONG: equals is binary
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const issues = validateNodeMetadata(node);
|
||||
|
||||
expect(issues.length).toBeGreaterThan(0);
|
||||
expect(issues.some(issue => issue.includes('should not have singleValue: true'))).toBe(true);
|
||||
});
|
||||
|
||||
it('should return empty array for valid node', () => {
|
||||
const node: WorkflowNode = {
|
||||
id: 'test',
|
||||
name: 'Valid IF',
|
||||
type: 'n8n-nodes-base.if',
|
||||
typeVersion: 2.2,
|
||||
position: [0, 0],
|
||||
parameters: {
|
||||
conditions: {
|
||||
options: {
|
||||
version: 2,
|
||||
leftValue: '',
|
||||
caseSensitive: true,
|
||||
typeValidation: 'strict'
|
||||
},
|
||||
conditions: [
|
||||
{
|
||||
id: 'cond1',
|
||||
leftValue: '={{ $json.value }}',
|
||||
rightValue: '',
|
||||
operator: {
|
||||
type: 'string',
|
||||
operation: 'isNotEmpty',
|
||||
singleValue: true
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const issues = validateNodeMetadata(node);
|
||||
|
||||
expect(issues).toEqual([]);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1610,20 +1610,15 @@ describe('NodeSpecificValidators', () => {
|
||||
});
|
||||
|
||||
describe('response mode validation', () => {
|
||||
// NOTE: responseNode mode validation was moved to workflow-validator.ts in Phase 5
|
||||
// because it requires access to node-level onError property, not just config/parameters.
|
||||
// See workflow-validator.ts checkWebhookErrorHandling() method for the actual implementation.
|
||||
// The validation cannot be performed at the node-specific-validator level.
|
||||
|
||||
it.skip('should error on responseNode without error handling - MOVED TO WORKFLOW VALIDATOR', () => {
|
||||
it('should error on responseNode without error handling', () => {
|
||||
context.config = {
|
||||
path: 'my-webhook',
|
||||
httpMethod: 'POST',
|
||||
responseMode: 'responseNode'
|
||||
};
|
||||
|
||||
|
||||
NodeSpecificValidators.validateWebhook(context);
|
||||
|
||||
|
||||
expect(context.errors).toContainEqual({
|
||||
type: 'invalid_configuration',
|
||||
property: 'responseMode',
|
||||
@@ -1632,14 +1627,14 @@ describe('NodeSpecificValidators', () => {
|
||||
});
|
||||
});
|
||||
|
||||
it.skip('should not error on responseNode with proper error handling - MOVED TO WORKFLOW VALIDATOR', () => {
|
||||
it('should not error on responseNode with proper error handling', () => {
|
||||
context.config = {
|
||||
path: 'my-webhook',
|
||||
httpMethod: 'POST',
|
||||
responseMode: 'responseNode',
|
||||
onError: 'continueRegularOutput'
|
||||
};
|
||||
|
||||
|
||||
NodeSpecificValidators.validateWebhook(context);
|
||||
|
||||
const responseModeErrors = context.errors.filter(e => e.property === 'responseMode');
|
||||
|
||||
@@ -1,414 +0,0 @@
|
||||
/**
|
||||
* Tests for Expression Utilities
|
||||
*
|
||||
* Comprehensive test suite for n8n expression detection utilities
|
||||
* that help validators understand when to skip literal validation
|
||||
*/
|
||||
|
||||
import { describe, it, expect } from 'vitest';
|
||||
import {
|
||||
isExpression,
|
||||
containsExpression,
|
||||
shouldSkipLiteralValidation,
|
||||
extractExpressionContent,
|
||||
hasMixedContent
|
||||
} from '../../../src/utils/expression-utils';
|
||||
|
||||
describe('Expression Utilities', () => {
|
||||
describe('isExpression', () => {
|
||||
describe('Valid expressions', () => {
|
||||
it('should detect expression with = prefix and {{ }}', () => {
|
||||
expect(isExpression('={{ $json.value }}')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect expression with = prefix only', () => {
|
||||
expect(isExpression('=$json.value')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect mixed content expression', () => {
|
||||
expect(isExpression('=https://api.com/{{ $json.id }}/data')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect expression with complex content', () => {
|
||||
expect(isExpression('={{ $json.items.map(item => item.id) }}')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Non-expressions', () => {
|
||||
it('should return false for plain strings', () => {
|
||||
expect(isExpression('plain text')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for URLs without = prefix', () => {
|
||||
expect(isExpression('https://api.example.com')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for {{ }} without = prefix', () => {
|
||||
expect(isExpression('{{ $json.value }}')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for empty string', () => {
|
||||
expect(isExpression('')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Edge cases', () => {
|
||||
it('should return false for null', () => {
|
||||
expect(isExpression(null)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for undefined', () => {
|
||||
expect(isExpression(undefined)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for number', () => {
|
||||
expect(isExpression(123)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for object', () => {
|
||||
expect(isExpression({})).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for array', () => {
|
||||
expect(isExpression([])).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for boolean', () => {
|
||||
expect(isExpression(true)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Type narrowing', () => {
|
||||
it('should narrow type to string when true', () => {
|
||||
const value: unknown = '=$json.value';
|
||||
if (isExpression(value)) {
|
||||
// This should compile because isExpression is a type predicate
|
||||
const length: number = value.length;
|
||||
expect(length).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('containsExpression', () => {
|
||||
describe('Valid expression markers', () => {
|
||||
it('should detect {{ }} markers', () => {
|
||||
expect(containsExpression('{{ $json.value }}')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect expression markers in mixed content', () => {
|
||||
expect(containsExpression('Hello {{ $json.name }}!')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect multiple expression markers', () => {
|
||||
expect(containsExpression('{{ $json.first }} and {{ $json.second }}')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect expression with = prefix', () => {
|
||||
expect(containsExpression('={{ $json.value }}')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect expressions with newlines', () => {
|
||||
expect(containsExpression('{{ $json.items\n .map(item => item.id) }}')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Non-expressions', () => {
|
||||
it('should return false for plain strings', () => {
|
||||
expect(containsExpression('plain text')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for = prefix without {{ }}', () => {
|
||||
expect(containsExpression('=$json.value')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for single braces', () => {
|
||||
expect(containsExpression('{ value }')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for empty string', () => {
|
||||
expect(containsExpression('')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Edge cases', () => {
|
||||
it('should return false for null', () => {
|
||||
expect(containsExpression(null)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for undefined', () => {
|
||||
expect(containsExpression(undefined)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for number', () => {
|
||||
expect(containsExpression(123)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for object', () => {
|
||||
expect(containsExpression({})).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for array', () => {
|
||||
expect(containsExpression([])).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('shouldSkipLiteralValidation', () => {
|
||||
describe('Should skip validation', () => {
|
||||
it('should skip for expression with = prefix and {{ }}', () => {
|
||||
expect(shouldSkipLiteralValidation('={{ $json.value }}')).toBe(true);
|
||||
});
|
||||
|
||||
it('should skip for expression with = prefix only', () => {
|
||||
expect(shouldSkipLiteralValidation('=$json.value')).toBe(true);
|
||||
});
|
||||
|
||||
it('should skip for {{ }} without = prefix', () => {
|
||||
expect(shouldSkipLiteralValidation('{{ $json.value }}')).toBe(true);
|
||||
});
|
||||
|
||||
it('should skip for mixed content with expressions', () => {
|
||||
expect(shouldSkipLiteralValidation('https://api.com/{{ $json.id }}/data')).toBe(true);
|
||||
});
|
||||
|
||||
it('should skip for expression URL', () => {
|
||||
expect(shouldSkipLiteralValidation('={{ $json.baseUrl }}/api')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Should not skip validation', () => {
|
||||
it('should validate plain strings', () => {
|
||||
expect(shouldSkipLiteralValidation('plain text')).toBe(false);
|
||||
});
|
||||
|
||||
it('should validate literal URLs', () => {
|
||||
expect(shouldSkipLiteralValidation('https://api.example.com')).toBe(false);
|
||||
});
|
||||
|
||||
it('should validate JSON strings', () => {
|
||||
expect(shouldSkipLiteralValidation('{"key": "value"}')).toBe(false);
|
||||
});
|
||||
|
||||
it('should validate numbers', () => {
|
||||
expect(shouldSkipLiteralValidation(123)).toBe(false);
|
||||
});
|
||||
|
||||
it('should validate null', () => {
|
||||
expect(shouldSkipLiteralValidation(null)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Real-world use cases', () => {
|
||||
it('should skip validation for expression-based URLs', () => {
|
||||
const url = '={{ $json.protocol }}://{{ $json.domain }}/api';
|
||||
expect(shouldSkipLiteralValidation(url)).toBe(true);
|
||||
});
|
||||
|
||||
it('should skip validation for expression-based JSON', () => {
|
||||
const json = '={{ { key: $json.value } }}';
|
||||
expect(shouldSkipLiteralValidation(json)).toBe(true);
|
||||
});
|
||||
|
||||
it('should not skip validation for literal URLs', () => {
|
||||
const url = 'https://api.example.com/endpoint';
|
||||
expect(shouldSkipLiteralValidation(url)).toBe(false);
|
||||
});
|
||||
|
||||
it('should not skip validation for literal JSON', () => {
|
||||
const json = '{"userId": 123, "name": "test"}';
|
||||
expect(shouldSkipLiteralValidation(json)).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('extractExpressionContent', () => {
|
||||
describe('Expression with = prefix and {{ }}', () => {
|
||||
it('should extract content from ={{ }}', () => {
|
||||
expect(extractExpressionContent('={{ $json.value }}')).toBe('$json.value');
|
||||
});
|
||||
|
||||
it('should extract complex expression', () => {
|
||||
expect(extractExpressionContent('={{ $json.items.map(i => i.id) }}')).toBe('$json.items.map(i => i.id)');
|
||||
});
|
||||
|
||||
it('should trim whitespace', () => {
|
||||
expect(extractExpressionContent('={{ $json.value }}')).toBe('$json.value');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Expression with = prefix only', () => {
|
||||
it('should extract content from = prefix', () => {
|
||||
expect(extractExpressionContent('=$json.value')).toBe('$json.value');
|
||||
});
|
||||
|
||||
it('should handle complex expressions without {{ }}', () => {
|
||||
expect(extractExpressionContent('=$json.items[0].name')).toBe('$json.items[0].name');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Non-expressions', () => {
|
||||
it('should return original value for plain strings', () => {
|
||||
expect(extractExpressionContent('plain text')).toBe('plain text');
|
||||
});
|
||||
|
||||
it('should return original value for {{ }} without = prefix', () => {
|
||||
expect(extractExpressionContent('{{ $json.value }}')).toBe('{{ $json.value }}');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Edge cases', () => {
|
||||
it('should handle empty expression', () => {
|
||||
expect(extractExpressionContent('=')).toBe('');
|
||||
});
|
||||
|
||||
it('should handle expression with only {{ }}', () => {
|
||||
// Empty braces don't match the regex pattern, returns as-is
|
||||
expect(extractExpressionContent('={{}}')).toBe('{{}}');
|
||||
});
|
||||
|
||||
it('should handle nested braces (not valid but should not crash)', () => {
|
||||
// The regex extracts content between outermost {{ }}
|
||||
expect(extractExpressionContent('={{ {{ value }} }}')).toBe('{{ value }}');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('hasMixedContent', () => {
|
||||
describe('Mixed content cases', () => {
|
||||
it('should detect mixed content with text and expression', () => {
|
||||
expect(hasMixedContent('Hello {{ $json.name }}!')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect URL with expression segments', () => {
|
||||
expect(hasMixedContent('https://api.com/{{ $json.id }}/data')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect multiple expressions in text', () => {
|
||||
expect(hasMixedContent('{{ $json.first }} and {{ $json.second }}')).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect JSON with expressions', () => {
|
||||
expect(hasMixedContent('{"id": {{ $json.id }}, "name": "test"}')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Pure expression cases', () => {
|
||||
it('should return false for pure expression with = prefix', () => {
|
||||
expect(hasMixedContent('={{ $json.value }}')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return true for {{ }} without = prefix (ambiguous case)', () => {
|
||||
// Without = prefix, we can't distinguish between pure expression and mixed content
|
||||
// So it's treated as mixed to be safe
|
||||
expect(hasMixedContent('{{ $json.value }}')).toBe(true);
|
||||
});
|
||||
|
||||
it('should return false for expression with whitespace', () => {
|
||||
expect(hasMixedContent(' ={{ $json.value }} ')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Non-expression cases', () => {
|
||||
it('should return false for plain text', () => {
|
||||
expect(hasMixedContent('plain text')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for literal URLs', () => {
|
||||
expect(hasMixedContent('https://api.example.com')).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for = prefix without {{ }}', () => {
|
||||
expect(hasMixedContent('=$json.value')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Edge cases', () => {
|
||||
it('should return false for null', () => {
|
||||
expect(hasMixedContent(null)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for undefined', () => {
|
||||
expect(hasMixedContent(undefined)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for number', () => {
|
||||
expect(hasMixedContent(123)).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for object', () => {
|
||||
expect(hasMixedContent({})).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for array', () => {
|
||||
expect(hasMixedContent([])).toBe(false);
|
||||
});
|
||||
|
||||
it('should return false for empty string', () => {
|
||||
expect(hasMixedContent('')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Type guard effectiveness', () => {
|
||||
it('should handle non-string types without calling containsExpression', () => {
|
||||
// This tests the fix from Phase 1 - type guard must come before containsExpression
|
||||
expect(() => hasMixedContent(123)).not.toThrow();
|
||||
expect(() => hasMixedContent(null)).not.toThrow();
|
||||
expect(() => hasMixedContent(undefined)).not.toThrow();
|
||||
expect(() => hasMixedContent({})).not.toThrow();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Integration scenarios', () => {
|
||||
it('should correctly identify expression-based URL in HTTP Request node', () => {
|
||||
const url = '={{ $json.baseUrl }}/users/{{ $json.userId }}';
|
||||
|
||||
expect(isExpression(url)).toBe(true);
|
||||
expect(containsExpression(url)).toBe(true);
|
||||
expect(shouldSkipLiteralValidation(url)).toBe(true);
|
||||
expect(hasMixedContent(url)).toBe(true);
|
||||
});
|
||||
|
||||
it('should correctly identify literal URL for validation', () => {
|
||||
const url = 'https://api.example.com/users/123';
|
||||
|
||||
expect(isExpression(url)).toBe(false);
|
||||
expect(containsExpression(url)).toBe(false);
|
||||
expect(shouldSkipLiteralValidation(url)).toBe(false);
|
||||
expect(hasMixedContent(url)).toBe(false);
|
||||
});
|
||||
|
||||
it('should handle expression in JSON body', () => {
|
||||
const json = '={{ { userId: $json.id, timestamp: $now } }}';
|
||||
|
||||
expect(isExpression(json)).toBe(true);
|
||||
expect(shouldSkipLiteralValidation(json)).toBe(true);
|
||||
expect(extractExpressionContent(json)).toBe('{ userId: $json.id, timestamp: $now }');
|
||||
});
|
||||
|
||||
it('should handle webhook path with expressions', () => {
|
||||
const path = '=/webhook/{{ $json.customerId }}/notify';
|
||||
|
||||
expect(isExpression(path)).toBe(true);
|
||||
expect(containsExpression(path)).toBe(true);
|
||||
expect(shouldSkipLiteralValidation(path)).toBe(true);
|
||||
expect(extractExpressionContent(path)).toBe('/webhook/{{ $json.customerId }}/notify');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Performance characteristics', () => {
|
||||
it('should use efficient regex for containsExpression', () => {
|
||||
// The implementation should use a single regex test, not two includes()
|
||||
const value = 'text {{ expression }} more text';
|
||||
const start = performance.now();
|
||||
for (let i = 0; i < 10000; i++) {
|
||||
containsExpression(value);
|
||||
}
|
||||
const duration = performance.now() - start;
|
||||
|
||||
// Performance test - should complete in reasonable time
|
||||
expect(duration).toBeLessThan(100); // 100ms for 10k iterations
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,240 +0,0 @@
|
||||
import { describe, test, expect } from 'vitest';
|
||||
import {
|
||||
isStickyNote,
|
||||
isTriggerNode,
|
||||
isNonExecutableNode,
|
||||
requiresIncomingConnection
|
||||
} from '@/utils/node-classification';
|
||||
|
||||
describe('Node Classification Utilities', () => {
|
||||
describe('isStickyNote', () => {
|
||||
test('should identify standard sticky note type', () => {
|
||||
expect(isStickyNote('n8n-nodes-base.stickyNote')).toBe(true);
|
||||
});
|
||||
|
||||
test('should identify normalized sticky note type', () => {
|
||||
expect(isStickyNote('nodes-base.stickyNote')).toBe(true);
|
||||
});
|
||||
|
||||
test('should identify scoped sticky note type', () => {
|
||||
expect(isStickyNote('@n8n/n8n-nodes-base.stickyNote')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return false for webhook node', () => {
|
||||
expect(isStickyNote('n8n-nodes-base.webhook')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for HTTP request node', () => {
|
||||
expect(isStickyNote('n8n-nodes-base.httpRequest')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for manual trigger node', () => {
|
||||
expect(isStickyNote('n8n-nodes-base.manualTrigger')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for Set node', () => {
|
||||
expect(isStickyNote('n8n-nodes-base.set')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for empty string', () => {
|
||||
expect(isStickyNote('')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('isTriggerNode', () => {
|
||||
test('should identify webhook trigger', () => {
|
||||
expect(isTriggerNode('n8n-nodes-base.webhook')).toBe(true);
|
||||
});
|
||||
|
||||
test('should identify webhook trigger variant', () => {
|
||||
expect(isTriggerNode('n8n-nodes-base.webhookTrigger')).toBe(true);
|
||||
});
|
||||
|
||||
test('should identify manual trigger', () => {
|
||||
expect(isTriggerNode('n8n-nodes-base.manualTrigger')).toBe(true);
|
||||
});
|
||||
|
||||
test('should identify cron trigger', () => {
|
||||
expect(isTriggerNode('n8n-nodes-base.cronTrigger')).toBe(true);
|
||||
});
|
||||
|
||||
test('should identify schedule trigger', () => {
|
||||
expect(isTriggerNode('n8n-nodes-base.scheduleTrigger')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return false for HTTP request node', () => {
|
||||
expect(isTriggerNode('n8n-nodes-base.httpRequest')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for Set node', () => {
|
||||
expect(isTriggerNode('n8n-nodes-base.set')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for sticky note', () => {
|
||||
expect(isTriggerNode('n8n-nodes-base.stickyNote')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for empty string', () => {
|
||||
expect(isTriggerNode('')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('isNonExecutableNode', () => {
|
||||
test('should identify sticky note as non-executable', () => {
|
||||
expect(isNonExecutableNode('n8n-nodes-base.stickyNote')).toBe(true);
|
||||
});
|
||||
|
||||
test('should identify all sticky note variations as non-executable', () => {
|
||||
expect(isNonExecutableNode('nodes-base.stickyNote')).toBe(true);
|
||||
expect(isNonExecutableNode('@n8n/n8n-nodes-base.stickyNote')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return false for webhook trigger', () => {
|
||||
expect(isNonExecutableNode('n8n-nodes-base.webhook')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for HTTP request node', () => {
|
||||
expect(isNonExecutableNode('n8n-nodes-base.httpRequest')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for Set node', () => {
|
||||
expect(isNonExecutableNode('n8n-nodes-base.set')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for manual trigger', () => {
|
||||
expect(isNonExecutableNode('n8n-nodes-base.manualTrigger')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('requiresIncomingConnection', () => {
|
||||
describe('non-executable nodes (should not require connections)', () => {
|
||||
test('should return false for sticky note', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.stickyNote')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for all sticky note variations', () => {
|
||||
expect(requiresIncomingConnection('nodes-base.stickyNote')).toBe(false);
|
||||
expect(requiresIncomingConnection('@n8n/n8n-nodes-base.stickyNote')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('trigger nodes (should not require incoming connections)', () => {
|
||||
test('should return false for webhook', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.webhook')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for webhook trigger', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.webhookTrigger')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for manual trigger', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.manualTrigger')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for cron trigger', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.cronTrigger')).toBe(false);
|
||||
});
|
||||
|
||||
test('should return false for schedule trigger', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.scheduleTrigger')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('regular nodes (should require incoming connections)', () => {
|
||||
test('should return true for HTTP request node', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.httpRequest')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return true for Set node', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.set')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return true for Code node', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.code')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return true for Function node', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.function')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return true for IF node', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.if')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return true for Switch node', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.switch')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return true for Respond to Webhook node', () => {
|
||||
expect(requiresIncomingConnection('n8n-nodes-base.respondToWebhook')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('edge cases', () => {
|
||||
test('should return true for unknown node types (conservative approach)', () => {
|
||||
expect(requiresIncomingConnection('unknown-package.unknownNode')).toBe(true);
|
||||
});
|
||||
|
||||
test('should return true for empty string', () => {
|
||||
expect(requiresIncomingConnection('')).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('integration scenarios', () => {
|
||||
test('sticky notes should be non-executable and not require connections', () => {
|
||||
const stickyType = 'n8n-nodes-base.stickyNote';
|
||||
expect(isNonExecutableNode(stickyType)).toBe(true);
|
||||
expect(requiresIncomingConnection(stickyType)).toBe(false);
|
||||
expect(isStickyNote(stickyType)).toBe(true);
|
||||
expect(isTriggerNode(stickyType)).toBe(false);
|
||||
});
|
||||
|
||||
test('webhook nodes should be triggers and not require incoming connections', () => {
|
||||
const webhookType = 'n8n-nodes-base.webhook';
|
||||
expect(isTriggerNode(webhookType)).toBe(true);
|
||||
expect(requiresIncomingConnection(webhookType)).toBe(false);
|
||||
expect(isNonExecutableNode(webhookType)).toBe(false);
|
||||
expect(isStickyNote(webhookType)).toBe(false);
|
||||
});
|
||||
|
||||
test('regular nodes should require incoming connections', () => {
|
||||
const httpType = 'n8n-nodes-base.httpRequest';
|
||||
expect(requiresIncomingConnection(httpType)).toBe(true);
|
||||
expect(isNonExecutableNode(httpType)).toBe(false);
|
||||
expect(isTriggerNode(httpType)).toBe(false);
|
||||
expect(isStickyNote(httpType)).toBe(false);
|
||||
});
|
||||
|
||||
test('all trigger types should not require incoming connections', () => {
|
||||
const triggerTypes = [
|
||||
'n8n-nodes-base.webhook',
|
||||
'n8n-nodes-base.webhookTrigger',
|
||||
'n8n-nodes-base.manualTrigger',
|
||||
'n8n-nodes-base.cronTrigger',
|
||||
'n8n-nodes-base.scheduleTrigger'
|
||||
];
|
||||
|
||||
triggerTypes.forEach(type => {
|
||||
expect(isTriggerNode(type)).toBe(true);
|
||||
expect(requiresIncomingConnection(type)).toBe(false);
|
||||
expect(isNonExecutableNode(type)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
test('all sticky note variations should be non-executable', () => {
|
||||
const stickyTypes = [
|
||||
'n8n-nodes-base.stickyNote',
|
||||
'nodes-base.stickyNote',
|
||||
'@n8n/n8n-nodes-base.stickyNote'
|
||||
];
|
||||
|
||||
stickyTypes.forEach(type => {
|
||||
expect(isStickyNote(type)).toBe(true);
|
||||
expect(isNonExecutableNode(type)).toBe(true);
|
||||
expect(requiresIncomingConnection(type)).toBe(false);
|
||||
expect(isTriggerNode(type)).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -206,7 +206,7 @@ describe('Validation System Fixes', () => {
|
||||
const result = await workflowValidator.validateWorkflow(workflow);
|
||||
|
||||
expect(result).toBeDefined();
|
||||
expect(result.statistics.totalNodes).toBe(1); // Only webhook, non-executable nodes excluded
|
||||
expect(result.statistics.totalNodes).toBe(1); // Only webhook, sticky note excluded
|
||||
expect(result.statistics.enabledNodes).toBe(1);
|
||||
});
|
||||
|
||||
|
||||
Reference in New Issue
Block a user