This is page 15 of 45. Use http://codebase.md/czlonkowski/n8n-mcp?lines=false&page={x} to view the full context.
# Directory Structure
```
├── _config.yml
├── .claude
│ └── agents
│ ├── code-reviewer.md
│ ├── context-manager.md
│ ├── debugger.md
│ ├── deployment-engineer.md
│ ├── mcp-backend-engineer.md
│ ├── n8n-mcp-tester.md
│ ├── technical-researcher.md
│ └── test-automator.md
├── .dockerignore
├── .env.docker
├── .env.example
├── .env.n8n.example
├── .env.test
├── .env.test.example
├── .github
│ ├── ABOUT.md
│ ├── BENCHMARK_THRESHOLDS.md
│ ├── FUNDING.yml
│ ├── gh-pages.yml
│ ├── secret_scanning.yml
│ └── workflows
│ ├── benchmark-pr.yml
│ ├── benchmark.yml
│ ├── docker-build-fast.yml
│ ├── docker-build-n8n.yml
│ ├── docker-build.yml
│ ├── release.yml
│ ├── test.yml
│ └── update-n8n-deps.yml
├── .gitignore
├── .npmignore
├── ATTRIBUTION.md
├── CHANGELOG.md
├── CLAUDE.md
├── codecov.yml
├── coverage.json
├── data
│ ├── .gitkeep
│ ├── nodes.db
│ ├── nodes.db-shm
│ ├── nodes.db-wal
│ └── templates.db
├── deploy
│ └── quick-deploy-n8n.sh
├── docker
│ ├── docker-entrypoint.sh
│ ├── n8n-mcp
│ ├── parse-config.js
│ └── README.md
├── docker-compose.buildkit.yml
├── docker-compose.extract.yml
├── docker-compose.n8n.yml
├── docker-compose.override.yml.example
├── docker-compose.test-n8n.yml
├── docker-compose.yml
├── Dockerfile
├── Dockerfile.railway
├── Dockerfile.test
├── docs
│ ├── AUTOMATED_RELEASES.md
│ ├── BENCHMARKS.md
│ ├── CHANGELOG.md
│ ├── CLAUDE_CODE_SETUP.md
│ ├── CLAUDE_INTERVIEW.md
│ ├── CODECOV_SETUP.md
│ ├── CODEX_SETUP.md
│ ├── CURSOR_SETUP.md
│ ├── DEPENDENCY_UPDATES.md
│ ├── DOCKER_README.md
│ ├── DOCKER_TROUBLESHOOTING.md
│ ├── FINAL_AI_VALIDATION_SPEC.md
│ ├── FLEXIBLE_INSTANCE_CONFIGURATION.md
│ ├── HTTP_DEPLOYMENT.md
│ ├── img
│ │ ├── cc_command.png
│ │ ├── cc_connected.png
│ │ ├── codex_connected.png
│ │ ├── cursor_tut.png
│ │ ├── Railway_api.png
│ │ ├── Railway_server_address.png
│ │ ├── vsc_ghcp_chat_agent_mode.png
│ │ ├── vsc_ghcp_chat_instruction_files.png
│ │ ├── vsc_ghcp_chat_thinking_tool.png
│ │ └── windsurf_tut.png
│ ├── INSTALLATION.md
│ ├── LIBRARY_USAGE.md
│ ├── local
│ │ ├── DEEP_DIVE_ANALYSIS_2025-10-02.md
│ │ ├── DEEP_DIVE_ANALYSIS_README.md
│ │ ├── Deep_dive_p1_p2.md
│ │ ├── integration-testing-plan.md
│ │ ├── integration-tests-phase1-summary.md
│ │ ├── N8N_AI_WORKFLOW_BUILDER_ANALYSIS.md
│ │ ├── P0_IMPLEMENTATION_PLAN.md
│ │ └── TEMPLATE_MINING_ANALYSIS.md
│ ├── MCP_ESSENTIALS_README.md
│ ├── MCP_QUICK_START_GUIDE.md
│ ├── N8N_DEPLOYMENT.md
│ ├── RAILWAY_DEPLOYMENT.md
│ ├── README_CLAUDE_SETUP.md
│ ├── README.md
│ ├── tools-documentation-usage.md
│ ├── VS_CODE_PROJECT_SETUP.md
│ ├── WINDSURF_SETUP.md
│ └── workflow-diff-examples.md
├── examples
│ └── enhanced-documentation-demo.js
├── fetch_log.txt
├── LICENSE
├── MEMORY_N8N_UPDATE.md
├── MEMORY_TEMPLATE_UPDATE.md
├── monitor_fetch.sh
├── N8N_HTTP_STREAMABLE_SETUP.md
├── n8n-nodes.db
├── P0-R3-TEST-PLAN.md
├── package-lock.json
├── package.json
├── package.runtime.json
├── PRIVACY.md
├── railway.json
├── README.md
├── renovate.json
├── scripts
│ ├── analyze-optimization.sh
│ ├── audit-schema-coverage.ts
│ ├── build-optimized.sh
│ ├── compare-benchmarks.js
│ ├── demo-optimization.sh
│ ├── deploy-http.sh
│ ├── deploy-to-vm.sh
│ ├── export-webhook-workflows.ts
│ ├── extract-changelog.js
│ ├── extract-from-docker.js
│ ├── extract-nodes-docker.sh
│ ├── extract-nodes-simple.sh
│ ├── format-benchmark-results.js
│ ├── generate-benchmark-stub.js
│ ├── generate-detailed-reports.js
│ ├── generate-test-summary.js
│ ├── http-bridge.js
│ ├── mcp-http-client.js
│ ├── migrate-nodes-fts.ts
│ ├── migrate-tool-docs.ts
│ ├── n8n-docs-mcp.service
│ ├── nginx-n8n-mcp.conf
│ ├── prebuild-fts5.ts
│ ├── prepare-release.js
│ ├── publish-npm-quick.sh
│ ├── publish-npm.sh
│ ├── quick-test.ts
│ ├── run-benchmarks-ci.js
│ ├── sync-runtime-version.js
│ ├── test-ai-validation-debug.ts
│ ├── test-code-node-enhancements.ts
│ ├── test-code-node-fixes.ts
│ ├── test-docker-config.sh
│ ├── test-docker-fingerprint.ts
│ ├── test-docker-optimization.sh
│ ├── test-docker.sh
│ ├── test-empty-connection-validation.ts
│ ├── test-error-message-tracking.ts
│ ├── test-error-output-validation.ts
│ ├── test-error-validation.js
│ ├── test-essentials.ts
│ ├── test-expression-code-validation.ts
│ ├── test-expression-format-validation.js
│ ├── test-fts5-search.ts
│ ├── test-fuzzy-fix.ts
│ ├── test-fuzzy-simple.ts
│ ├── test-helpers-validation.ts
│ ├── test-http-search.ts
│ ├── test-http.sh
│ ├── test-jmespath-validation.ts
│ ├── test-multi-tenant-simple.ts
│ ├── test-multi-tenant.ts
│ ├── test-n8n-integration.sh
│ ├── test-node-info.js
│ ├── test-node-type-validation.ts
│ ├── test-nodes-base-prefix.ts
│ ├── test-operation-validation.ts
│ ├── test-optimized-docker.sh
│ ├── test-release-automation.js
│ ├── test-search-improvements.ts
│ ├── test-security.ts
│ ├── test-single-session.sh
│ ├── test-sqljs-triggers.ts
│ ├── test-telemetry-debug.ts
│ ├── test-telemetry-direct.ts
│ ├── test-telemetry-env.ts
│ ├── test-telemetry-integration.ts
│ ├── test-telemetry-no-select.ts
│ ├── test-telemetry-security.ts
│ ├── test-telemetry-simple.ts
│ ├── test-typeversion-validation.ts
│ ├── test-url-configuration.ts
│ ├── test-user-id-persistence.ts
│ ├── test-webhook-validation.ts
│ ├── test-workflow-insert.ts
│ ├── test-workflow-sanitizer.ts
│ ├── test-workflow-tracking-debug.ts
│ ├── update-and-publish-prep.sh
│ ├── update-n8n-deps.js
│ ├── update-readme-version.js
│ ├── vitest-benchmark-json-reporter.js
│ └── vitest-benchmark-reporter.ts
├── SECURITY.md
├── src
│ ├── config
│ │ └── n8n-api.ts
│ ├── data
│ │ └── canonical-ai-tool-examples.json
│ ├── database
│ │ ├── database-adapter.ts
│ │ ├── migrations
│ │ │ └── add-template-node-configs.sql
│ │ ├── node-repository.ts
│ │ ├── nodes.db
│ │ ├── schema-optimized.sql
│ │ └── schema.sql
│ ├── errors
│ │ └── validation-service-error.ts
│ ├── http-server-single-session.ts
│ ├── http-server.ts
│ ├── index.ts
│ ├── loaders
│ │ └── node-loader.ts
│ ├── mappers
│ │ └── docs-mapper.ts
│ ├── mcp
│ │ ├── handlers-n8n-manager.ts
│ │ ├── handlers-workflow-diff.ts
│ │ ├── index.ts
│ │ ├── server.ts
│ │ ├── stdio-wrapper.ts
│ │ ├── tool-docs
│ │ │ ├── configuration
│ │ │ │ ├── get-node-as-tool-info.ts
│ │ │ │ ├── get-node-documentation.ts
│ │ │ │ ├── get-node-essentials.ts
│ │ │ │ ├── get-node-info.ts
│ │ │ │ ├── get-property-dependencies.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── search-node-properties.ts
│ │ │ ├── discovery
│ │ │ │ ├── get-database-statistics.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── list-ai-tools.ts
│ │ │ │ ├── list-nodes.ts
│ │ │ │ └── search-nodes.ts
│ │ │ ├── guides
│ │ │ │ ├── ai-agents-guide.ts
│ │ │ │ └── index.ts
│ │ │ ├── index.ts
│ │ │ ├── system
│ │ │ │ ├── index.ts
│ │ │ │ ├── n8n-diagnostic.ts
│ │ │ │ ├── n8n-health-check.ts
│ │ │ │ ├── n8n-list-available-tools.ts
│ │ │ │ └── tools-documentation.ts
│ │ │ ├── templates
│ │ │ │ ├── get-template.ts
│ │ │ │ ├── get-templates-for-task.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── list-node-templates.ts
│ │ │ │ ├── list-tasks.ts
│ │ │ │ ├── search-templates-by-metadata.ts
│ │ │ │ └── search-templates.ts
│ │ │ ├── types.ts
│ │ │ ├── validation
│ │ │ │ ├── index.ts
│ │ │ │ ├── validate-node-minimal.ts
│ │ │ │ ├── validate-node-operation.ts
│ │ │ │ ├── validate-workflow-connections.ts
│ │ │ │ ├── validate-workflow-expressions.ts
│ │ │ │ └── validate-workflow.ts
│ │ │ └── workflow_management
│ │ │ ├── index.ts
│ │ │ ├── n8n-autofix-workflow.ts
│ │ │ ├── n8n-create-workflow.ts
│ │ │ ├── n8n-delete-execution.ts
│ │ │ ├── n8n-delete-workflow.ts
│ │ │ ├── n8n-get-execution.ts
│ │ │ ├── n8n-get-workflow-details.ts
│ │ │ ├── n8n-get-workflow-minimal.ts
│ │ │ ├── n8n-get-workflow-structure.ts
│ │ │ ├── n8n-get-workflow.ts
│ │ │ ├── n8n-list-executions.ts
│ │ │ ├── n8n-list-workflows.ts
│ │ │ ├── n8n-trigger-webhook-workflow.ts
│ │ │ ├── n8n-update-full-workflow.ts
│ │ │ ├── n8n-update-partial-workflow.ts
│ │ │ └── n8n-validate-workflow.ts
│ │ ├── tools-documentation.ts
│ │ ├── tools-n8n-friendly.ts
│ │ ├── tools-n8n-manager.ts
│ │ ├── tools.ts
│ │ └── workflow-examples.ts
│ ├── mcp-engine.ts
│ ├── mcp-tools-engine.ts
│ ├── n8n
│ │ ├── MCPApi.credentials.ts
│ │ └── MCPNode.node.ts
│ ├── parsers
│ │ ├── node-parser.ts
│ │ ├── property-extractor.ts
│ │ └── simple-parser.ts
│ ├── scripts
│ │ ├── debug-http-search.ts
│ │ ├── extract-from-docker.ts
│ │ ├── fetch-templates-robust.ts
│ │ ├── fetch-templates.ts
│ │ ├── rebuild-database.ts
│ │ ├── rebuild-optimized.ts
│ │ ├── rebuild.ts
│ │ ├── sanitize-templates.ts
│ │ ├── seed-canonical-ai-examples.ts
│ │ ├── test-autofix-documentation.ts
│ │ ├── test-autofix-workflow.ts
│ │ ├── test-execution-filtering.ts
│ │ ├── test-node-suggestions.ts
│ │ ├── test-protocol-negotiation.ts
│ │ ├── test-summary.ts
│ │ ├── test-webhook-autofix.ts
│ │ ├── validate.ts
│ │ └── validation-summary.ts
│ ├── services
│ │ ├── ai-node-validator.ts
│ │ ├── ai-tool-validators.ts
│ │ ├── confidence-scorer.ts
│ │ ├── config-validator.ts
│ │ ├── enhanced-config-validator.ts
│ │ ├── example-generator.ts
│ │ ├── execution-processor.ts
│ │ ├── expression-format-validator.ts
│ │ ├── expression-validator.ts
│ │ ├── n8n-api-client.ts
│ │ ├── n8n-validation.ts
│ │ ├── node-documentation-service.ts
│ │ ├── node-similarity-service.ts
│ │ ├── node-specific-validators.ts
│ │ ├── operation-similarity-service.ts
│ │ ├── property-dependencies.ts
│ │ ├── property-filter.ts
│ │ ├── resource-similarity-service.ts
│ │ ├── sqlite-storage-service.ts
│ │ ├── task-templates.ts
│ │ ├── universal-expression-validator.ts
│ │ ├── workflow-auto-fixer.ts
│ │ ├── workflow-diff-engine.ts
│ │ └── workflow-validator.ts
│ ├── telemetry
│ │ ├── batch-processor.ts
│ │ ├── config-manager.ts
│ │ ├── early-error-logger.ts
│ │ ├── error-sanitization-utils.ts
│ │ ├── error-sanitizer.ts
│ │ ├── event-tracker.ts
│ │ ├── event-validator.ts
│ │ ├── index.ts
│ │ ├── performance-monitor.ts
│ │ ├── rate-limiter.ts
│ │ ├── startup-checkpoints.ts
│ │ ├── telemetry-error.ts
│ │ ├── telemetry-manager.ts
│ │ ├── telemetry-types.ts
│ │ └── workflow-sanitizer.ts
│ ├── templates
│ │ ├── batch-processor.ts
│ │ ├── metadata-generator.ts
│ │ ├── README.md
│ │ ├── template-fetcher.ts
│ │ ├── template-repository.ts
│ │ └── template-service.ts
│ ├── types
│ │ ├── index.ts
│ │ ├── instance-context.ts
│ │ ├── n8n-api.ts
│ │ ├── node-types.ts
│ │ └── workflow-diff.ts
│ └── utils
│ ├── auth.ts
│ ├── bridge.ts
│ ├── cache-utils.ts
│ ├── console-manager.ts
│ ├── documentation-fetcher.ts
│ ├── enhanced-documentation-fetcher.ts
│ ├── error-handler.ts
│ ├── example-generator.ts
│ ├── fixed-collection-validator.ts
│ ├── logger.ts
│ ├── mcp-client.ts
│ ├── n8n-errors.ts
│ ├── node-source-extractor.ts
│ ├── node-type-normalizer.ts
│ ├── node-type-utils.ts
│ ├── node-utils.ts
│ ├── npm-version-checker.ts
│ ├── protocol-version.ts
│ ├── simple-cache.ts
│ ├── ssrf-protection.ts
│ ├── template-node-resolver.ts
│ ├── template-sanitizer.ts
│ ├── url-detector.ts
│ ├── validation-schemas.ts
│ └── version.ts
├── test-output.txt
├── test-reinit-fix.sh
├── tests
│ ├── __snapshots__
│ │ └── .gitkeep
│ ├── auth.test.ts
│ ├── benchmarks
│ │ ├── database-queries.bench.ts
│ │ ├── index.ts
│ │ ├── mcp-tools.bench.ts
│ │ ├── mcp-tools.bench.ts.disabled
│ │ ├── mcp-tools.bench.ts.skip
│ │ ├── node-loading.bench.ts.disabled
│ │ ├── README.md
│ │ ├── search-operations.bench.ts.disabled
│ │ └── validation-performance.bench.ts.disabled
│ ├── bridge.test.ts
│ ├── comprehensive-extraction-test.js
│ ├── data
│ │ └── .gitkeep
│ ├── debug-slack-doc.js
│ ├── demo-enhanced-documentation.js
│ ├── docker-tests-README.md
│ ├── error-handler.test.ts
│ ├── examples
│ │ └── using-database-utils.test.ts
│ ├── extracted-nodes-db
│ │ ├── database-import.json
│ │ ├── extraction-report.json
│ │ ├── insert-nodes.sql
│ │ ├── n8n-nodes-base__Airtable.json
│ │ ├── n8n-nodes-base__Discord.json
│ │ ├── n8n-nodes-base__Function.json
│ │ ├── n8n-nodes-base__HttpRequest.json
│ │ ├── n8n-nodes-base__If.json
│ │ ├── n8n-nodes-base__Slack.json
│ │ ├── n8n-nodes-base__SplitInBatches.json
│ │ └── n8n-nodes-base__Webhook.json
│ ├── factories
│ │ ├── node-factory.ts
│ │ └── property-definition-factory.ts
│ ├── fixtures
│ │ ├── .gitkeep
│ │ ├── database
│ │ │ └── test-nodes.json
│ │ ├── factories
│ │ │ ├── node.factory.ts
│ │ │ └── parser-node.factory.ts
│ │ └── template-configs.ts
│ ├── helpers
│ │ └── env-helpers.ts
│ ├── http-server-auth.test.ts
│ ├── integration
│ │ ├── ai-validation
│ │ │ ├── ai-agent-validation.test.ts
│ │ │ ├── ai-tool-validation.test.ts
│ │ │ ├── chat-trigger-validation.test.ts
│ │ │ ├── e2e-validation.test.ts
│ │ │ ├── helpers.ts
│ │ │ ├── llm-chain-validation.test.ts
│ │ │ ├── README.md
│ │ │ └── TEST_REPORT.md
│ │ ├── ci
│ │ │ └── database-population.test.ts
│ │ ├── database
│ │ │ ├── connection-management.test.ts
│ │ │ ├── empty-database.test.ts
│ │ │ ├── fts5-search.test.ts
│ │ │ ├── node-fts5-search.test.ts
│ │ │ ├── node-repository.test.ts
│ │ │ ├── performance.test.ts
│ │ │ ├── sqljs-memory-leak.test.ts
│ │ │ ├── template-node-configs.test.ts
│ │ │ ├── template-repository.test.ts
│ │ │ ├── test-utils.ts
│ │ │ └── transactions.test.ts
│ │ ├── database-integration.test.ts
│ │ ├── docker
│ │ │ ├── docker-config.test.ts
│ │ │ ├── docker-entrypoint.test.ts
│ │ │ └── test-helpers.ts
│ │ ├── flexible-instance-config.test.ts
│ │ ├── mcp
│ │ │ └── template-examples-e2e.test.ts
│ │ ├── mcp-protocol
│ │ │ ├── basic-connection.test.ts
│ │ │ ├── error-handling.test.ts
│ │ │ ├── performance.test.ts
│ │ │ ├── protocol-compliance.test.ts
│ │ │ ├── README.md
│ │ │ ├── session-management.test.ts
│ │ │ ├── test-helpers.ts
│ │ │ ├── tool-invocation.test.ts
│ │ │ └── workflow-error-validation.test.ts
│ │ ├── msw-setup.test.ts
│ │ ├── n8n-api
│ │ │ ├── executions
│ │ │ │ ├── delete-execution.test.ts
│ │ │ │ ├── get-execution.test.ts
│ │ │ │ ├── list-executions.test.ts
│ │ │ │ └── trigger-webhook.test.ts
│ │ │ ├── scripts
│ │ │ │ └── cleanup-orphans.ts
│ │ │ ├── system
│ │ │ │ ├── diagnostic.test.ts
│ │ │ │ ├── health-check.test.ts
│ │ │ │ └── list-tools.test.ts
│ │ │ ├── test-connection.ts
│ │ │ ├── types
│ │ │ │ └── mcp-responses.ts
│ │ │ ├── utils
│ │ │ │ ├── cleanup-helpers.ts
│ │ │ │ ├── credentials.ts
│ │ │ │ ├── factories.ts
│ │ │ │ ├── fixtures.ts
│ │ │ │ ├── mcp-context.ts
│ │ │ │ ├── n8n-client.ts
│ │ │ │ ├── node-repository.ts
│ │ │ │ ├── response-types.ts
│ │ │ │ ├── test-context.ts
│ │ │ │ └── webhook-workflows.ts
│ │ │ └── workflows
│ │ │ ├── autofix-workflow.test.ts
│ │ │ ├── create-workflow.test.ts
│ │ │ ├── delete-workflow.test.ts
│ │ │ ├── get-workflow-details.test.ts
│ │ │ ├── get-workflow-minimal.test.ts
│ │ │ ├── get-workflow-structure.test.ts
│ │ │ ├── get-workflow.test.ts
│ │ │ ├── list-workflows.test.ts
│ │ │ ├── smart-parameters.test.ts
│ │ │ ├── update-partial-workflow.test.ts
│ │ │ ├── update-workflow.test.ts
│ │ │ └── validate-workflow.test.ts
│ │ ├── security
│ │ │ ├── command-injection-prevention.test.ts
│ │ │ └── rate-limiting.test.ts
│ │ ├── setup
│ │ │ ├── integration-setup.ts
│ │ │ └── msw-test-server.ts
│ │ ├── telemetry
│ │ │ ├── docker-user-id-stability.test.ts
│ │ │ └── mcp-telemetry.test.ts
│ │ ├── templates
│ │ │ └── metadata-operations.test.ts
│ │ └── workflow-creation-node-type-format.test.ts
│ ├── logger.test.ts
│ ├── MOCKING_STRATEGY.md
│ ├── mocks
│ │ ├── n8n-api
│ │ │ ├── data
│ │ │ │ ├── credentials.ts
│ │ │ │ ├── executions.ts
│ │ │ │ └── workflows.ts
│ │ │ ├── handlers.ts
│ │ │ └── index.ts
│ │ └── README.md
│ ├── node-storage-export.json
│ ├── setup
│ │ ├── global-setup.ts
│ │ ├── msw-setup.ts
│ │ ├── TEST_ENV_DOCUMENTATION.md
│ │ └── test-env.ts
│ ├── test-database-extraction.js
│ ├── test-direct-extraction.js
│ ├── test-enhanced-documentation.js
│ ├── test-enhanced-integration.js
│ ├── test-mcp-extraction.js
│ ├── test-mcp-server-extraction.js
│ ├── test-mcp-tools-integration.js
│ ├── test-node-documentation-service.js
│ ├── test-node-list.js
│ ├── test-package-info.js
│ ├── test-parsing-operations.js
│ ├── test-slack-node-complete.js
│ ├── test-small-rebuild.js
│ ├── test-sqlite-search.js
│ ├── test-storage-system.js
│ ├── unit
│ │ ├── __mocks__
│ │ │ ├── n8n-nodes-base.test.ts
│ │ │ ├── n8n-nodes-base.ts
│ │ │ └── README.md
│ │ ├── database
│ │ │ ├── __mocks__
│ │ │ │ └── better-sqlite3.ts
│ │ │ ├── database-adapter-unit.test.ts
│ │ │ ├── node-repository-core.test.ts
│ │ │ ├── node-repository-operations.test.ts
│ │ │ ├── node-repository-outputs.test.ts
│ │ │ ├── README.md
│ │ │ └── template-repository-core.test.ts
│ │ ├── docker
│ │ │ ├── config-security.test.ts
│ │ │ ├── edge-cases.test.ts
│ │ │ ├── parse-config.test.ts
│ │ │ └── serve-command.test.ts
│ │ ├── errors
│ │ │ └── validation-service-error.test.ts
│ │ ├── examples
│ │ │ └── using-n8n-nodes-base-mock.test.ts
│ │ ├── flexible-instance-security-advanced.test.ts
│ │ ├── flexible-instance-security.test.ts
│ │ ├── http-server
│ │ │ └── multi-tenant-support.test.ts
│ │ ├── http-server-n8n-mode.test.ts
│ │ ├── http-server-n8n-reinit.test.ts
│ │ ├── http-server-session-management.test.ts
│ │ ├── loaders
│ │ │ └── node-loader.test.ts
│ │ ├── mappers
│ │ │ └── docs-mapper.test.ts
│ │ ├── mcp
│ │ │ ├── get-node-essentials-examples.test.ts
│ │ │ ├── handlers-n8n-manager-simple.test.ts
│ │ │ ├── handlers-n8n-manager.test.ts
│ │ │ ├── handlers-workflow-diff.test.ts
│ │ │ ├── lru-cache-behavior.test.ts
│ │ │ ├── multi-tenant-tool-listing.test.ts.disabled
│ │ │ ├── parameter-validation.test.ts
│ │ │ ├── search-nodes-examples.test.ts
│ │ │ ├── tools-documentation.test.ts
│ │ │ └── tools.test.ts
│ │ ├── monitoring
│ │ │ └── cache-metrics.test.ts
│ │ ├── MULTI_TENANT_TEST_COVERAGE.md
│ │ ├── multi-tenant-integration.test.ts
│ │ ├── parsers
│ │ │ ├── node-parser-outputs.test.ts
│ │ │ ├── node-parser.test.ts
│ │ │ ├── property-extractor.test.ts
│ │ │ └── simple-parser.test.ts
│ │ ├── scripts
│ │ │ └── fetch-templates-extraction.test.ts
│ │ ├── services
│ │ │ ├── ai-node-validator.test.ts
│ │ │ ├── ai-tool-validators.test.ts
│ │ │ ├── confidence-scorer.test.ts
│ │ │ ├── config-validator-basic.test.ts
│ │ │ ├── config-validator-edge-cases.test.ts
│ │ │ ├── config-validator-node-specific.test.ts
│ │ │ ├── config-validator-security.test.ts
│ │ │ ├── debug-validator.test.ts
│ │ │ ├── enhanced-config-validator-integration.test.ts
│ │ │ ├── enhanced-config-validator-operations.test.ts
│ │ │ ├── enhanced-config-validator.test.ts
│ │ │ ├── example-generator.test.ts
│ │ │ ├── execution-processor.test.ts
│ │ │ ├── expression-format-validator.test.ts
│ │ │ ├── expression-validator-edge-cases.test.ts
│ │ │ ├── expression-validator.test.ts
│ │ │ ├── fixed-collection-validation.test.ts
│ │ │ ├── loop-output-edge-cases.test.ts
│ │ │ ├── n8n-api-client.test.ts
│ │ │ ├── n8n-validation.test.ts
│ │ │ ├── node-similarity-service.test.ts
│ │ │ ├── node-specific-validators.test.ts
│ │ │ ├── operation-similarity-service-comprehensive.test.ts
│ │ │ ├── operation-similarity-service.test.ts
│ │ │ ├── property-dependencies.test.ts
│ │ │ ├── property-filter-edge-cases.test.ts
│ │ │ ├── property-filter.test.ts
│ │ │ ├── resource-similarity-service-comprehensive.test.ts
│ │ │ ├── resource-similarity-service.test.ts
│ │ │ ├── task-templates.test.ts
│ │ │ ├── template-service.test.ts
│ │ │ ├── universal-expression-validator.test.ts
│ │ │ ├── validation-fixes.test.ts
│ │ │ ├── workflow-auto-fixer.test.ts
│ │ │ ├── workflow-diff-engine.test.ts
│ │ │ ├── workflow-fixed-collection-validation.test.ts
│ │ │ ├── workflow-validator-comprehensive.test.ts
│ │ │ ├── workflow-validator-edge-cases.test.ts
│ │ │ ├── workflow-validator-error-outputs.test.ts
│ │ │ ├── workflow-validator-expression-format.test.ts
│ │ │ ├── workflow-validator-loops-simple.test.ts
│ │ │ ├── workflow-validator-loops.test.ts
│ │ │ ├── workflow-validator-mocks.test.ts
│ │ │ ├── workflow-validator-performance.test.ts
│ │ │ ├── workflow-validator-with-mocks.test.ts
│ │ │ └── workflow-validator.test.ts
│ │ ├── telemetry
│ │ │ ├── batch-processor.test.ts
│ │ │ ├── config-manager.test.ts
│ │ │ ├── event-tracker.test.ts
│ │ │ ├── event-validator.test.ts
│ │ │ ├── rate-limiter.test.ts
│ │ │ ├── telemetry-error.test.ts
│ │ │ ├── telemetry-manager.test.ts
│ │ │ ├── v2.18.3-fixes-verification.test.ts
│ │ │ └── workflow-sanitizer.test.ts
│ │ ├── templates
│ │ │ ├── batch-processor.test.ts
│ │ │ ├── metadata-generator.test.ts
│ │ │ ├── template-repository-metadata.test.ts
│ │ │ └── template-repository-security.test.ts
│ │ ├── test-env-example.test.ts
│ │ ├── test-infrastructure.test.ts
│ │ ├── types
│ │ │ ├── instance-context-coverage.test.ts
│ │ │ └── instance-context-multi-tenant.test.ts
│ │ ├── utils
│ │ │ ├── auth-timing-safe.test.ts
│ │ │ ├── cache-utils.test.ts
│ │ │ ├── console-manager.test.ts
│ │ │ ├── database-utils.test.ts
│ │ │ ├── fixed-collection-validator.test.ts
│ │ │ ├── n8n-errors.test.ts
│ │ │ ├── node-type-normalizer.test.ts
│ │ │ ├── node-type-utils.test.ts
│ │ │ ├── node-utils.test.ts
│ │ │ ├── simple-cache-memory-leak-fix.test.ts
│ │ │ ├── ssrf-protection.test.ts
│ │ │ └── template-node-resolver.test.ts
│ │ └── validation-fixes.test.ts
│ └── utils
│ ├── assertions.ts
│ ├── builders
│ │ └── workflow.builder.ts
│ ├── data-generators.ts
│ ├── database-utils.ts
│ ├── README.md
│ └── test-helpers.ts
├── thumbnail.png
├── tsconfig.build.json
├── tsconfig.json
├── types
│ ├── mcp.d.ts
│ └── test-env.d.ts
├── verify-telemetry-fix.js
├── versioned-nodes.md
├── vitest.config.benchmark.ts
├── vitest.config.integration.ts
└── vitest.config.ts
```
# Files
--------------------------------------------------------------------------------
/tests/integration/n8n-api/workflows/validate-workflow.test.ts:
--------------------------------------------------------------------------------
```typescript
/**
* Integration Tests: handleValidateWorkflow
*
* Tests workflow validation against a real n8n instance.
* Covers validation profiles, validation types, and error detection.
*/
import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
import { createTestContext, TestContext, createTestWorkflowName } from '../utils/test-context';
import { getTestN8nClient } from '../utils/n8n-client';
import { N8nApiClient } from '../../../../src/services/n8n-api-client';
import { SIMPLE_WEBHOOK_WORKFLOW } from '../utils/fixtures';
import { cleanupOrphanedWorkflows } from '../utils/cleanup-helpers';
import { createMcpContext } from '../utils/mcp-context';
import { InstanceContext } from '../../../../src/types/instance-context';
import { handleValidateWorkflow } from '../../../../src/mcp/handlers-n8n-manager';
import { getNodeRepository, closeNodeRepository } from '../utils/node-repository';
import { NodeRepository } from '../../../../src/database/node-repository';
import { ValidationResponse } from '../types/mcp-responses';
describe('Integration: handleValidateWorkflow', () => {
let context: TestContext;
let client: N8nApiClient;
let mcpContext: InstanceContext;
let repository: NodeRepository;
beforeEach(async () => {
context = createTestContext();
client = getTestN8nClient();
mcpContext = createMcpContext();
repository = await getNodeRepository();
});
afterEach(async () => {
await context.cleanup();
});
afterAll(async () => {
await closeNodeRepository();
if (!process.env.CI) {
await cleanupOrphanedWorkflows();
}
});
// ======================================================================
// Valid Workflow - All Profiles
// ======================================================================
describe('Valid Workflow', () => {
it('should validate valid workflow with default profile (runtime)', async () => {
// Create valid workflow
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Valid Default'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
// Validate with default profile
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as ValidationResponse;
// Verify response structure
expect(data.valid).toBe(true);
expect(data.errors).toBeUndefined(); // Only present if errors exist
expect(data.summary).toBeDefined();
expect(data.summary.errorCount).toBe(0);
});
it('should validate with strict profile', async () => {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Valid Strict'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{
id: created.id,
options: { profile: 'strict' }
},
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.valid).toBe(true);
});
it('should validate with ai-friendly profile', async () => {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Valid AI Friendly'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{
id: created.id,
options: { profile: 'ai-friendly' }
},
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.valid).toBe(true);
});
it('should validate with minimal profile', async () => {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Valid Minimal'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{
id: created.id,
options: { profile: 'minimal' }
},
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.valid).toBe(true);
});
});
// ======================================================================
// Invalid Workflow - Error Detection
// ======================================================================
describe('Invalid Workflow Detection', () => {
it('should detect invalid node type', async () => {
// Create workflow with invalid node type
const workflow = {
name: createTestWorkflowName('Validate - Invalid Node Type'),
nodes: [
{
id: 'invalid-1',
name: 'Invalid Node',
type: 'invalid-node-type',
typeVersion: 1,
position: [250, 300] as [number, number],
parameters: {}
}
],
connections: {},
settings: {},
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
// Should detect error
expect(data.valid).toBe(false);
expect(data.errors).toBeDefined();
expect(data.errors.length).toBeGreaterThan(0);
expect(data.summary.errorCount).toBeGreaterThan(0);
// Error should mention invalid node type
const errorMessages = data.errors.map((e: any) => e.message).join(' ');
expect(errorMessages).toMatch(/invalid-node-type|not found|unknown/i);
});
it('should detect missing required connections', async () => {
// Create workflow with 2 nodes but no connections
const workflow = {
name: createTestWorkflowName('Validate - Missing Connections'),
nodes: [
{
id: 'webhook-1',
name: 'Webhook',
type: 'n8n-nodes-base.webhook',
typeVersion: 2,
position: [250, 300] as [number, number],
parameters: {
httpMethod: 'GET',
path: 'test'
}
},
{
id: 'set-1',
name: 'Set',
type: 'n8n-nodes-base.set',
typeVersion: 3.4,
position: [450, 300] as [number, number],
parameters: {
assignments: {
assignments: []
}
}
}
],
connections: {}, // Empty connections - Set node is unreachable
settings: {},
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
// Multi-node workflow with empty connections should produce warning/error
// (depending on validation profile)
expect(data.valid).toBe(false);
});
});
// ======================================================================
// Selective Validation
// ======================================================================
describe('Selective Validation', () => {
it('should validate nodes only (skip connections)', async () => {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Nodes Only'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{
id: created.id,
options: {
validateNodes: true,
validateConnections: false,
validateExpressions: false
}
},
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.valid).toBe(true);
});
it('should validate connections only (skip nodes)', async () => {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Connections Only'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{
id: created.id,
options: {
validateNodes: false,
validateConnections: true,
validateExpressions: false
}
},
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.valid).toBe(true);
});
it('should validate expressions only', async () => {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Expressions Only'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{
id: created.id,
options: {
validateNodes: false,
validateConnections: false,
validateExpressions: true
}
},
repository,
mcpContext
);
expect(response.success).toBe(true);
// Expression validation may pass even if workflow has other issues
expect(response.data).toBeDefined();
});
});
// ======================================================================
// Error Handling
// ======================================================================
describe('Error Handling', () => {
it('should handle non-existent workflow ID', async () => {
const response = await handleValidateWorkflow(
{ id: '99999999' },
repository,
mcpContext
);
expect(response.success).toBe(false);
expect(response.error).toBeDefined();
});
it('should handle invalid profile parameter', async () => {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Invalid Profile'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{
id: created.id,
options: { profile: 'invalid-profile' as any }
},
repository,
mcpContext
);
// Should either fail validation or use default profile
expect(response.success).toBe(false);
});
});
// ======================================================================
// Response Format Verification
// ======================================================================
describe('Response Format', () => {
it('should return complete validation response structure', async () => {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('Validate - Response Format'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
// Verify required fields
expect(data).toHaveProperty('workflowId');
expect(data).toHaveProperty('workflowName');
expect(data).toHaveProperty('valid');
expect(data).toHaveProperty('summary');
// errors and warnings only present if they exist
// For valid workflow, they should be undefined
if (data.errors) {
expect(Array.isArray(data.errors)).toBe(true);
}
if (data.warnings) {
expect(Array.isArray(data.warnings)).toBe(true);
}
// Verify summary structure
expect(data.summary).toHaveProperty('errorCount');
expect(data.summary).toHaveProperty('warningCount');
expect(data.summary).toHaveProperty('totalNodes');
expect(data.summary).toHaveProperty('enabledNodes');
expect(data.summary).toHaveProperty('triggerNodes');
// Verify types
expect(typeof data.valid).toBe('boolean');
expect(typeof data.summary.errorCount).toBe('number');
expect(typeof data.summary.warningCount).toBe('number');
});
});
});
```
--------------------------------------------------------------------------------
/tests/comprehensive-extraction-test.js:
--------------------------------------------------------------------------------
```javascript
#!/usr/bin/env node
/**
* Comprehensive test suite for n8n node extraction functionality
* Tests all aspects of node extraction for database storage
*/
const fs = require('fs').promises;
const path = require('path');
const crypto = require('crypto');
// Import our components
const { NodeSourceExtractor } = require('../dist/utils/node-source-extractor');
const { N8NMCPServer } = require('../dist/mcp/server');
// Test configuration
const TEST_RESULTS_DIR = path.join(__dirname, 'test-results');
const EXTRACTED_NODES_FILE = path.join(TEST_RESULTS_DIR, 'extracted-nodes.json');
const TEST_SUMMARY_FILE = path.join(TEST_RESULTS_DIR, 'test-summary.json');
// Create results directory
async function ensureTestDir() {
try {
await fs.mkdir(TEST_RESULTS_DIR, { recursive: true });
} catch (error) {
console.error('Failed to create test directory:', error);
}
}
// Test results tracking
const testResults = {
totalTests: 0,
passed: 0,
failed: 0,
startTime: new Date(),
endTime: null,
tests: [],
extractedNodes: [],
databaseSchema: null
};
// Helper function to run a test
async function runTest(name, testFn) {
console.log(`\n📋 Running: ${name}`);
testResults.totalTests++;
const testResult = {
name,
status: 'pending',
startTime: new Date(),
endTime: null,
error: null,
details: {}
};
try {
const result = await testFn();
testResult.status = 'passed';
testResult.details = result;
testResults.passed++;
console.log(`✅ PASSED: ${name}`);
} catch (error) {
testResult.status = 'failed';
testResult.error = error.message;
testResults.failed++;
console.error(`❌ FAILED: ${name}`);
console.error(` Error: ${error.message}`);
if (process.env.DEBUG) {
console.error(error.stack);
}
}
testResult.endTime = new Date();
testResults.tests.push(testResult);
return testResult;
}
// Test 1: Basic extraction functionality
async function testBasicExtraction() {
const extractor = new NodeSourceExtractor();
// Test a known node
const testNodes = [
'@n8n/n8n-nodes-langchain.Agent',
'n8n-nodes-base.Function',
'n8n-nodes-base.Webhook'
];
const results = [];
for (const nodeType of testNodes) {
try {
console.log(` - Extracting ${nodeType}...`);
const nodeInfo = await extractor.extractNodeSource(nodeType);
results.push({
nodeType,
extracted: true,
codeLength: nodeInfo.sourceCode.length,
hasCredentials: !!nodeInfo.credentialCode,
hasPackageInfo: !!nodeInfo.packageInfo,
location: nodeInfo.location
});
console.log(` ✓ Extracted: ${nodeInfo.sourceCode.length} bytes`);
} catch (error) {
results.push({
nodeType,
extracted: false,
error: error.message
});
console.log(` ✗ Failed: ${error.message}`);
}
}
// At least one should succeed
const successCount = results.filter(r => r.extracted).length;
if (successCount === 0) {
throw new Error('No nodes could be extracted');
}
return { results, successCount, totalTested: testNodes.length };
}
// Test 2: List available nodes
async function testListAvailableNodes() {
const extractor = new NodeSourceExtractor();
console.log(' - Listing all available nodes...');
const nodes = await extractor.listAvailableNodes();
console.log(` - Found ${nodes.length} nodes`);
// Group by package
const nodesByPackage = {};
nodes.forEach(node => {
const pkg = node.packageName || 'unknown';
if (!nodesByPackage[pkg]) {
nodesByPackage[pkg] = [];
}
nodesByPackage[pkg].push(node.name);
});
// Show summary
console.log(' - Node distribution by package:');
Object.entries(nodesByPackage).forEach(([pkg, nodeList]) => {
console.log(` ${pkg}: ${nodeList.length} nodes`);
});
if (nodes.length === 0) {
throw new Error('No nodes found');
}
return {
totalNodes: nodes.length,
packages: Object.keys(nodesByPackage),
nodesByPackage,
sampleNodes: nodes.slice(0, 5)
};
}
// Test 3: Bulk extraction simulation
async function testBulkExtraction() {
const extractor = new NodeSourceExtractor();
// First get list of nodes
const allNodes = await extractor.listAvailableNodes();
// Limit to a reasonable number for testing
const nodesToExtract = allNodes.slice(0, 10);
console.log(` - Testing bulk extraction of ${nodesToExtract.length} nodes...`);
const extractionResults = [];
const startTime = Date.now();
for (const node of nodesToExtract) {
const nodeType = node.packageName ? `${node.packageName}.${node.name}` : node.name;
try {
const nodeInfo = await extractor.extractNodeSource(nodeType);
// Calculate hash for deduplication
const codeHash = crypto.createHash('sha256').update(nodeInfo.sourceCode).digest('hex');
const extractedData = {
nodeType,
name: node.name,
packageName: node.packageName,
codeLength: nodeInfo.sourceCode.length,
codeHash,
hasCredentials: !!nodeInfo.credentialCode,
hasPackageInfo: !!nodeInfo.packageInfo,
location: nodeInfo.location,
extractedAt: new Date().toISOString()
};
extractionResults.push({
success: true,
data: extractedData
});
// Store for database simulation
testResults.extractedNodes.push({
...extractedData,
sourceCode: nodeInfo.sourceCode,
credentialCode: nodeInfo.credentialCode,
packageInfo: nodeInfo.packageInfo
});
} catch (error) {
extractionResults.push({
success: false,
nodeType,
error: error.message
});
}
}
const endTime = Date.now();
const successCount = extractionResults.filter(r => r.success).length;
console.log(` - Extraction completed in ${endTime - startTime}ms`);
console.log(` - Success rate: ${successCount}/${nodesToExtract.length} (${(successCount/nodesToExtract.length*100).toFixed(1)}%)`);
return {
totalAttempted: nodesToExtract.length,
successCount,
failureCount: nodesToExtract.length - successCount,
timeElapsed: endTime - startTime,
results: extractionResults
};
}
// Test 4: Database schema simulation
async function testDatabaseSchema() {
console.log(' - Simulating database schema for extracted nodes...');
// Define a schema that would work for storing extracted nodes
const schema = {
tables: {
nodes: {
columns: {
id: 'UUID PRIMARY KEY',
node_type: 'VARCHAR(255) UNIQUE NOT NULL',
name: 'VARCHAR(255) NOT NULL',
package_name: 'VARCHAR(255)',
display_name: 'VARCHAR(255)',
description: 'TEXT',
version: 'VARCHAR(50)',
code_hash: 'VARCHAR(64) NOT NULL',
code_length: 'INTEGER NOT NULL',
source_location: 'TEXT',
extracted_at: 'TIMESTAMP NOT NULL',
updated_at: 'TIMESTAMP'
},
indexes: ['node_type', 'package_name', 'code_hash']
},
node_source_code: {
columns: {
id: 'UUID PRIMARY KEY',
node_id: 'UUID REFERENCES nodes(id)',
source_code: 'TEXT NOT NULL',
compiled_code: 'TEXT',
source_map: 'TEXT'
}
},
node_credentials: {
columns: {
id: 'UUID PRIMARY KEY',
node_id: 'UUID REFERENCES nodes(id)',
credential_type: 'VARCHAR(255) NOT NULL',
credential_code: 'TEXT NOT NULL',
required_fields: 'JSONB'
}
},
node_metadata: {
columns: {
id: 'UUID PRIMARY KEY',
node_id: 'UUID REFERENCES nodes(id)',
package_info: 'JSONB',
dependencies: 'JSONB',
icon: 'TEXT',
categories: 'TEXT[]',
documentation_url: 'TEXT'
}
}
}
};
// Validate that our extracted data fits the schema
const sampleNode = testResults.extractedNodes[0];
if (sampleNode) {
console.log(' - Validating extracted data against schema...');
// Simulate database record
const dbRecord = {
nodes: {
id: crypto.randomUUID(),
node_type: sampleNode.nodeType,
name: sampleNode.name,
package_name: sampleNode.packageName,
code_hash: sampleNode.codeHash,
code_length: sampleNode.codeLength,
source_location: sampleNode.location,
extracted_at: new Date()
},
node_source_code: {
source_code: sampleNode.sourceCode
},
node_credentials: sampleNode.credentialCode ? {
credential_code: sampleNode.credentialCode
} : null,
node_metadata: {
package_info: sampleNode.packageInfo
}
};
console.log(' - Sample database record created successfully');
}
testResults.databaseSchema = schema;
return {
schemaValid: true,
tablesCount: Object.keys(schema.tables).length,
estimatedStoragePerNode: sampleNode ? sampleNode.codeLength + 1024 : 0 // code + metadata overhead
};
}
// Test 5: Error handling
async function testErrorHandling() {
const extractor = new NodeSourceExtractor();
const errorTests = [
{
name: 'Non-existent node',
nodeType: 'non-existent-package.FakeNode',
expectedError: 'not found'
},
{
name: 'Invalid node type format',
nodeType: '',
expectedError: 'invalid'
},
{
name: 'Malformed package name',
nodeType: '@[email protected]',
expectedError: 'not found'
}
];
const results = [];
for (const test of errorTests) {
try {
console.log(` - Testing: ${test.name}`);
await extractor.extractNodeSource(test.nodeType);
results.push({
...test,
passed: false,
error: 'Expected error but extraction succeeded'
});
} catch (error) {
const passed = error.message.toLowerCase().includes(test.expectedError);
results.push({
...test,
passed,
actualError: error.message
});
console.log(` ${passed ? '✓' : '✗'} Got expected error type`);
}
}
const passedCount = results.filter(r => r.passed).length;
return {
totalTests: errorTests.length,
passed: passedCount,
results
};
}
// Test 6: MCP server integration
async function testMCPServerIntegration() {
console.log(' - Testing MCP server tool handlers...');
const config = {
port: 3000,
host: '0.0.0.0',
authToken: 'test-token'
};
const n8nConfig = {
apiUrl: 'http://localhost:5678',
apiKey: 'test-key'
};
// Note: We can't fully test the server without running it,
// but we can verify the handlers are set up correctly
const server = new N8NMCPServer(config, n8nConfig);
// Verify the server instance is created
if (!server) {
throw new Error('Failed to create MCP server instance');
}
console.log(' - MCP server instance created successfully');
return {
serverCreated: true,
config
};
}
// Main test runner
async function runAllTests() {
console.log('=== Comprehensive n8n Node Extraction Test Suite ===\n');
console.log('This test suite validates the extraction of n8n nodes for database storage.\n');
await ensureTestDir();
// Update todo status
console.log('Starting test execution...\n');
// Run all tests
await runTest('Basic Node Extraction', testBasicExtraction);
await runTest('List Available Nodes', testListAvailableNodes);
await runTest('Bulk Node Extraction', testBulkExtraction);
await runTest('Database Schema Validation', testDatabaseSchema);
await runTest('Error Handling', testErrorHandling);
await runTest('MCP Server Integration', testMCPServerIntegration);
// Calculate final results
testResults.endTime = new Date();
const duration = (testResults.endTime - testResults.startTime) / 1000;
// Save extracted nodes data
if (testResults.extractedNodes.length > 0) {
await fs.writeFile(
EXTRACTED_NODES_FILE,
JSON.stringify(testResults.extractedNodes, null, 2)
);
console.log(`\n📁 Extracted nodes saved to: ${EXTRACTED_NODES_FILE}`);
}
// Save test summary
const summary = {
...testResults,
extractedNodes: testResults.extractedNodes.length // Just count, not full data
};
await fs.writeFile(
TEST_SUMMARY_FILE,
JSON.stringify(summary, null, 2)
);
// Print summary
console.log('\n' + '='.repeat(60));
console.log('TEST SUMMARY');
console.log('='.repeat(60));
console.log(`Total Tests: ${testResults.totalTests}`);
console.log(`Passed: ${testResults.passed} ✅`);
console.log(`Failed: ${testResults.failed} ❌`);
console.log(`Duration: ${duration.toFixed(2)}s`);
console.log(`Nodes Extracted: ${testResults.extractedNodes.length}`);
if (testResults.databaseSchema) {
console.log('\nDatabase Schema:');
console.log(`- Tables: ${Object.keys(testResults.databaseSchema.tables).join(', ')}`);
console.log(`- Ready for bulk storage: YES`);
}
console.log('\n' + '='.repeat(60));
// Exit with appropriate code
process.exit(testResults.failed > 0 ? 1 : 0);
}
// Handle errors
process.on('unhandledRejection', (error) => {
console.error('\n💥 Unhandled error:', error);
process.exit(1);
});
// Run tests
runAllTests();
```
--------------------------------------------------------------------------------
/tests/unit/utils/database-utils.test.ts:
--------------------------------------------------------------------------------
```typescript
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import * as fs from 'fs';
import * as path from 'path';
import {
createTestDatabase,
seedTestNodes,
seedTestTemplates,
createTestNode,
createTestTemplate,
resetDatabase,
createDatabaseSnapshot,
restoreDatabaseSnapshot,
loadFixtures,
dbHelpers,
createMockDatabaseAdapter,
withTransaction,
measureDatabaseOperation,
TestDatabase
} from '../../utils/database-utils';
describe('Database Utils', () => {
let testDb: TestDatabase;
afterEach(async () => {
if (testDb) {
await testDb.cleanup();
}
});
describe('createTestDatabase', () => {
it('should create an in-memory database by default', async () => {
testDb = await createTestDatabase();
expect(testDb.adapter).toBeDefined();
expect(testDb.nodeRepository).toBeDefined();
expect(testDb.templateRepository).toBeDefined();
expect(testDb.path).toBe(':memory:');
});
it('should create a file-based database when requested', async () => {
const dbPath = path.join(__dirname, '../../temp/test-file.db');
testDb = await createTestDatabase({ inMemory: false, dbPath });
expect(testDb.path).toBe(dbPath);
expect(fs.existsSync(dbPath)).toBe(true);
});
it('should initialize schema when requested', async () => {
testDb = await createTestDatabase({ initSchema: true });
// Verify tables exist
const tables = testDb.adapter
.prepare("SELECT name FROM sqlite_master WHERE type='table'")
.all() as { name: string }[];
const tableNames = tables.map(t => t.name);
expect(tableNames).toContain('nodes');
expect(tableNames).toContain('templates');
});
it('should skip schema initialization when requested', async () => {
testDb = await createTestDatabase({ initSchema: false });
// Verify tables don't exist (SQLite has internal tables, so check for our specific tables)
const tables = testDb.adapter
.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name IN ('nodes', 'templates')")
.all() as { name: string }[];
expect(tables.length).toBe(0);
});
});
describe('seedTestNodes', () => {
beforeEach(async () => {
testDb = await createTestDatabase();
});
it('should seed default test nodes', async () => {
const nodes = await seedTestNodes(testDb.nodeRepository);
expect(nodes).toHaveLength(3);
expect(nodes[0].nodeType).toBe('nodes-base.httpRequest');
expect(nodes[1].nodeType).toBe('nodes-base.webhook');
expect(nodes[2].nodeType).toBe('nodes-base.slack');
});
it('should seed custom nodes along with defaults', async () => {
const customNodes = [
{ nodeType: 'nodes-base.custom1', displayName: 'Custom 1' },
{ nodeType: 'nodes-base.custom2', displayName: 'Custom 2' }
];
const nodes = await seedTestNodes(testDb.nodeRepository, customNodes);
expect(nodes).toHaveLength(5); // 3 default + 2 custom
expect(nodes[3].nodeType).toBe('nodes-base.custom1');
expect(nodes[4].nodeType).toBe('nodes-base.custom2');
});
it('should save nodes to database', async () => {
await seedTestNodes(testDb.nodeRepository);
const count = dbHelpers.countRows(testDb.adapter, 'nodes');
expect(count).toBe(3);
const httpNode = testDb.nodeRepository.getNode('nodes-base.httpRequest');
expect(httpNode).toBeDefined();
expect(httpNode.displayName).toBe('HTTP Request');
});
});
describe('seedTestTemplates', () => {
beforeEach(async () => {
testDb = await createTestDatabase();
});
it('should seed default test templates', async () => {
const templates = await seedTestTemplates(testDb.templateRepository);
expect(templates).toHaveLength(2);
expect(templates[0].name).toBe('Simple HTTP Workflow');
expect(templates[1].name).toBe('Webhook to Slack');
});
it('should seed custom templates', async () => {
const customTemplates = [
{ id: 100, name: 'Custom Template' }
];
const templates = await seedTestTemplates(testDb.templateRepository, customTemplates);
expect(templates).toHaveLength(3);
expect(templates[2].id).toBe(100);
expect(templates[2].name).toBe('Custom Template');
});
});
describe('createTestNode', () => {
it('should create a node with defaults', () => {
const node = createTestNode();
expect(node.nodeType).toBe('nodes-base.test');
expect(node.displayName).toBe('Test Node');
expect(node.style).toBe('programmatic');
expect(node.isAITool).toBe(false);
});
it('should override defaults', () => {
const node = createTestNode({
nodeType: 'nodes-base.custom',
displayName: 'Custom Node',
isAITool: true
});
expect(node.nodeType).toBe('nodes-base.custom');
expect(node.displayName).toBe('Custom Node');
expect(node.isAITool).toBe(true);
});
});
describe('resetDatabase', () => {
beforeEach(async () => {
testDb = await createTestDatabase();
});
it('should clear all data and reinitialize schema', async () => {
// Add some data
await seedTestNodes(testDb.nodeRepository);
await seedTestTemplates(testDb.templateRepository);
// Verify data exists
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(3);
expect(dbHelpers.countRows(testDb.adapter, 'templates')).toBe(2);
// Reset database
await resetDatabase(testDb.adapter);
// Verify data is cleared
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(0);
expect(dbHelpers.countRows(testDb.adapter, 'templates')).toBe(0);
// Verify tables still exist
const tables = testDb.adapter
.prepare("SELECT name FROM sqlite_master WHERE type='table'")
.all() as { name: string }[];
const tableNames = tables.map(t => t.name);
expect(tableNames).toContain('nodes');
expect(tableNames).toContain('templates');
});
});
describe('Database Snapshots', () => {
beforeEach(async () => {
testDb = await createTestDatabase();
});
it('should create and restore database snapshot', async () => {
// Seed initial data
await seedTestNodes(testDb.nodeRepository);
await seedTestTemplates(testDb.templateRepository);
// Create snapshot
const snapshot = await createDatabaseSnapshot(testDb.adapter);
expect(snapshot.metadata.nodeCount).toBe(3);
expect(snapshot.metadata.templateCount).toBe(2);
expect(snapshot.nodes).toHaveLength(3);
expect(snapshot.templates).toHaveLength(2);
// Clear database
await resetDatabase(testDb.adapter);
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(0);
// Restore from snapshot
await restoreDatabaseSnapshot(testDb.adapter, snapshot);
// Verify data is restored
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(3);
expect(dbHelpers.countRows(testDb.adapter, 'templates')).toBe(2);
const httpNode = testDb.nodeRepository.getNode('nodes-base.httpRequest');
expect(httpNode).toBeDefined();
expect(httpNode.displayName).toBe('HTTP Request');
});
});
describe('loadFixtures', () => {
beforeEach(async () => {
testDb = await createTestDatabase();
});
it('should load fixtures from JSON file', async () => {
// Create a temporary fixture file
const fixturePath = path.join(__dirname, '../../temp/test-fixtures.json');
const fixtures = {
nodes: [
createTestNode({ nodeType: 'nodes-base.fixture1' }),
createTestNode({ nodeType: 'nodes-base.fixture2' })
],
templates: [
createTestTemplate({ id: 1000, name: 'Fixture Template' })
]
};
// Ensure directory exists
const dir = path.dirname(fixturePath);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
fs.writeFileSync(fixturePath, JSON.stringify(fixtures, null, 2));
// Load fixtures
await loadFixtures(testDb.adapter, fixturePath);
// Verify data was loaded
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(2);
expect(dbHelpers.countRows(testDb.adapter, 'templates')).toBe(1);
expect(dbHelpers.nodeExists(testDb.adapter, 'nodes-base.fixture1')).toBe(true);
expect(dbHelpers.nodeExists(testDb.adapter, 'nodes-base.fixture2')).toBe(true);
// Cleanup
fs.unlinkSync(fixturePath);
});
});
describe('dbHelpers', () => {
beforeEach(async () => {
testDb = await createTestDatabase();
await seedTestNodes(testDb.nodeRepository);
});
it('should count rows correctly', () => {
const count = dbHelpers.countRows(testDb.adapter, 'nodes');
expect(count).toBe(3);
});
it('should check if node exists', () => {
expect(dbHelpers.nodeExists(testDb.adapter, 'nodes-base.httpRequest')).toBe(true);
expect(dbHelpers.nodeExists(testDb.adapter, 'nodes-base.nonexistent')).toBe(false);
});
it('should get all node types', () => {
const nodeTypes = dbHelpers.getAllNodeTypes(testDb.adapter);
expect(nodeTypes).toHaveLength(3);
expect(nodeTypes).toContain('nodes-base.httpRequest');
expect(nodeTypes).toContain('nodes-base.webhook');
expect(nodeTypes).toContain('nodes-base.slack');
});
it('should clear table', () => {
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(3);
dbHelpers.clearTable(testDb.adapter, 'nodes');
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(0);
});
});
describe('createMockDatabaseAdapter', () => {
it('should create a mock adapter with all required methods', () => {
const mockAdapter = createMockDatabaseAdapter();
expect(mockAdapter.prepare).toBeDefined();
expect(mockAdapter.exec).toBeDefined();
expect(mockAdapter.close).toBeDefined();
expect(mockAdapter.pragma).toBeDefined();
expect(mockAdapter.transaction).toBeDefined();
expect(mockAdapter.checkFTS5Support).toBeDefined();
// Test that methods are mocked
expect(vi.isMockFunction(mockAdapter.prepare)).toBe(true);
expect(vi.isMockFunction(mockAdapter.exec)).toBe(true);
});
});
describe('withTransaction', () => {
beforeEach(async () => {
testDb = await createTestDatabase();
});
it('should rollback transaction for testing', async () => {
// Insert a node
await seedTestNodes(testDb.nodeRepository, [
{ nodeType: 'nodes-base.transaction-test' }
]);
const initialCount = dbHelpers.countRows(testDb.adapter, 'nodes');
// Try to insert in a transaction that will rollback
const result = await withTransaction(testDb.adapter, async () => {
testDb.nodeRepository.saveNode(createTestNode({
nodeType: 'nodes-base.should-rollback'
}));
// Verify it was inserted within transaction
const midCount = dbHelpers.countRows(testDb.adapter, 'nodes');
expect(midCount).toBe(initialCount + 1);
return 'test-result';
});
// Transaction should have rolled back
expect(result).toBeNull();
const finalCount = dbHelpers.countRows(testDb.adapter, 'nodes');
expect(finalCount).toBe(initialCount);
});
});
describe('measureDatabaseOperation', () => {
beforeEach(async () => {
testDb = await createTestDatabase();
});
it('should measure operation duration', async () => {
const duration = await measureDatabaseOperation('test operation', async () => {
await seedTestNodes(testDb.nodeRepository);
// Add a small delay to ensure measurable time passes
await new Promise(resolve => setTimeout(resolve, 1));
});
expect(duration).toBeGreaterThanOrEqual(0);
expect(duration).toBeLessThan(1000); // Should be fast
});
});
describe('Integration Tests', () => {
it('should handle complex database operations', async () => {
testDb = await createTestDatabase({ enableFTS5: true });
// Seed initial data
const nodes = await seedTestNodes(testDb.nodeRepository);
const templates = await seedTestTemplates(testDb.templateRepository);
// Create snapshot
const snapshot = await createDatabaseSnapshot(testDb.adapter);
// Add more data
await seedTestNodes(testDb.nodeRepository, [
{ nodeType: 'nodes-base.extra1' },
{ nodeType: 'nodes-base.extra2' }
]);
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(5);
// Restore snapshot
await restoreDatabaseSnapshot(testDb.adapter, snapshot);
// Should be back to original state
expect(dbHelpers.countRows(testDb.adapter, 'nodes')).toBe(3);
// Test FTS5 if supported
if (testDb.adapter.checkFTS5Support()) {
// FTS5 operations would go here
expect(true).toBe(true);
}
});
});
});
```
--------------------------------------------------------------------------------
/tests/unit/services/config-validator-security.test.ts:
--------------------------------------------------------------------------------
```typescript
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { ConfigValidator } from '@/services/config-validator';
import type { ValidationResult, ValidationError, ValidationWarning } from '@/services/config-validator';
// Mock the database
vi.mock('better-sqlite3');
describe('ConfigValidator - Security Validation', () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe('Credential security', () => {
it('should perform security checks for hardcoded credentials', () => {
const nodeType = 'nodes-base.test';
const config = {
api_key: 'sk-1234567890abcdef',
password: 'my-secret-password',
token: 'hardcoded-token'
};
const properties = [
{ name: 'api_key', type: 'string' },
{ name: 'password', type: 'string' },
{ name: 'token', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.filter(w => w.type === 'security')).toHaveLength(3);
expect(result.warnings.some(w => w.property === 'api_key')).toBe(true);
expect(result.warnings.some(w => w.property === 'password')).toBe(true);
expect(result.warnings.some(w => w.property === 'token')).toBe(true);
});
it('should validate HTTP Request with authentication in API URLs', () => {
const nodeType = 'nodes-base.httpRequest';
const config = {
method: 'GET',
url: 'https://api.github.com/user/repos',
authentication: 'none'
};
const properties = [
{ name: 'method', type: 'options' },
{ name: 'url', type: 'string' },
{ name: 'authentication', type: 'options' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('API endpoints typically require authentication')
)).toBe(true);
});
});
describe('Code execution security', () => {
it('should warn about security issues with eval/exec', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'javascript',
jsCode: `
const userInput = items[0].json.code;
const result = eval(userInput);
return [{json: {result}}];
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'jsCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('eval/exec which can be a security risk')
)).toBe(true);
});
it('should detect infinite loops', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'javascript',
jsCode: `
while (true) {
console.log('infinite loop');
}
return items;
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'jsCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('Infinite loop detected')
)).toBe(true);
});
});
describe('Database security', () => {
it('should validate database query security', () => {
const nodeType = 'nodes-base.postgres';
const config = {
query: 'DELETE FROM users;' // Missing WHERE clause
};
const properties = [
{ name: 'query', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('DELETE query without WHERE clause')
)).toBe(true);
});
it('should check for SQL injection vulnerabilities', () => {
const nodeType = 'nodes-base.mysql';
const config = {
query: 'SELECT * FROM users WHERE id = ${userId}'
};
const properties = [
{ name: 'query', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('SQL injection')
)).toBe(true);
});
// DROP TABLE warning not implemented in current validator
it.skip('should warn about DROP TABLE operations', () => {
const nodeType = 'nodes-base.postgres';
const config = {
query: 'DROP TABLE IF EXISTS user_sessions;'
};
const properties = [
{ name: 'query', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('DROP TABLE is a destructive operation')
)).toBe(true);
});
// TRUNCATE warning not implemented in current validator
it.skip('should warn about TRUNCATE operations', () => {
const nodeType = 'nodes-base.mysql';
const config = {
query: 'TRUNCATE TABLE audit_logs;'
};
const properties = [
{ name: 'query', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('TRUNCATE is a destructive operation')
)).toBe(true);
});
it('should check for unescaped user input in queries', () => {
const nodeType = 'nodes-base.postgres';
const config = {
query: `SELECT * FROM users WHERE name = '{{ $json.userName }}'`
};
const properties = [
{ name: 'query', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('vulnerable to SQL injection')
)).toBe(true);
});
});
describe('Network security', () => {
// HTTP vs HTTPS warning not implemented in current validator
it.skip('should warn about HTTP (non-HTTPS) API calls', () => {
const nodeType = 'nodes-base.httpRequest';
const config = {
method: 'POST',
url: 'http://api.example.com/sensitive-data',
sendBody: true
};
const properties = [
{ name: 'method', type: 'options' },
{ name: 'url', type: 'string' },
{ name: 'sendBody', type: 'boolean' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('Consider using HTTPS')
)).toBe(true);
});
// Localhost URL warning not implemented in current validator
it.skip('should validate localhost/internal URLs', () => {
const nodeType = 'nodes-base.httpRequest';
const config = {
method: 'GET',
url: 'http://localhost:8080/admin'
};
const properties = [
{ name: 'method', type: 'options' },
{ name: 'url', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('Accessing localhost/internal URLs')
)).toBe(true);
});
// Sensitive data in URL warning not implemented in current validator
it.skip('should check for sensitive data in URLs', () => {
const nodeType = 'nodes-base.httpRequest';
const config = {
method: 'GET',
url: 'https://api.example.com/users?api_key=secret123&token=abc'
};
const properties = [
{ name: 'method', type: 'options' },
{ name: 'url', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('Sensitive data in URL')
)).toBe(true);
});
});
describe('File system security', () => {
// File system operations warning not implemented in current validator
it.skip('should warn about dangerous file operations', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'javascript',
jsCode: `
const fs = require('fs');
fs.unlinkSync('/etc/passwd');
return items;
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'jsCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('File system operations')
)).toBe(true);
});
// Path traversal warning not implemented in current validator
it.skip('should check for path traversal vulnerabilities', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'javascript',
jsCode: `
const path = items[0].json.userPath;
const file = fs.readFileSync('../../../' + path);
return [{json: {content: file.toString()}}];
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'jsCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('Path traversal')
)).toBe(true);
});
});
describe('Crypto and sensitive operations', () => {
it('should validate crypto module usage', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'javascript',
jsCode: `
const uuid = crypto.randomUUID();
return [{json: {id: uuid}}];
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'jsCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'invalid_value' &&
w.message.includes('Using crypto without require')
)).toBe(true);
});
// Weak crypto algorithm warning not implemented in current validator
it.skip('should warn about weak crypto algorithms', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'javascript',
jsCode: `
const crypto = require('crypto');
const hash = crypto.createHash('md5');
hash.update(data);
return [{json: {hash: hash.digest('hex')}}];
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'jsCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('MD5 is cryptographically weak')
)).toBe(true);
});
// Environment variable access warning not implemented in current validator
it.skip('should check for environment variable access', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'javascript',
jsCode: `
const apiKey = process.env.SECRET_API_KEY;
const dbPassword = process.env.DATABASE_PASSWORD;
return [{json: {configured: !!apiKey}}];
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'jsCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('Accessing environment variables')
)).toBe(true);
});
});
describe('Python security', () => {
it('should warn about exec/eval in Python', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'python',
pythonCode: `
user_code = items[0]['json']['code']
result = exec(user_code)
return [{"json": {"result": result}}]
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'pythonCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('eval/exec which can be a security risk')
)).toBe(true);
});
// os.system usage warning not implemented in current validator
it.skip('should check for subprocess/os.system usage', () => {
const nodeType = 'nodes-base.code';
const config = {
language: 'python',
pythonCode: `
import os
command = items[0]['json']['command']
os.system(command)
return [{"json": {"executed": True}}]
`
};
const properties = [
{ name: 'language', type: 'options' },
{ name: 'pythonCode', type: 'string' }
];
const result = ConfigValidator.validate(nodeType, config, properties);
expect(result.warnings.some(w =>
w.type === 'security' &&
w.message.includes('os.system() can execute arbitrary commands')
)).toBe(true);
});
});
});
```
--------------------------------------------------------------------------------
/tests/integration/ai-validation/e2e-validation.test.ts:
--------------------------------------------------------------------------------
```typescript
/**
* Integration Tests: End-to-End AI Workflow Validation
*
* Tests complete AI workflow validation and creation flow.
* Validates multi-error detection and workflow creation after validation.
*/
import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
import { createTestContext, TestContext, createTestWorkflowName } from '../n8n-api/utils/test-context';
import { getTestN8nClient } from '../n8n-api/utils/n8n-client';
import { N8nApiClient } from '../../../src/services/n8n-api-client';
import { cleanupOrphanedWorkflows } from '../n8n-api/utils/cleanup-helpers';
import { createMcpContext } from '../n8n-api/utils/mcp-context';
import { InstanceContext } from '../../../src/types/instance-context';
import { handleValidateWorkflow, handleCreateWorkflow } from '../../../src/mcp/handlers-n8n-manager';
import { getNodeRepository, closeNodeRepository } from '../n8n-api/utils/node-repository';
import { NodeRepository } from '../../../src/database/node-repository';
import { ValidationResponse } from '../n8n-api/types/mcp-responses';
import {
createChatTriggerNode,
createAIAgentNode,
createLanguageModelNode,
createHTTPRequestToolNode,
createCodeToolNode,
createMemoryNode,
createRespondNode,
createAIConnection,
createMainConnection,
mergeConnections,
createAIWorkflow
} from './helpers';
describe('Integration: End-to-End AI Workflow Validation', () => {
let context: TestContext;
let client: N8nApiClient;
let mcpContext: InstanceContext;
let repository: NodeRepository;
beforeEach(async () => {
context = createTestContext();
client = getTestN8nClient();
mcpContext = createMcpContext();
repository = await getNodeRepository();
});
afterEach(async () => {
await context.cleanup();
});
afterAll(async () => {
await closeNodeRepository();
if (!process.env.CI) {
await cleanupOrphanedWorkflows();
}
});
// ======================================================================
// TEST 1: Validate and Create Complex AI Workflow
// ======================================================================
it('should validate and create complex AI workflow', async () => {
const chatTrigger = createChatTriggerNode({
name: 'Chat Trigger',
responseMode: 'lastNode'
});
const languageModel = createLanguageModelNode('openai', {
name: 'OpenAI Chat Model'
});
const httpTool = createHTTPRequestToolNode({
name: 'Weather API',
toolDescription: 'Fetches current weather data from weather API',
url: 'https://api.weather.com/current',
method: 'GET'
});
const codeTool = createCodeToolNode({
name: 'Data Processor',
toolDescription: 'Processes and formats weather data',
code: 'return { formatted: JSON.stringify($input.all()) };'
});
const memory = createMemoryNode({
name: 'Conversation Memory',
contextWindowLength: 10
});
const agent = createAIAgentNode({
name: 'Weather Assistant',
promptType: 'define',
text: 'You are a weather assistant. Help users understand weather data.',
systemMessage: 'You are an AI assistant specialized in weather information. You have access to weather APIs and can process data. Always provide clear, helpful responses.'
});
const respond = createRespondNode({
name: 'Respond to User'
});
const workflow = createAIWorkflow(
[chatTrigger, languageModel, httpTool, codeTool, memory, agent, respond],
mergeConnections(
createMainConnection('Chat Trigger', 'Weather Assistant'),
createAIConnection('OpenAI Chat Model', 'Weather Assistant', 'ai_languageModel'),
createAIConnection('Weather API', 'Weather Assistant', 'ai_tool'),
createAIConnection('Data Processor', 'Weather Assistant', 'ai_tool'),
createAIConnection('Conversation Memory', 'Weather Assistant', 'ai_memory'),
createMainConnection('Weather Assistant', 'Respond to User')
),
{
name: createTestWorkflowName('E2E - Complex AI Workflow'),
tags: ['mcp-integration-test', 'ai-validation', 'e2e']
}
);
// Step 1: Create workflow
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
// Step 2: Validate workflow
const validationResponse = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(validationResponse.success).toBe(true);
const validationData = validationResponse.data as ValidationResponse;
// Workflow should be valid
expect(validationData.valid).toBe(true);
expect(validationData.errors).toBeUndefined();
expect(validationData.summary.errorCount).toBe(0);
// Verify all nodes detected
expect(validationData.summary.totalNodes).toBe(7);
expect(validationData.summary.triggerNodes).toBe(1);
// Step 3: Since it's valid, it's already created and ready to use
// Just verify it exists
const retrieved = await client.getWorkflow(created.id!);
expect(retrieved.id).toBe(created.id);
expect(retrieved.nodes.length).toBe(7);
});
// ======================================================================
// TEST 2: Detect Multiple Validation Errors
// ======================================================================
it('should detect multiple validation errors', async () => {
const chatTrigger = createChatTriggerNode({
name: 'Chat Trigger',
responseMode: 'streaming'
});
const httpTool = createHTTPRequestToolNode({
name: 'HTTP Tool',
toolDescription: '', // ERROR: missing description
url: '', // ERROR: missing URL
method: 'GET'
});
const codeTool = createCodeToolNode({
name: 'Code Tool',
toolDescription: 'Short', // WARNING: too short
code: '' // ERROR: missing code
});
const agent = createAIAgentNode({
name: 'AI Agent',
promptType: 'define',
text: '', // ERROR: missing prompt text
// ERROR: missing language model connection
// ERROR: has main output in streaming mode
});
const respond = createRespondNode({
name: 'Respond'
});
const workflow = createAIWorkflow(
[chatTrigger, httpTool, codeTool, agent, respond],
mergeConnections(
createMainConnection('Chat Trigger', 'AI Agent'),
createAIConnection('HTTP Tool', 'AI Agent', 'ai_tool'),
createAIConnection('Code Tool', 'AI Agent', 'ai_tool'),
createMainConnection('AI Agent', 'Respond') // ERROR in streaming mode
),
{
name: createTestWorkflowName('E2E - Multiple Errors'),
tags: ['mcp-integration-test', 'ai-validation', 'e2e']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const validationResponse = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(validationResponse.success).toBe(true);
const validationData = validationResponse.data as ValidationResponse;
// Should be invalid with multiple errors
expect(validationData.valid).toBe(false);
expect(validationData.errors).toBeDefined();
expect(validationData.errors!.length).toBeGreaterThan(3);
// Verify specific errors are detected
const errorCodes = validationData.errors!.map(e => e.details?.code || e.code);
expect(errorCodes).toContain('MISSING_LANGUAGE_MODEL'); // AI Agent
expect(errorCodes).toContain('MISSING_PROMPT_TEXT'); // AI Agent
expect(errorCodes).toContain('MISSING_TOOL_DESCRIPTION'); // HTTP Tool
expect(errorCodes).toContain('MISSING_URL'); // HTTP Tool
expect(errorCodes).toContain('MISSING_CODE'); // Code Tool
// Should also have streaming error
const streamingErrors = validationData.errors!.filter(e => {
const code = e.details?.code || e.code;
return code === 'STREAMING_WITH_MAIN_OUTPUT' ||
code === 'STREAMING_AGENT_HAS_OUTPUT';
});
expect(streamingErrors.length).toBeGreaterThan(0);
// Verify error messages are actionable
for (const error of validationData.errors!) {
expect(error.message).toBeDefined();
expect(error.message.length).toBeGreaterThan(10);
expect(error.nodeName).toBeDefined();
}
});
// ======================================================================
// TEST 3: Validate Streaming Workflow (No Main Output)
// ======================================================================
it('should validate streaming workflow without main output', async () => {
const chatTrigger = createChatTriggerNode({
name: 'Chat Trigger',
responseMode: 'streaming'
});
const languageModel = createLanguageModelNode('anthropic', {
name: 'Claude Model'
});
const agent = createAIAgentNode({
name: 'Streaming Agent',
text: 'You are a helpful assistant',
systemMessage: 'Provide helpful, streaming responses to user queries'
});
const workflow = createAIWorkflow(
[chatTrigger, languageModel, agent],
mergeConnections(
createMainConnection('Chat Trigger', 'Streaming Agent'),
createAIConnection('Claude Model', 'Streaming Agent', 'ai_languageModel')
// No main output from agent - streaming mode
),
{
name: createTestWorkflowName('E2E - Streaming Workflow'),
tags: ['mcp-integration-test', 'ai-validation', 'e2e']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const validationResponse = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(validationResponse.success).toBe(true);
const validationData = validationResponse.data as ValidationResponse;
expect(validationData.valid).toBe(true);
expect(validationData.errors).toBeUndefined();
expect(validationData.summary.errorCount).toBe(0);
});
// ======================================================================
// TEST 4: Validate Non-Streaming Workflow (With Main Output)
// ======================================================================
it('should validate non-streaming workflow with main output', async () => {
const chatTrigger = createChatTriggerNode({
name: 'Chat Trigger',
responseMode: 'lastNode'
});
const languageModel = createLanguageModelNode('openai', {
name: 'GPT Model'
});
const agent = createAIAgentNode({
name: 'Non-Streaming Agent',
text: 'You are a helpful assistant'
});
const respond = createRespondNode({
name: 'Final Response'
});
const workflow = createAIWorkflow(
[chatTrigger, languageModel, agent, respond],
mergeConnections(
createMainConnection('Chat Trigger', 'Non-Streaming Agent'),
createAIConnection('GPT Model', 'Non-Streaming Agent', 'ai_languageModel'),
createMainConnection('Non-Streaming Agent', 'Final Response')
),
{
name: createTestWorkflowName('E2E - Non-Streaming Workflow'),
tags: ['mcp-integration-test', 'ai-validation', 'e2e']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const validationResponse = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(validationResponse.success).toBe(true);
const validationData = validationResponse.data as ValidationResponse;
expect(validationData.valid).toBe(true);
expect(validationData.errors).toBeUndefined();
});
// ======================================================================
// TEST 5: Test Node Type Normalization (Bug Fix Validation)
// ======================================================================
it('should correctly normalize node types during validation', async () => {
// This test validates the v2.17.0 fix for node type normalization
const languageModel = createLanguageModelNode('openai', {
name: 'OpenAI Model'
});
const agent = createAIAgentNode({
name: 'AI Agent',
text: 'Test agent'
});
const httpTool = createHTTPRequestToolNode({
name: 'API Tool',
toolDescription: 'Calls external API',
url: 'https://api.example.com/test'
});
const workflow = createAIWorkflow(
[languageModel, agent, httpTool],
mergeConnections(
createAIConnection('OpenAI Model', 'AI Agent', 'ai_languageModel'),
createAIConnection('API Tool', 'AI Agent', 'ai_tool')
),
{
name: createTestWorkflowName('E2E - Type Normalization'),
tags: ['mcp-integration-test', 'ai-validation', 'e2e']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const validationResponse = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(validationResponse.success).toBe(true);
const validationData = validationResponse.data as ValidationResponse;
// Should be valid - no false "no tools connected" warning
expect(validationData.valid).toBe(true);
// Should NOT have false warnings about tools
if (validationData.warnings) {
const falseToolWarnings = validationData.warnings.filter(w =>
w.message.toLowerCase().includes('no ai_tool') &&
w.nodeName === 'AI Agent'
);
expect(falseToolWarnings.length).toBe(0);
}
});
});
```
--------------------------------------------------------------------------------
/tests/unit/services/property-dependencies.test.ts:
--------------------------------------------------------------------------------
```typescript
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { PropertyDependencies } from '@/services/property-dependencies';
import type { DependencyAnalysis, PropertyDependency } from '@/services/property-dependencies';
// Mock the database
vi.mock('better-sqlite3');
describe('PropertyDependencies', () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe('analyze', () => {
it('should analyze simple property dependencies', () => {
const properties = [
{
name: 'method',
displayName: 'HTTP Method',
type: 'options'
},
{
name: 'sendBody',
displayName: 'Send Body',
type: 'boolean',
displayOptions: {
show: {
method: ['POST', 'PUT', 'PATCH']
}
}
}
];
const analysis = PropertyDependencies.analyze(properties);
expect(analysis.totalProperties).toBe(2);
expect(analysis.propertiesWithDependencies).toBe(1);
expect(analysis.dependencies).toHaveLength(1);
const sendBodyDep = analysis.dependencies[0];
expect(sendBodyDep.property).toBe('sendBody');
expect(sendBodyDep.dependsOn).toHaveLength(1);
expect(sendBodyDep.dependsOn[0]).toMatchObject({
property: 'method',
values: ['POST', 'PUT', 'PATCH'],
condition: 'equals'
});
});
it('should handle hide conditions', () => {
const properties = [
{
name: 'mode',
type: 'options'
},
{
name: 'manualField',
type: 'string',
displayOptions: {
hide: {
mode: ['automatic']
}
}
}
];
const analysis = PropertyDependencies.analyze(properties);
const manualFieldDep = analysis.dependencies[0];
expect(manualFieldDep.hideWhen).toEqual({ mode: ['automatic'] });
expect(manualFieldDep.dependsOn[0].condition).toBe('not_equals');
});
it('should handle multiple dependencies', () => {
const properties = [
{
name: 'resource',
type: 'options'
},
{
name: 'operation',
type: 'options'
},
{
name: 'channel',
type: 'string',
displayOptions: {
show: {
resource: ['message'],
operation: ['post']
}
}
}
];
const analysis = PropertyDependencies.analyze(properties);
const channelDep = analysis.dependencies[0];
expect(channelDep.dependsOn).toHaveLength(2);
expect(channelDep.notes).toContain('Multiple conditions must be met for this property to be visible');
});
it('should build dependency graph', () => {
const properties = [
{
name: 'method',
type: 'options'
},
{
name: 'sendBody',
type: 'boolean',
displayOptions: {
show: { method: ['POST'] }
}
},
{
name: 'contentType',
type: 'options',
displayOptions: {
show: { method: ['POST'], sendBody: [true] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
expect(analysis.dependencyGraph).toMatchObject({
method: ['sendBody', 'contentType'],
sendBody: ['contentType']
});
});
it('should identify properties that enable others', () => {
const properties = [
{
name: 'sendHeaders',
type: 'boolean'
},
{
name: 'headerParameters',
type: 'collection',
displayOptions: {
show: { sendHeaders: [true] }
}
},
{
name: 'headerCount',
type: 'number',
displayOptions: {
show: { sendHeaders: [true] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
const sendHeadersDeps = analysis.dependencies.filter(d =>
d.dependsOn.some(c => c.property === 'sendHeaders')
);
expect(sendHeadersDeps).toHaveLength(2);
expect(analysis.dependencyGraph.sendHeaders).toContain('headerParameters');
expect(analysis.dependencyGraph.sendHeaders).toContain('headerCount');
});
it('should add notes for collection types', () => {
const properties = [
{
name: 'showCollection',
type: 'boolean'
},
{
name: 'items',
type: 'collection',
displayOptions: {
show: { showCollection: [true] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
const itemsDep = analysis.dependencies[0];
expect(itemsDep.notes).toContain('This property contains nested properties that may have their own dependencies');
});
it('should generate helpful descriptions', () => {
const properties = [
{
name: 'method',
displayName: 'HTTP Method',
type: 'options'
},
{
name: 'sendBody',
type: 'boolean',
displayOptions: {
show: { method: ['POST', 'PUT'] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
const sendBodyDep = analysis.dependencies[0];
expect(sendBodyDep.dependsOn[0].description).toBe(
'Visible when HTTP Method is one of: "POST", "PUT"'
);
});
it('should handle empty properties', () => {
const analysis = PropertyDependencies.analyze([]);
expect(analysis.totalProperties).toBe(0);
expect(analysis.propertiesWithDependencies).toBe(0);
expect(analysis.dependencies).toHaveLength(0);
expect(analysis.dependencyGraph).toEqual({});
});
});
describe('suggestions', () => {
it('should suggest key properties to configure first', () => {
const properties = [
{
name: 'resource',
type: 'options'
},
{
name: 'operation',
type: 'options',
displayOptions: {
show: { resource: ['message'] }
}
},
{
name: 'channel',
type: 'string',
displayOptions: {
show: { resource: ['message'], operation: ['post'] }
}
},
{
name: 'text',
type: 'string',
displayOptions: {
show: { resource: ['message'], operation: ['post'] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
expect(analysis.suggestions[0]).toContain('Key properties to configure first');
expect(analysis.suggestions[0]).toContain('resource');
});
it('should detect circular dependencies', () => {
const properties = [
{
name: 'fieldA',
type: 'string',
displayOptions: {
show: { fieldB: ['value'] }
}
},
{
name: 'fieldB',
type: 'string',
displayOptions: {
show: { fieldA: ['value'] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
expect(analysis.suggestions.some(s => s.includes('Circular dependency'))).toBe(true);
});
it('should note complex dependencies', () => {
const properties = [
{
name: 'a',
type: 'string'
},
{
name: 'b',
type: 'string'
},
{
name: 'c',
type: 'string'
},
{
name: 'complex',
type: 'string',
displayOptions: {
show: { a: ['1'], b: ['2'], c: ['3'] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
expect(analysis.suggestions.some(s => s.includes('multiple dependencies'))).toBe(true);
});
});
describe('getVisibilityImpact', () => {
const properties = [
{
name: 'method',
type: 'options'
},
{
name: 'sendBody',
type: 'boolean',
displayOptions: {
show: { method: ['POST', 'PUT'] }
}
},
{
name: 'contentType',
type: 'options',
displayOptions: {
show: {
method: ['POST', 'PUT'],
sendBody: [true]
}
}
},
{
name: 'debugMode',
type: 'boolean',
displayOptions: {
hide: { method: ['GET'] }
}
}
];
it('should determine visible properties for POST method', () => {
const config = { method: 'POST', sendBody: true };
const impact = PropertyDependencies.getVisibilityImpact(properties, config);
expect(impact.visible).toContain('method');
expect(impact.visible).toContain('sendBody');
expect(impact.visible).toContain('contentType');
expect(impact.visible).toContain('debugMode');
expect(impact.hidden).toHaveLength(0);
});
it('should determine hidden properties for GET method', () => {
const config = { method: 'GET' };
const impact = PropertyDependencies.getVisibilityImpact(properties, config);
expect(impact.visible).toContain('method');
expect(impact.hidden).toContain('sendBody');
expect(impact.hidden).toContain('contentType');
expect(impact.hidden).toContain('debugMode'); // Hidden by hide condition
});
it('should provide reasons for visibility', () => {
const config = { method: 'GET' };
const impact = PropertyDependencies.getVisibilityImpact(properties, config);
expect(impact.reasons.sendBody).toContain('needs to be POST or PUT');
expect(impact.reasons.debugMode).toContain('Hidden because method is "GET"');
});
it('should handle partial dependencies', () => {
const config = { method: 'POST', sendBody: false };
const impact = PropertyDependencies.getVisibilityImpact(properties, config);
expect(impact.visible).toContain('sendBody');
expect(impact.hidden).toContain('contentType');
expect(impact.reasons.contentType).toContain('needs to be true');
});
it('should handle properties without display options', () => {
const simpleProps = [
{ name: 'field1', type: 'string' },
{ name: 'field2', type: 'number' }
];
const impact = PropertyDependencies.getVisibilityImpact(simpleProps, {});
expect(impact.visible).toEqual(['field1', 'field2']);
expect(impact.hidden).toHaveLength(0);
});
it('should handle empty configuration', () => {
const impact = PropertyDependencies.getVisibilityImpact(properties, {});
expect(impact.visible).toContain('method');
expect(impact.hidden).toContain('sendBody'); // No method value provided
expect(impact.hidden).toContain('contentType');
});
it('should handle array values in conditions', () => {
const props = [
{
name: 'status',
type: 'options'
},
{
name: 'errorMessage',
type: 'string',
displayOptions: {
show: { status: ['error', 'failed'] }
}
}
];
const config1 = { status: 'error' };
const impact1 = PropertyDependencies.getVisibilityImpact(props, config1);
expect(impact1.visible).toContain('errorMessage');
const config2 = { status: 'success' };
const impact2 = PropertyDependencies.getVisibilityImpact(props, config2);
expect(impact2.hidden).toContain('errorMessage');
});
});
describe('edge cases', () => {
it('should handle properties with both show and hide conditions', () => {
const properties = [
{
name: 'mode',
type: 'options'
},
{
name: 'special',
type: 'string',
displayOptions: {
show: { mode: ['custom'] },
hide: { debug: [true] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
const specialDep = analysis.dependencies[0];
expect(specialDep.showWhen).toEqual({ mode: ['custom'] });
expect(specialDep.hideWhen).toEqual({ debug: [true] });
expect(specialDep.dependsOn).toHaveLength(2);
});
it('should handle non-array values in display conditions', () => {
const properties = [
{
name: 'enabled',
type: 'boolean'
},
{
name: 'config',
type: 'string',
displayOptions: {
show: { enabled: true } // Not an array
}
}
];
const analysis = PropertyDependencies.analyze(properties);
const configDep = analysis.dependencies[0];
expect(configDep.dependsOn[0].values).toEqual([true]);
});
it('should handle deeply nested property references', () => {
const properties = [
{
name: 'level1',
type: 'options'
},
{
name: 'level2',
type: 'options',
displayOptions: {
show: { level1: ['A'] }
}
},
{
name: 'level3',
type: 'string',
displayOptions: {
show: { level1: ['A'], level2: ['B'] }
}
}
];
const analysis = PropertyDependencies.analyze(properties);
expect(analysis.dependencyGraph).toMatchObject({
level1: ['level2', 'level3'],
level2: ['level3']
});
});
});
});
```
--------------------------------------------------------------------------------
/tests/utils/database-utils.ts:
--------------------------------------------------------------------------------
```typescript
import { DatabaseAdapter, createDatabaseAdapter } from '../../src/database/database-adapter';
import { NodeRepository } from '../../src/database/node-repository';
import { TemplateRepository } from '../../src/templates/template-repository';
import { ParsedNode } from '../../src/parsers/node-parser';
import { TemplateWorkflow, TemplateNode, TemplateUser, TemplateDetail } from '../../src/templates/template-fetcher';
import * as fs from 'fs';
import * as path from 'path';
import { vi } from 'vitest';
/**
* Database test utilities for n8n-mcp
* Provides helpers for creating, seeding, and managing test databases
*/
export interface TestDatabaseOptions {
/**
* Use in-memory database (default: true)
* When false, creates a temporary file database
*/
inMemory?: boolean;
/**
* Custom database path (only used when inMemory is false)
*/
dbPath?: string;
/**
* Initialize with schema (default: true)
*/
initSchema?: boolean;
/**
* Enable FTS5 support if available (default: false)
*/
enableFTS5?: boolean;
}
export interface TestDatabase {
adapter: DatabaseAdapter;
nodeRepository: NodeRepository;
templateRepository: TemplateRepository;
path: string;
cleanup: () => Promise<void>;
}
export interface DatabaseSnapshot {
nodes: any[];
templates: any[];
metadata: {
createdAt: string;
nodeCount: number;
templateCount: number;
};
}
/**
* Creates a test database with repositories
*/
export async function createTestDatabase(options: TestDatabaseOptions = {}): Promise<TestDatabase> {
const {
inMemory = true,
dbPath,
initSchema = true,
enableFTS5 = false
} = options;
// Determine database path
const finalPath = inMemory
? ':memory:'
: dbPath || path.join(__dirname, `../temp/test-${Date.now()}.db`);
// Ensure directory exists for file-based databases
if (!inMemory) {
const dir = path.dirname(finalPath);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
}
// Create database adapter
const adapter = await createDatabaseAdapter(finalPath);
// Initialize schema if requested
if (initSchema) {
await initializeDatabaseSchema(adapter, enableFTS5);
}
// Create repositories
const nodeRepository = new NodeRepository(adapter);
const templateRepository = new TemplateRepository(adapter);
// Cleanup function
const cleanup = async () => {
adapter.close();
if (!inMemory && fs.existsSync(finalPath)) {
fs.unlinkSync(finalPath);
}
};
return {
adapter,
nodeRepository,
templateRepository,
path: finalPath,
cleanup
};
}
/**
* Initializes database schema from SQL file
*/
export async function initializeDatabaseSchema(adapter: DatabaseAdapter, enableFTS5 = false): Promise<void> {
const schemaPath = path.join(__dirname, '../../src/database/schema.sql');
const schema = fs.readFileSync(schemaPath, 'utf-8');
// Execute main schema
adapter.exec(schema);
// Optionally initialize FTS5 tables
if (enableFTS5 && adapter.checkFTS5Support()) {
adapter.exec(`
CREATE VIRTUAL TABLE IF NOT EXISTS templates_fts USING fts5(
name,
description,
content='templates',
content_rowid='id'
);
-- Trigger to keep FTS index in sync
CREATE TRIGGER IF NOT EXISTS templates_ai AFTER INSERT ON templates BEGIN
INSERT INTO templates_fts(rowid, name, description)
VALUES (new.id, new.name, new.description);
END;
CREATE TRIGGER IF NOT EXISTS templates_au AFTER UPDATE ON templates BEGIN
UPDATE templates_fts
SET name = new.name, description = new.description
WHERE rowid = new.id;
END;
CREATE TRIGGER IF NOT EXISTS templates_ad AFTER DELETE ON templates BEGIN
DELETE FROM templates_fts WHERE rowid = old.id;
END;
`);
}
}
/**
* Seeds test nodes into the database
*/
export async function seedTestNodes(
nodeRepository: NodeRepository,
nodes: Partial<ParsedNode>[] = []
): Promise<ParsedNode[]> {
const defaultNodes: ParsedNode[] = [
createTestNode({
nodeType: 'nodes-base.httpRequest',
displayName: 'HTTP Request',
description: 'Makes HTTP requests',
category: 'Core Nodes',
isAITool: true
}),
createTestNode({
nodeType: 'nodes-base.webhook',
displayName: 'Webhook',
description: 'Receives webhook calls',
category: 'Core Nodes',
isTrigger: true,
isWebhook: true
}),
createTestNode({
nodeType: 'nodes-base.slack',
displayName: 'Slack',
description: 'Send messages to Slack',
category: 'Communication',
isAITool: true
})
];
const allNodes = [...defaultNodes, ...nodes.map(n => createTestNode(n))];
for (const node of allNodes) {
nodeRepository.saveNode(node);
}
return allNodes;
}
/**
* Seeds test templates into the database
*/
export async function seedTestTemplates(
templateRepository: TemplateRepository,
templates: Partial<TemplateWorkflow>[] = []
): Promise<TemplateWorkflow[]> {
const defaultTemplates: TemplateWorkflow[] = [
createTestTemplate({
id: 1,
name: 'Simple HTTP Workflow',
description: 'Basic HTTP request workflow',
nodes: [{ id: 1, name: 'HTTP Request', icon: 'http' }]
}),
createTestTemplate({
id: 2,
name: 'Webhook to Slack',
description: 'Webhook that sends to Slack',
nodes: [
{ id: 1, name: 'Webhook', icon: 'webhook' },
{ id: 2, name: 'Slack', icon: 'slack' }
]
})
];
const allTemplates = [...defaultTemplates, ...templates.map(t => createTestTemplate(t))];
for (const template of allTemplates) {
// Convert to TemplateDetail format for saving
const detail: TemplateDetail = {
id: template.id,
name: template.name,
description: template.description,
views: template.totalViews,
createdAt: template.createdAt,
workflow: {
nodes: template.nodes?.map((n, i) => ({
id: `node_${i}`,
name: n.name,
type: `n8n-nodes-base.${n.name.toLowerCase()}`,
position: [250 + i * 200, 300],
parameters: {}
})) || [],
connections: {},
settings: {}
}
};
await templateRepository.saveTemplate(template, detail);
}
return allTemplates;
}
/**
* Creates a test node with defaults
*/
export function createTestNode(overrides: Partial<ParsedNode> = {}): ParsedNode {
return {
style: 'programmatic',
nodeType: 'nodes-base.test',
displayName: 'Test Node',
description: 'A test node',
category: 'Test',
properties: [],
credentials: [],
isAITool: false,
isTrigger: false,
isWebhook: false,
operations: [],
version: '1',
isVersioned: false,
packageName: 'n8n-nodes-base',
documentation: undefined,
...overrides
};
}
/**
* Creates a test template with defaults
*/
export function createTestTemplate(overrides: Partial<TemplateWorkflow> = {}): TemplateWorkflow {
const id = overrides.id || Math.floor(Math.random() * 10000);
return {
id,
name: `Test Template ${id}`,
description: 'A test template',
nodes: overrides.nodes || [],
user: overrides.user || {
id: 1,
name: 'Test User',
username: 'testuser',
verified: false
},
createdAt: overrides.createdAt || new Date().toISOString(),
totalViews: overrides.totalViews || 100,
...overrides
};
}
/**
* Resets database to clean state
*/
export async function resetDatabase(adapter: DatabaseAdapter): Promise<void> {
// Drop all tables
adapter.exec(`
DROP TABLE IF EXISTS templates_fts;
DROP TABLE IF EXISTS templates;
DROP TABLE IF EXISTS nodes;
`);
// Reinitialize schema
await initializeDatabaseSchema(adapter);
}
/**
* Creates a database snapshot
*/
export async function createDatabaseSnapshot(adapter: DatabaseAdapter): Promise<DatabaseSnapshot> {
const nodes = adapter.prepare('SELECT * FROM nodes').all();
const templates = adapter.prepare('SELECT * FROM templates').all();
return {
nodes,
templates,
metadata: {
createdAt: new Date().toISOString(),
nodeCount: nodes.length,
templateCount: templates.length
}
};
}
/**
* Restores database from snapshot
*/
export async function restoreDatabaseSnapshot(
adapter: DatabaseAdapter,
snapshot: DatabaseSnapshot
): Promise<void> {
// Reset database first
await resetDatabase(adapter);
// Restore nodes
const nodeStmt = adapter.prepare(`
INSERT INTO nodes (
node_type, package_name, display_name, description,
category, development_style, is_ai_tool, is_trigger,
is_webhook, is_versioned, version, documentation,
properties_schema, operations, credentials_required
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`);
for (const node of snapshot.nodes) {
nodeStmt.run(
node.node_type,
node.package_name,
node.display_name,
node.description,
node.category,
node.development_style,
node.is_ai_tool,
node.is_trigger,
node.is_webhook,
node.is_versioned,
node.version,
node.documentation,
node.properties_schema,
node.operations,
node.credentials_required
);
}
// Restore templates
const templateStmt = adapter.prepare(`
INSERT INTO templates (
id, workflow_id, name, description,
author_name, author_username, author_verified,
nodes_used, workflow_json, categories,
views, created_at, updated_at, url
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`);
for (const template of snapshot.templates) {
templateStmt.run(
template.id,
template.workflow_id,
template.name,
template.description,
template.author_name,
template.author_username,
template.author_verified,
template.nodes_used,
template.workflow_json,
template.categories,
template.views,
template.created_at,
template.updated_at,
template.url
);
}
}
/**
* Loads JSON fixtures into database
*/
export async function loadFixtures(
adapter: DatabaseAdapter,
fixturePath: string
): Promise<void> {
const fixtures = JSON.parse(fs.readFileSync(fixturePath, 'utf-8'));
if (fixtures.nodes) {
const nodeRepo = new NodeRepository(adapter);
for (const node of fixtures.nodes) {
nodeRepo.saveNode(node);
}
}
if (fixtures.templates) {
const templateRepo = new TemplateRepository(adapter);
for (const template of fixtures.templates) {
// Convert to proper format
const detail: TemplateDetail = {
id: template.id,
name: template.name,
description: template.description,
views: template.views || template.totalViews || 0,
createdAt: template.createdAt,
workflow: template.workflow || {
nodes: template.nodes?.map((n: any, i: number) => ({
id: `node_${i}`,
name: n.name,
type: `n8n-nodes-base.${n.name.toLowerCase()}`,
position: [250 + i * 200, 300],
parameters: {}
})) || [],
connections: {},
settings: {}
}
};
await templateRepo.saveTemplate(template, detail);
}
}
}
/**
* Database test helpers for common operations
*/
export const dbHelpers = {
/**
* Counts rows in a table
*/
countRows(adapter: DatabaseAdapter, table: string): number {
const result = adapter.prepare(`SELECT COUNT(*) as count FROM ${table}`).get() as { count: number };
return result.count;
},
/**
* Checks if a node exists
*/
nodeExists(adapter: DatabaseAdapter, nodeType: string): boolean {
const result = adapter.prepare('SELECT 1 FROM nodes WHERE node_type = ?').get(nodeType);
return !!result;
},
/**
* Gets all node types
*/
getAllNodeTypes(adapter: DatabaseAdapter): string[] {
const rows = adapter.prepare('SELECT node_type FROM nodes').all() as { node_type: string }[];
return rows.map(r => r.node_type);
},
/**
* Clears a specific table
*/
clearTable(adapter: DatabaseAdapter, table: string): void {
adapter.exec(`DELETE FROM ${table}`);
},
/**
* Executes raw SQL
*/
executeSql(adapter: DatabaseAdapter, sql: string): void {
adapter.exec(sql);
}
};
/**
* Creates a mock database adapter for unit tests
*/
export function createMockDatabaseAdapter(): DatabaseAdapter {
const mockDb = {
prepare: vi.fn(),
exec: vi.fn(),
close: vi.fn(),
pragma: vi.fn(),
inTransaction: false,
transaction: vi.fn((fn) => fn()),
checkFTS5Support: vi.fn(() => false)
};
return mockDb as unknown as DatabaseAdapter;
}
/**
* Transaction test helper
* Note: better-sqlite3 transactions are synchronous
*/
export async function withTransaction<T>(
adapter: DatabaseAdapter,
fn: () => Promise<T>
): Promise<T | null> {
try {
adapter.exec('BEGIN');
const result = await fn();
// Always rollback for testing
adapter.exec('ROLLBACK');
return null; // Indicate rollback happened
} catch (error) {
adapter.exec('ROLLBACK');
throw error;
}
}
/**
* Performance test helper
*/
export async function measureDatabaseOperation(
name: string,
operation: () => Promise<void>
): Promise<number> {
const start = performance.now();
await operation();
const duration = performance.now() - start;
console.log(`[DB Performance] ${name}: ${duration.toFixed(2)}ms`);
return duration;
}
```
--------------------------------------------------------------------------------
/tests/integration/ai-validation/ai-agent-validation.test.ts:
--------------------------------------------------------------------------------
```typescript
/**
* Integration Tests: AI Agent Validation
*
* Tests AI Agent validation against real n8n instance.
* These tests validate the fixes from v2.17.0 including node type normalization.
*/
import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
import { createTestContext, TestContext, createTestWorkflowName } from '../n8n-api/utils/test-context';
import { getTestN8nClient } from '../n8n-api/utils/n8n-client';
import { N8nApiClient } from '../../../src/services/n8n-api-client';
import { cleanupOrphanedWorkflows } from '../n8n-api/utils/cleanup-helpers';
import { createMcpContext } from '../n8n-api/utils/mcp-context';
import { InstanceContext } from '../../../src/types/instance-context';
import { handleValidateWorkflow } from '../../../src/mcp/handlers-n8n-manager';
import { getNodeRepository, closeNodeRepository } from '../n8n-api/utils/node-repository';
import { NodeRepository } from '../../../src/database/node-repository';
import { ValidationResponse } from '../n8n-api/types/mcp-responses';
import {
createAIAgentNode,
createChatTriggerNode,
createLanguageModelNode,
createHTTPRequestToolNode,
createCodeToolNode,
createMemoryNode,
createRespondNode,
createAIConnection,
createMainConnection,
mergeConnections,
createAIWorkflow
} from './helpers';
describe('Integration: AI Agent Validation', () => {
let context: TestContext;
let client: N8nApiClient;
let mcpContext: InstanceContext;
let repository: NodeRepository;
beforeEach(async () => {
context = createTestContext();
client = getTestN8nClient();
mcpContext = createMcpContext();
repository = await getNodeRepository();
});
afterEach(async () => {
await context.cleanup();
});
afterAll(async () => {
await closeNodeRepository();
if (!process.env.CI) {
await cleanupOrphanedWorkflows();
}
});
// ======================================================================
// TEST 1: Missing Language Model
// ======================================================================
it('should detect missing language model in real workflow', async () => {
const agent = createAIAgentNode({
name: 'AI Agent',
text: 'Test prompt'
});
const workflow = createAIWorkflow(
[agent],
{},
{
name: createTestWorkflowName('AI Agent - Missing Model'),
tags: ['mcp-integration-test', 'ai-validation']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as ValidationResponse;
expect(data.valid).toBe(false);
expect(data.errors).toBeDefined();
expect(data.errors!.length).toBeGreaterThan(0);
const errorCodes = data.errors!.map(e => e.details?.code || e.code);
expect(errorCodes).toContain('MISSING_LANGUAGE_MODEL');
const errorMessages = data.errors!.map(e => e.message).join(' ');
expect(errorMessages).toMatch(/language model|ai_languageModel/i);
});
// ======================================================================
// TEST 2: Valid AI Agent with Language Model
// ======================================================================
it('should validate AI Agent with language model', async () => {
const languageModel = createLanguageModelNode('openai', {
name: 'OpenAI Chat Model'
});
const agent = createAIAgentNode({
name: 'AI Agent',
text: 'You are a helpful assistant'
});
const workflow = createAIWorkflow(
[languageModel, agent],
mergeConnections(
createAIConnection('OpenAI Chat Model', 'AI Agent', 'ai_languageModel')
),
{
name: createTestWorkflowName('AI Agent - Valid'),
tags: ['mcp-integration-test', 'ai-validation']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as ValidationResponse;
expect(data.valid).toBe(true);
expect(data.errors).toBeUndefined();
expect(data.summary.errorCount).toBe(0);
});
// ======================================================================
// TEST 3: Tool Connections Detection
// ======================================================================
it('should detect tool connections correctly', async () => {
const languageModel = createLanguageModelNode('openai', {
name: 'OpenAI Chat Model'
});
const httpTool = createHTTPRequestToolNode({
name: 'HTTP Request Tool',
toolDescription: 'Fetches weather data from API',
url: 'https://api.weather.com/current',
method: 'GET'
});
const agent = createAIAgentNode({
name: 'AI Agent',
text: 'You are a weather assistant'
});
const workflow = createAIWorkflow(
[languageModel, httpTool, agent],
mergeConnections(
createAIConnection('OpenAI Chat Model', 'AI Agent', 'ai_languageModel'),
createAIConnection('HTTP Request Tool', 'AI Agent', 'ai_tool')
),
{
name: createTestWorkflowName('AI Agent - With Tool'),
tags: ['mcp-integration-test', 'ai-validation']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as ValidationResponse;
expect(data.valid).toBe(true);
// Should NOT have false "no tools" warning
if (data.warnings) {
const toolWarnings = data.warnings.filter(w =>
w.message.toLowerCase().includes('no ai_tool')
);
expect(toolWarnings.length).toBe(0);
}
});
// ======================================================================
// TEST 4: Streaming Mode Constraints (Chat Trigger)
// ======================================================================
it('should validate streaming mode constraints', async () => {
const chatTrigger = createChatTriggerNode({
name: 'Chat Trigger',
responseMode: 'streaming'
});
const languageModel = createLanguageModelNode('openai', {
name: 'OpenAI Chat Model'
});
const agent = createAIAgentNode({
name: 'AI Agent',
text: 'You are a helpful assistant'
});
const respond = createRespondNode({
name: 'Respond to Webhook'
});
const workflow = createAIWorkflow(
[chatTrigger, languageModel, agent, respond],
mergeConnections(
createMainConnection('Chat Trigger', 'AI Agent'),
createAIConnection('OpenAI Chat Model', 'AI Agent', 'ai_languageModel'),
createMainConnection('AI Agent', 'Respond to Webhook') // ERROR: streaming with main output
),
{
name: createTestWorkflowName('AI Agent - Streaming Error'),
tags: ['mcp-integration-test', 'ai-validation']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as ValidationResponse;
expect(data.valid).toBe(false);
expect(data.errors).toBeDefined();
const streamingErrors = data.errors!.filter(e => {
const code = e.details?.code || e.code;
return code === 'STREAMING_WITH_MAIN_OUTPUT' ||
code === 'STREAMING_AGENT_HAS_OUTPUT';
});
expect(streamingErrors.length).toBeGreaterThan(0);
});
// ======================================================================
// TEST 5: AI Agent Own streamResponse Setting
// ======================================================================
it('should validate AI Agent own streamResponse setting', async () => {
const languageModel = createLanguageModelNode('openai', {
name: 'OpenAI Chat Model'
});
const agent = createAIAgentNode({
name: 'AI Agent',
text: 'You are a helpful assistant',
streamResponse: true // Agent has its own streaming enabled
});
const respond = createRespondNode({
name: 'Respond to Webhook'
});
const workflow = createAIWorkflow(
[languageModel, agent, respond],
mergeConnections(
createAIConnection('OpenAI Chat Model', 'AI Agent', 'ai_languageModel'),
createMainConnection('AI Agent', 'Respond to Webhook') // ERROR: streaming with main output
),
{
name: createTestWorkflowName('AI Agent - Own Streaming'),
tags: ['mcp-integration-test', 'ai-validation']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as ValidationResponse;
expect(data.valid).toBe(false);
expect(data.errors).toBeDefined();
const errorCodes = data.errors!.map(e => e.details?.code || e.code);
expect(errorCodes).toContain('STREAMING_WITH_MAIN_OUTPUT');
});
// ======================================================================
// TEST 6: Multiple Memory Connections
// ======================================================================
it('should validate memory connections', async () => {
const languageModel = createLanguageModelNode('openai', {
name: 'OpenAI Chat Model'
});
const memory1 = createMemoryNode({
name: 'Memory 1'
});
const memory2 = createMemoryNode({
name: 'Memory 2'
});
const agent = createAIAgentNode({
name: 'AI Agent',
text: 'You are a helpful assistant'
});
const workflow = createAIWorkflow(
[languageModel, memory1, memory2, agent],
mergeConnections(
createAIConnection('OpenAI Chat Model', 'AI Agent', 'ai_languageModel'),
createAIConnection('Memory 1', 'AI Agent', 'ai_memory'),
createAIConnection('Memory 2', 'AI Agent', 'ai_memory') // ERROR: multiple memory
),
{
name: createTestWorkflowName('AI Agent - Multiple Memory'),
tags: ['mcp-integration-test', 'ai-validation']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as ValidationResponse;
expect(data.valid).toBe(false);
expect(data.errors).toBeDefined();
const errorCodes = data.errors!.map(e => e.details?.code || e.code);
expect(errorCodes).toContain('MULTIPLE_MEMORY_CONNECTIONS');
});
// ======================================================================
// TEST 7: Complete AI Workflow (All Components)
// ======================================================================
it('should validate complete AI workflow', async () => {
const chatTrigger = createChatTriggerNode({
name: 'Chat Trigger',
responseMode: 'lastNode' // Not streaming
});
const languageModel = createLanguageModelNode('openai', {
name: 'OpenAI Chat Model'
});
const httpTool = createHTTPRequestToolNode({
name: 'HTTP Request Tool',
toolDescription: 'Fetches data from external API',
url: 'https://api.example.com/data',
method: 'GET'
});
const codeTool = createCodeToolNode({
name: 'Code Tool',
toolDescription: 'Processes data with custom logic',
code: 'return { result: "processed" };'
});
const memory = createMemoryNode({
name: 'Window Buffer Memory',
contextWindowLength: 5
});
const agent = createAIAgentNode({
name: 'AI Agent',
promptType: 'define',
text: 'You are a helpful assistant with access to tools',
systemMessage: 'You are an AI assistant that helps users with data processing and external API calls.'
});
const respond = createRespondNode({
name: 'Respond to Webhook'
});
const workflow = createAIWorkflow(
[chatTrigger, languageModel, httpTool, codeTool, memory, agent, respond],
mergeConnections(
createMainConnection('Chat Trigger', 'AI Agent'),
createAIConnection('OpenAI Chat Model', 'AI Agent', 'ai_languageModel'),
createAIConnection('HTTP Request Tool', 'AI Agent', 'ai_tool'),
createAIConnection('Code Tool', 'AI Agent', 'ai_tool'),
createAIConnection('Window Buffer Memory', 'AI Agent', 'ai_memory'),
createMainConnection('AI Agent', 'Respond to Webhook')
),
{
name: createTestWorkflowName('AI Agent - Complete Workflow'),
tags: ['mcp-integration-test', 'ai-validation']
}
);
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
const response = await handleValidateWorkflow(
{ id: created.id },
repository,
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as ValidationResponse;
expect(data.valid).toBe(true);
expect(data.errors).toBeUndefined();
expect(data.summary.errorCount).toBe(0);
});
});
```
--------------------------------------------------------------------------------
/tests/unit/services/task-templates.test.ts:
--------------------------------------------------------------------------------
```typescript
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { TaskTemplates } from '@/services/task-templates';
import type { TaskTemplate } from '@/services/task-templates';
// Mock the database
vi.mock('better-sqlite3');
describe('TaskTemplates', () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe('getTaskTemplate', () => {
it('should return template for get_api_data task', () => {
const template = TaskTemplates.getTaskTemplate('get_api_data');
expect(template).toBeDefined();
expect(template?.task).toBe('get_api_data');
expect(template?.nodeType).toBe('nodes-base.httpRequest');
expect(template?.configuration).toMatchObject({
method: 'GET',
retryOnFail: true,
maxTries: 3
});
});
it('should return template for webhook tasks', () => {
const template = TaskTemplates.getTaskTemplate('receive_webhook');
expect(template).toBeDefined();
expect(template?.nodeType).toBe('nodes-base.webhook');
expect(template?.configuration).toMatchObject({
httpMethod: 'POST',
responseMode: 'lastNode',
alwaysOutputData: true
});
});
it('should return template for database tasks', () => {
const template = TaskTemplates.getTaskTemplate('query_postgres');
expect(template).toBeDefined();
expect(template?.nodeType).toBe('nodes-base.postgres');
expect(template?.configuration).toMatchObject({
operation: 'executeQuery',
onError: 'continueRegularOutput'
});
});
it('should return undefined for unknown task', () => {
const template = TaskTemplates.getTaskTemplate('unknown_task');
expect(template).toBeUndefined();
});
it('should have getTemplate alias working', () => {
const template1 = TaskTemplates.getTaskTemplate('get_api_data');
const template2 = TaskTemplates.getTemplate('get_api_data');
expect(template1).toEqual(template2);
});
});
describe('template structure', () => {
it('should have all required fields in templates', () => {
const allTasks = TaskTemplates.getAllTasks();
allTasks.forEach(task => {
const template = TaskTemplates.getTaskTemplate(task);
expect(template).toBeDefined();
expect(template?.task).toBe(task);
expect(template?.description).toBeTruthy();
expect(template?.nodeType).toBeTruthy();
expect(template?.configuration).toBeDefined();
expect(template?.userMustProvide).toBeDefined();
expect(Array.isArray(template?.userMustProvide)).toBe(true);
});
});
it('should have proper user must provide structure', () => {
const template = TaskTemplates.getTaskTemplate('post_json_request');
expect(template?.userMustProvide).toHaveLength(2);
expect(template?.userMustProvide[0]).toMatchObject({
property: 'url',
description: expect.any(String),
example: 'https://api.example.com/users'
});
});
it('should have optional enhancements where applicable', () => {
const template = TaskTemplates.getTaskTemplate('get_api_data');
expect(template?.optionalEnhancements).toBeDefined();
expect(template?.optionalEnhancements?.length).toBeGreaterThan(0);
expect(template?.optionalEnhancements?.[0]).toHaveProperty('property');
expect(template?.optionalEnhancements?.[0]).toHaveProperty('description');
});
it('should have notes for complex templates', () => {
const template = TaskTemplates.getTaskTemplate('post_json_request');
expect(template?.notes).toBeDefined();
expect(template?.notes?.length).toBeGreaterThan(0);
expect(template?.notes?.[0]).toContain('JSON');
});
});
describe('special templates', () => {
it('should have process_webhook_data template with detailed code', () => {
const template = TaskTemplates.getTaskTemplate('process_webhook_data');
expect(template?.nodeType).toBe('nodes-base.code');
expect(template?.configuration.jsCode).toContain('items[0].json.body');
expect(template?.configuration.jsCode).toContain('❌ WRONG');
expect(template?.configuration.jsCode).toContain('✅ CORRECT');
expect(template?.notes?.[0]).toContain('WEBHOOK DATA IS AT items[0].json.body');
});
it('should have AI agent workflow template', () => {
const template = TaskTemplates.getTaskTemplate('ai_agent_workflow');
expect(template?.nodeType).toBe('nodes-langchain.agent');
expect(template?.configuration).toHaveProperty('systemMessage');
});
it('should have error handling pattern templates', () => {
const template = TaskTemplates.getTaskTemplate('modern_error_handling_patterns');
expect(template).toBeDefined();
expect(template?.configuration).toHaveProperty('onError', 'continueRegularOutput');
expect(template?.configuration).toHaveProperty('retryOnFail', true);
expect(template?.notes).toBeDefined();
});
it('should have AI tool templates', () => {
const template = TaskTemplates.getTaskTemplate('custom_ai_tool');
expect(template?.nodeType).toBe('nodes-base.code');
expect(template?.configuration.mode).toBe('runOnceForEachItem');
expect(template?.configuration.jsCode).toContain('$json');
});
});
describe('getAllTasks', () => {
it('should return all task names', () => {
const tasks = TaskTemplates.getAllTasks();
expect(Array.isArray(tasks)).toBe(true);
expect(tasks.length).toBeGreaterThan(20);
expect(tasks).toContain('get_api_data');
expect(tasks).toContain('receive_webhook');
expect(tasks).toContain('query_postgres');
});
});
describe('getTasksForNode', () => {
it('should return tasks for HTTP Request node', () => {
const tasks = TaskTemplates.getTasksForNode('nodes-base.httpRequest');
expect(tasks).toContain('get_api_data');
expect(tasks).toContain('post_json_request');
expect(tasks).toContain('call_api_with_auth');
expect(tasks).toContain('api_call_with_retry');
});
it('should return tasks for Code node', () => {
const tasks = TaskTemplates.getTasksForNode('nodes-base.code');
expect(tasks).toContain('transform_data');
expect(tasks).toContain('process_webhook_data');
expect(tasks).toContain('custom_ai_tool');
expect(tasks).toContain('aggregate_data');
});
it('should return tasks for Webhook node', () => {
const tasks = TaskTemplates.getTasksForNode('nodes-base.webhook');
expect(tasks).toContain('receive_webhook');
expect(tasks).toContain('webhook_with_response');
expect(tasks).toContain('webhook_with_error_handling');
});
it('should return empty array for unknown node', () => {
const tasks = TaskTemplates.getTasksForNode('nodes-base.unknownNode');
expect(tasks).toEqual([]);
});
});
describe('searchTasks', () => {
it('should find tasks by name', () => {
const tasks = TaskTemplates.searchTasks('webhook');
expect(tasks).toContain('receive_webhook');
expect(tasks).toContain('webhook_with_response');
expect(tasks).toContain('process_webhook_data');
});
it('should find tasks by description', () => {
const tasks = TaskTemplates.searchTasks('resilient');
expect(tasks.length).toBeGreaterThan(0);
expect(tasks.some(t => {
const template = TaskTemplates.getTaskTemplate(t);
return template?.description.toLowerCase().includes('resilient');
})).toBe(true);
});
it('should find tasks by node type', () => {
const tasks = TaskTemplates.searchTasks('postgres');
expect(tasks).toContain('query_postgres');
expect(tasks).toContain('insert_postgres_data');
});
it('should be case insensitive', () => {
const tasks1 = TaskTemplates.searchTasks('WEBHOOK');
const tasks2 = TaskTemplates.searchTasks('webhook');
expect(tasks1).toEqual(tasks2);
});
it('should return empty array for no matches', () => {
const tasks = TaskTemplates.searchTasks('xyz123nonexistent');
expect(tasks).toEqual([]);
});
});
describe('getTaskCategories', () => {
it('should return all task categories', () => {
const categories = TaskTemplates.getTaskCategories();
expect(Object.keys(categories)).toContain('HTTP/API');
expect(Object.keys(categories)).toContain('Webhooks');
expect(Object.keys(categories)).toContain('Database');
expect(Object.keys(categories)).toContain('AI/LangChain');
expect(Object.keys(categories)).toContain('Data Processing');
expect(Object.keys(categories)).toContain('Communication');
expect(Object.keys(categories)).toContain('Error Handling');
});
it('should have tasks assigned to categories', () => {
const categories = TaskTemplates.getTaskCategories();
expect(categories['HTTP/API']).toContain('get_api_data');
expect(categories['Webhooks']).toContain('receive_webhook');
expect(categories['Database']).toContain('query_postgres');
expect(categories['AI/LangChain']).toContain('chat_with_ai');
});
it('should have tasks in multiple categories where appropriate', () => {
const categories = TaskTemplates.getTaskCategories();
// process_webhook_data should be in both Webhooks and Data Processing
expect(categories['Webhooks']).toContain('process_webhook_data');
expect(categories['Data Processing']).toContain('process_webhook_data');
});
});
describe('error handling templates', () => {
it('should have proper retry configuration', () => {
const template = TaskTemplates.getTaskTemplate('api_call_with_retry');
expect(template?.configuration).toMatchObject({
retryOnFail: true,
maxTries: 5,
waitBetweenTries: 2000,
alwaysOutputData: true
});
});
it('should have database transaction safety template', () => {
const template = TaskTemplates.getTaskTemplate('database_transaction_safety');
expect(template?.configuration).toMatchObject({
onError: 'continueErrorOutput',
retryOnFail: false, // Transactions should not be retried
alwaysOutputData: true
});
});
it('should have AI rate limit handling', () => {
const template = TaskTemplates.getTaskTemplate('ai_rate_limit_handling');
expect(template?.configuration).toMatchObject({
retryOnFail: true,
maxTries: 5,
waitBetweenTries: 5000 // Longer wait for rate limits
});
});
});
describe('code node templates', () => {
it('should have aggregate data template', () => {
const template = TaskTemplates.getTaskTemplate('aggregate_data');
expect(template?.configuration.jsCode).toContain('stats');
expect(template?.configuration.jsCode).toContain('average');
expect(template?.configuration.jsCode).toContain('median');
});
it('should have batch processing template', () => {
const template = TaskTemplates.getTaskTemplate('batch_process_with_api');
expect(template?.configuration.jsCode).toContain('BATCH_SIZE');
expect(template?.configuration.jsCode).toContain('$helpers.httpRequest');
});
it('should have error safe transform template', () => {
const template = TaskTemplates.getTaskTemplate('error_safe_transform');
expect(template?.configuration.jsCode).toContain('required fields');
expect(template?.configuration.jsCode).toContain('validation');
expect(template?.configuration.jsCode).toContain('summary');
});
it('should have async processing template', () => {
const template = TaskTemplates.getTaskTemplate('async_data_processing');
expect(template?.configuration.jsCode).toContain('CONCURRENT_LIMIT');
expect(template?.configuration.jsCode).toContain('Promise.all');
});
it('should have Python data analysis template', () => {
const template = TaskTemplates.getTaskTemplate('python_data_analysis');
expect(template?.configuration.language).toBe('python');
expect(template?.configuration.pythonCode).toContain('_input.all()');
expect(template?.configuration.pythonCode).toContain('statistics');
});
});
describe('template configurations', () => {
it('should have proper error handling defaults', () => {
const apiTemplate = TaskTemplates.getTaskTemplate('get_api_data');
const webhookTemplate = TaskTemplates.getTaskTemplate('receive_webhook');
const dbWriteTemplate = TaskTemplates.getTaskTemplate('insert_postgres_data');
// API calls should continue on error
expect(apiTemplate?.configuration.onError).toBe('continueRegularOutput');
// Webhooks should always respond
expect(webhookTemplate?.configuration.onError).toBe('continueRegularOutput');
expect(webhookTemplate?.configuration.alwaysOutputData).toBe(true);
// Database writes should stop on error
expect(dbWriteTemplate?.configuration.onError).toBe('stopWorkflow');
});
it('should have appropriate retry configurations', () => {
const apiTemplate = TaskTemplates.getTaskTemplate('get_api_data');
const dbTemplate = TaskTemplates.getTaskTemplate('query_postgres');
const aiTemplate = TaskTemplates.getTaskTemplate('chat_with_ai');
// API calls: moderate retries
expect(apiTemplate?.configuration.maxTries).toBe(3);
expect(apiTemplate?.configuration.waitBetweenTries).toBe(1000);
// Database reads: can retry
expect(dbTemplate?.configuration.retryOnFail).toBe(true);
// AI calls: longer waits for rate limits
expect(aiTemplate?.configuration.waitBetweenTries).toBe(5000);
});
});
});
```
--------------------------------------------------------------------------------
/tests/unit/scripts/fetch-templates-extraction.test.ts:
--------------------------------------------------------------------------------
```typescript
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import * as zlib from 'zlib';
/**
* Unit tests for template configuration extraction functions
* Testing the core logic from fetch-templates.ts
*/
// Extract the functions to test by importing or recreating them
function extractNodeConfigs(
templateId: number,
templateName: string,
templateViews: number,
workflowCompressed: string,
metadata: any
): Array<{
node_type: string;
template_id: number;
template_name: string;
template_views: number;
node_name: string;
parameters_json: string;
credentials_json: string | null;
has_credentials: number;
has_expressions: number;
complexity: string;
use_cases: string;
}> {
try {
const decompressed = zlib.gunzipSync(Buffer.from(workflowCompressed, 'base64'));
const workflow = JSON.parse(decompressed.toString('utf-8'));
const configs: any[] = [];
for (const node of workflow.nodes || []) {
if (node.type.includes('stickyNote') || !node.parameters) {
continue;
}
configs.push({
node_type: node.type,
template_id: templateId,
template_name: templateName,
template_views: templateViews,
node_name: node.name,
parameters_json: JSON.stringify(node.parameters),
credentials_json: node.credentials ? JSON.stringify(node.credentials) : null,
has_credentials: node.credentials ? 1 : 0,
has_expressions: detectExpressions(node.parameters) ? 1 : 0,
complexity: metadata?.complexity || 'medium',
use_cases: JSON.stringify(metadata?.use_cases || [])
});
}
return configs;
} catch (error) {
return [];
}
}
function detectExpressions(params: any): boolean {
if (!params) return false;
const json = JSON.stringify(params);
return json.includes('={{') || json.includes('$json') || json.includes('$node');
}
describe('Template Configuration Extraction', () => {
describe('extractNodeConfigs', () => {
it('should extract configs from valid workflow with multiple nodes', () => {
const workflow = {
nodes: [
{
id: 'node1',
name: 'Webhook',
type: 'n8n-nodes-base.webhook',
typeVersion: 1,
position: [100, 100],
parameters: {
httpMethod: 'POST',
path: 'webhook-test'
}
},
{
id: 'node2',
name: 'HTTP Request',
type: 'n8n-nodes-base.httpRequest',
typeVersion: 3,
position: [300, 100],
parameters: {
url: 'https://api.example.com',
method: 'GET'
}
}
],
connections: {}
};
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const metadata = {
complexity: 'simple',
use_cases: ['webhook processing', 'API calls']
};
const configs = extractNodeConfigs(1, 'Test Template', 500, compressed, metadata);
expect(configs).toHaveLength(2);
expect(configs[0].node_type).toBe('n8n-nodes-base.webhook');
expect(configs[0].node_name).toBe('Webhook');
expect(configs[0].template_id).toBe(1);
expect(configs[0].template_name).toBe('Test Template');
expect(configs[0].template_views).toBe(500);
expect(configs[0].has_credentials).toBe(0);
expect(configs[0].complexity).toBe('simple');
const parsedParams = JSON.parse(configs[0].parameters_json);
expect(parsedParams.httpMethod).toBe('POST');
expect(parsedParams.path).toBe('webhook-test');
expect(configs[1].node_type).toBe('n8n-nodes-base.httpRequest');
expect(configs[1].node_name).toBe('HTTP Request');
});
it('should return empty array for workflow with no nodes', () => {
const workflow = { nodes: [], connections: {} };
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Empty Template', 100, compressed, null);
expect(configs).toHaveLength(0);
});
it('should skip sticky note nodes', () => {
const workflow = {
nodes: [
{
id: 'sticky1',
name: 'Note',
type: 'n8n-nodes-base.stickyNote',
typeVersion: 1,
position: [100, 100],
parameters: { content: 'This is a note' }
},
{
id: 'node1',
name: 'HTTP Request',
type: 'n8n-nodes-base.httpRequest',
typeVersion: 3,
position: [300, 100],
parameters: { url: 'https://api.example.com' }
}
],
connections: {}
};
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Test', 100, compressed, null);
expect(configs).toHaveLength(1);
expect(configs[0].node_type).toBe('n8n-nodes-base.httpRequest');
});
it('should skip nodes without parameters', () => {
const workflow = {
nodes: [
{
id: 'node1',
name: 'No Params',
type: 'n8n-nodes-base.someNode',
typeVersion: 1,
position: [100, 100]
// No parameters field
},
{
id: 'node2',
name: 'With Params',
type: 'n8n-nodes-base.httpRequest',
typeVersion: 3,
position: [300, 100],
parameters: { url: 'https://api.example.com' }
}
],
connections: {}
};
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Test', 100, compressed, null);
expect(configs).toHaveLength(1);
expect(configs[0].node_type).toBe('n8n-nodes-base.httpRequest');
});
it('should handle nodes with credentials', () => {
const workflow = {
nodes: [
{
id: 'node1',
name: 'Slack',
type: 'n8n-nodes-base.slack',
typeVersion: 1,
position: [100, 100],
parameters: {
resource: 'message',
operation: 'post'
},
credentials: {
slackApi: {
id: '1',
name: 'Slack API'
}
}
}
],
connections: {}
};
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Test', 100, compressed, null);
expect(configs).toHaveLength(1);
expect(configs[0].has_credentials).toBe(1);
expect(configs[0].credentials_json).toBeTruthy();
const creds = JSON.parse(configs[0].credentials_json!);
expect(creds.slackApi).toBeDefined();
});
it('should use default complexity when metadata is missing', () => {
const workflow = {
nodes: [
{
id: 'node1',
name: 'HTTP Request',
type: 'n8n-nodes-base.httpRequest',
typeVersion: 3,
position: [100, 100],
parameters: { url: 'https://api.example.com' }
}
],
connections: {}
};
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Test', 100, compressed, null);
expect(configs[0].complexity).toBe('medium');
expect(configs[0].use_cases).toBe('[]');
});
it('should handle malformed compressed data gracefully', () => {
const invalidCompressed = 'invalid-base64-data';
const configs = extractNodeConfigs(1, 'Test', 100, invalidCompressed, null);
expect(configs).toHaveLength(0);
});
it('should handle invalid JSON after decompression', () => {
const invalidJson = 'not valid json';
const compressed = zlib.gzipSync(Buffer.from(invalidJson)).toString('base64');
const configs = extractNodeConfigs(1, 'Test', 100, compressed, null);
expect(configs).toHaveLength(0);
});
it('should handle workflows with missing nodes array', () => {
const workflow = { connections: {} };
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Test', 100, compressed, null);
expect(configs).toHaveLength(0);
});
});
describe('detectExpressions', () => {
it('should detect n8n expression syntax with ={{...}}', () => {
const params = {
url: '={{ $json.apiUrl }}',
method: 'GET'
};
expect(detectExpressions(params)).toBe(true);
});
it('should detect $json references', () => {
const params = {
body: {
data: '$json.data'
}
};
expect(detectExpressions(params)).toBe(true);
});
it('should detect $node references', () => {
const params = {
url: 'https://api.example.com',
headers: {
authorization: '$node["Webhook"].json.token'
}
};
expect(detectExpressions(params)).toBe(true);
});
it('should return false for parameters without expressions', () => {
const params = {
url: 'https://api.example.com',
method: 'POST',
body: {
name: 'test'
}
};
expect(detectExpressions(params)).toBe(false);
});
it('should handle nested objects with expressions', () => {
const params = {
options: {
queryParameters: {
filters: {
id: '={{ $json.userId }}'
}
}
}
};
expect(detectExpressions(params)).toBe(true);
});
it('should return false for null parameters', () => {
expect(detectExpressions(null)).toBe(false);
});
it('should return false for undefined parameters', () => {
expect(detectExpressions(undefined)).toBe(false);
});
it('should return false for empty object', () => {
expect(detectExpressions({})).toBe(false);
});
it('should handle array parameters with expressions', () => {
const params = {
items: [
{ value: '={{ $json.item1 }}' },
{ value: '={{ $json.item2 }}' }
]
};
expect(detectExpressions(params)).toBe(true);
});
it('should detect multiple expression types in same params', () => {
const params = {
url: '={{ $node["HTTP Request"].json.nextUrl }}',
body: {
data: '$json.data',
token: '={{ $json.token }}'
}
};
expect(detectExpressions(params)).toBe(true);
});
});
describe('Edge Cases', () => {
it('should handle very large workflows without crashing', () => {
const nodes = Array.from({ length: 100 }, (_, i) => ({
id: `node${i}`,
name: `Node ${i}`,
type: 'n8n-nodes-base.httpRequest',
typeVersion: 3,
position: [100 * i, 100],
parameters: {
url: `https://api.example.com/${i}`,
method: 'GET'
}
}));
const workflow = { nodes, connections: {} };
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Large Template', 1000, compressed, null);
expect(configs).toHaveLength(100);
});
it('should handle special characters in node names and parameters', () => {
const workflow = {
nodes: [
{
id: 'node1',
name: 'Node with 特殊文字 & émojis 🎉',
type: 'n8n-nodes-base.httpRequest',
typeVersion: 3,
position: [100, 100],
parameters: {
url: 'https://api.example.com?query=test&special=值',
headers: {
'X-Custom-Header': 'value with spaces & symbols!@#$%'
}
}
}
],
connections: {}
};
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Test', 100, compressed, null);
expect(configs).toHaveLength(1);
expect(configs[0].node_name).toBe('Node with 特殊文字 & émojis 🎉');
const params = JSON.parse(configs[0].parameters_json);
expect(params.headers['X-Custom-Header']).toBe('value with spaces & symbols!@#$%');
});
it('should preserve parameter structure exactly as in workflow', () => {
const workflow = {
nodes: [
{
id: 'node1',
name: 'Complex Node',
type: 'n8n-nodes-base.httpRequest',
typeVersion: 3,
position: [100, 100],
parameters: {
url: 'https://api.example.com',
options: {
queryParameters: {
filters: [
{ name: 'status', value: 'active' },
{ name: 'type', value: 'user' }
]
},
timeout: 10000,
redirect: {
followRedirects: true,
maxRedirects: 5
}
}
}
}
],
connections: {}
};
const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(workflow))).toString('base64');
const configs = extractNodeConfigs(1, 'Test', 100, compressed, null);
const params = JSON.parse(configs[0].parameters_json);
expect(params.options.queryParameters.filters).toHaveLength(2);
expect(params.options.timeout).toBe(10000);
expect(params.options.redirect.maxRedirects).toBe(5);
});
});
});
```
--------------------------------------------------------------------------------
/tests/integration/n8n-api/workflows/list-workflows.test.ts:
--------------------------------------------------------------------------------
```typescript
/**
* Integration Tests: handleListWorkflows
*
* Tests workflow listing against a real n8n instance.
* Covers filtering, pagination, and various list parameters.
*/
import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
import { createTestContext, TestContext, createTestWorkflowName } from '../utils/test-context';
import { getTestN8nClient } from '../utils/n8n-client';
import { N8nApiClient } from '../../../../src/services/n8n-api-client';
import { SIMPLE_WEBHOOK_WORKFLOW, SIMPLE_HTTP_WORKFLOW } from '../utils/fixtures';
import { cleanupOrphanedWorkflows } from '../utils/cleanup-helpers';
import { createMcpContext } from '../utils/mcp-context';
import { InstanceContext } from '../../../../src/types/instance-context';
import { handleListWorkflows } from '../../../../src/mcp/handlers-n8n-manager';
describe('Integration: handleListWorkflows', () => {
let context: TestContext;
let client: N8nApiClient;
let mcpContext: InstanceContext;
beforeEach(() => {
context = createTestContext();
client = getTestN8nClient();
mcpContext = createMcpContext();
});
afterEach(async () => {
await context.cleanup();
});
afterAll(async () => {
if (!process.env.CI) {
await cleanupOrphanedWorkflows();
}
});
// ======================================================================
// No Filters
// ======================================================================
describe('No Filters', () => {
it('should list all workflows without filters', async () => {
// Create test workflows
const workflow1 = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('List - All 1'),
tags: ['mcp-integration-test']
};
const workflow2 = {
...SIMPLE_HTTP_WORKFLOW,
name: createTestWorkflowName('List - All 2'),
tags: ['mcp-integration-test']
};
const created1 = await client.createWorkflow(workflow1);
const created2 = await client.createWorkflow(workflow2);
context.trackWorkflow(created1.id!);
context.trackWorkflow(created2.id!);
// List workflows without filters
const response = await handleListWorkflows({}, mcpContext);
expect(response.success).toBe(true);
expect(response.data).toBeDefined();
const data = response.data as any;
expect(Array.isArray(data.workflows)).toBe(true);
expect(data.workflows.length).toBeGreaterThan(0);
// Our workflows should be in the list
const workflow1Found = data.workflows.find((w: any) => w.id === created1.id);
const workflow2Found = data.workflows.find((w: any) => w.id === created2.id);
expect(workflow1Found).toBeDefined();
expect(workflow2Found).toBeDefined();
});
});
// ======================================================================
// Filter by Active Status
// ======================================================================
describe('Filter by Active Status', () => {
it('should filter workflows by active=true', async () => {
// Create active workflow
const activeWorkflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('List - Active'),
active: true,
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(activeWorkflow);
context.trackWorkflow(created.id!);
// Activate workflow
await client.updateWorkflow(created.id!, {
...activeWorkflow,
active: true
});
// List active workflows
const response = await handleListWorkflows(
{ active: true },
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
// All returned workflows should be active
data.workflows.forEach((w: any) => {
expect(w.active).toBe(true);
});
});
it('should filter workflows by active=false', async () => {
// Create inactive workflow
const inactiveWorkflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('List - Inactive'),
active: false,
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(inactiveWorkflow);
context.trackWorkflow(created.id!);
// List inactive workflows
const response = await handleListWorkflows(
{ active: false },
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
// All returned workflows should be inactive
data.workflows.forEach((w: any) => {
expect(w.active).toBe(false);
});
// Our workflow should be in the list
const found = data.workflows.find((w: any) => w.id === created.id);
expect(found).toBeDefined();
});
});
// ======================================================================
// Filter by Tags
// ======================================================================
describe('Filter by Tags', () => {
it('should filter workflows by name instead of tags', async () => {
// Note: Tags filtering requires tag IDs, not names, and tags are readonly in workflow creation
// This test filters by name instead, which is more reliable for integration testing
const uniqueName = createTestWorkflowName('List - Name Filter Test');
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: uniqueName,
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
// List all workflows and verify ours is included
const response = await handleListWorkflows({}, mcpContext);
expect(response.success).toBe(true);
const data = response.data as any;
// Our workflow should be in the list
const found = data.workflows.find((w: any) => w.id === created.id);
expect(found).toBeDefined();
expect(found.name).toBe(uniqueName);
});
});
// ======================================================================
// Pagination
// ======================================================================
describe('Pagination', () => {
it('should return first page with limit', async () => {
// Create multiple workflows
const workflows = [];
for (let i = 0; i < 3; i++) {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName(`List - Page ${i}`),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
workflows.push(created);
}
// List first page with limit
const response = await handleListWorkflows(
{ limit: 2 },
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.workflows.length).toBeLessThanOrEqual(2);
expect(data.hasMore).toBeDefined();
expect(data.nextCursor).toBeDefined();
});
it('should handle pagination with cursor', async () => {
// Create multiple workflows
for (let i = 0; i < 5; i++) {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName(`List - Cursor ${i}`),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
}
// Get first page
const firstPage = await handleListWorkflows(
{ limit: 2 },
mcpContext
);
expect(firstPage.success).toBe(true);
const firstData = firstPage.data as any;
if (firstData.hasMore && firstData.nextCursor) {
// Get second page using cursor
const secondPage = await handleListWorkflows(
{ limit: 2, cursor: firstData.nextCursor },
mcpContext
);
expect(secondPage.success).toBe(true);
const secondData = secondPage.data as any;
// Second page should have different workflows
const firstIds = new Set(firstData.workflows.map((w: any) => w.id));
const secondIds = secondData.workflows.map((w: any) => w.id);
secondIds.forEach((id: string) => {
expect(firstIds.has(id)).toBe(false);
});
}
});
it('should handle last page (no more results)', async () => {
// Create single workflow
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('List - Last Page'),
tags: ['mcp-integration-test', 'unique-last-page-tag']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
// List with high limit and unique tag
const response = await handleListWorkflows(
{
tags: ['unique-last-page-tag'],
limit: 100
},
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
// Should not have more results
expect(data.hasMore).toBe(false);
expect(data.workflows.length).toBeLessThanOrEqual(100);
});
});
// ======================================================================
// Limit Variations
// ======================================================================
describe('Limit Variations', () => {
it('should respect limit=1', async () => {
// Create workflow
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('List - Limit 1'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
// List with limit=1
const response = await handleListWorkflows(
{ limit: 1 },
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.workflows.length).toBe(1);
});
it('should respect limit=50', async () => {
// List with limit=50
const response = await handleListWorkflows(
{ limit: 50 },
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.workflows.length).toBeLessThanOrEqual(50);
});
it('should respect limit=100 (max)', async () => {
// List with limit=100
const response = await handleListWorkflows(
{ limit: 100 },
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(data.workflows.length).toBeLessThanOrEqual(100);
});
});
// ======================================================================
// Exclude Pinned Data
// ======================================================================
describe('Exclude Pinned Data', () => {
it('should exclude pinned data when requested', async () => {
// Create workflow
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName('List - No Pinned Data'),
tags: ['mcp-integration-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
// List with excludePinnedData=true
const response = await handleListWorkflows(
{ excludePinnedData: true },
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
// Verify response doesn't include pinned data
data.workflows.forEach((w: any) => {
expect(w.pinData).toBeUndefined();
});
});
});
// ======================================================================
// Empty Results
// ======================================================================
describe('Empty Results', () => {
it('should return empty array when no workflows match filters', async () => {
// List with non-existent tag
const response = await handleListWorkflows(
{ tags: ['non-existent-tag-xyz-12345'] },
mcpContext
);
expect(response.success).toBe(true);
const data = response.data as any;
expect(Array.isArray(data.workflows)).toBe(true);
expect(data.workflows.length).toBe(0);
expect(data.hasMore).toBe(false);
});
});
// ======================================================================
// Sort Order Verification
// ======================================================================
describe('Sort Order', () => {
it('should return workflows in consistent order', async () => {
// Create multiple workflows
for (let i = 0; i < 3; i++) {
const workflow = {
...SIMPLE_WEBHOOK_WORKFLOW,
name: createTestWorkflowName(`List - Sort ${i}`),
tags: ['mcp-integration-test', 'sort-test']
};
const created = await client.createWorkflow(workflow);
context.trackWorkflow(created.id!);
// Small delay to ensure different timestamps
await new Promise(resolve => setTimeout(resolve, 100));
}
// List workflows twice
const response1 = await handleListWorkflows(
{ tags: ['sort-test'] },
mcpContext
);
const response2 = await handleListWorkflows(
{ tags: ['sort-test'] },
mcpContext
);
expect(response1.success).toBe(true);
expect(response2.success).toBe(true);
const data1 = response1.data as any;
const data2 = response2.data as any;
// Same workflows should be returned in same order
expect(data1.workflows.length).toBe(data2.workflows.length);
const ids1 = data1.workflows.map((w: any) => w.id);
const ids2 = data2.workflows.map((w: any) => w.id);
expect(ids1).toEqual(ids2);
});
});
});
```
--------------------------------------------------------------------------------
/src/parsers/node-parser.ts:
--------------------------------------------------------------------------------
```typescript
import { PropertyExtractor } from './property-extractor';
import type {
NodeClass,
VersionedNodeInstance
} from '../types/node-types';
import {
isVersionedNodeInstance,
isVersionedNodeClass,
getNodeDescription as getNodeDescriptionHelper
} from '../types/node-types';
import type { INodeTypeBaseDescription, INodeTypeDescription } from 'n8n-workflow';
export interface ParsedNode {
style: 'declarative' | 'programmatic';
nodeType: string;
displayName: string;
description?: string;
category?: string;
properties: any[];
credentials: any[];
isAITool: boolean;
isTrigger: boolean;
isWebhook: boolean;
operations: any[];
version?: string;
isVersioned: boolean;
packageName: string;
documentation?: string;
outputs?: any[];
outputNames?: string[];
}
export class NodeParser {
private propertyExtractor = new PropertyExtractor();
private currentNodeClass: NodeClass | null = null;
parse(nodeClass: NodeClass, packageName: string): ParsedNode {
this.currentNodeClass = nodeClass;
// Get base description (handles versioned nodes)
const description = this.getNodeDescription(nodeClass);
const outputInfo = this.extractOutputs(description);
return {
style: this.detectStyle(nodeClass),
nodeType: this.extractNodeType(description, packageName),
displayName: description.displayName || description.name,
description: description.description,
category: this.extractCategory(description),
properties: this.propertyExtractor.extractProperties(nodeClass),
credentials: this.propertyExtractor.extractCredentials(nodeClass),
isAITool: this.propertyExtractor.detectAIToolCapability(nodeClass),
isTrigger: this.detectTrigger(description),
isWebhook: this.detectWebhook(description),
operations: this.propertyExtractor.extractOperations(nodeClass),
version: this.extractVersion(nodeClass),
isVersioned: this.detectVersioned(nodeClass),
packageName: packageName,
outputs: outputInfo.outputs,
outputNames: outputInfo.outputNames
};
}
private getNodeDescription(nodeClass: NodeClass): INodeTypeBaseDescription | INodeTypeDescription {
// Try to get description from the class first
let description: INodeTypeBaseDescription | INodeTypeDescription | undefined;
// Check if it's a versioned node using type guard
if (isVersionedNodeClass(nodeClass)) {
// This is a VersionedNodeType class - instantiate it
try {
const instance = new (nodeClass as new () => VersionedNodeInstance)();
// Strategic any assertion for accessing both description and baseDescription
const inst = instance as any;
// Try description first (real VersionedNodeType with getter)
// Only fallback to baseDescription if nodeVersions exists (complete VersionedNodeType mock)
// This prevents using baseDescription for incomplete mocks that test edge cases
description = inst.description || (inst.nodeVersions ? inst.baseDescription : undefined);
// If still undefined (incomplete mock), leave as undefined to use catch block fallback
} catch (e) {
// Some nodes might require parameters to instantiate
}
} else if (typeof nodeClass === 'function') {
// Try to instantiate to get description
try {
const instance = new nodeClass();
description = instance.description;
// If description is empty or missing name, check for baseDescription fallback
if (!description || !description.name) {
const inst = instance as any;
if (inst.baseDescription?.name) {
description = inst.baseDescription;
}
}
} catch (e) {
// Some nodes might require parameters to instantiate
// Try to access static properties
description = (nodeClass as any).description;
}
} else {
// Maybe it's already an instance
description = nodeClass.description;
// If description is empty or missing name, check for baseDescription fallback
if (!description || !description.name) {
const inst = nodeClass as any;
if (inst.baseDescription?.name) {
description = inst.baseDescription;
}
}
}
return description || ({} as any);
}
private detectStyle(nodeClass: NodeClass): 'declarative' | 'programmatic' {
const desc = this.getNodeDescription(nodeClass);
return (desc as any).routing ? 'declarative' : 'programmatic';
}
private extractNodeType(description: INodeTypeBaseDescription | INodeTypeDescription, packageName: string): string {
// Ensure we have the full node type including package prefix
const name = description.name;
if (!name) {
throw new Error('Node is missing name property');
}
if (name.includes('.')) {
return name;
}
// Add package prefix if missing
const packagePrefix = packageName.replace('@n8n/', '').replace('n8n-', '');
return `${packagePrefix}.${name}`;
}
private extractCategory(description: INodeTypeBaseDescription | INodeTypeDescription): string {
return description.group?.[0] ||
(description as any).categories?.[0] ||
(description as any).category ||
'misc';
}
private detectTrigger(description: INodeTypeBaseDescription | INodeTypeDescription): boolean {
// Strategic any assertion for properties that only exist on INodeTypeDescription
const desc = description as any;
// Primary check: group includes 'trigger'
if (description.group && Array.isArray(description.group)) {
if (description.group.includes('trigger')) {
return true;
}
}
// Fallback checks for edge cases
return desc.polling === true ||
desc.trigger === true ||
desc.eventTrigger === true ||
description.name?.toLowerCase().includes('trigger');
}
private detectWebhook(description: INodeTypeBaseDescription | INodeTypeDescription): boolean {
const desc = description as any; // INodeTypeDescription has webhooks, but INodeTypeBaseDescription doesn't
return (desc.webhooks?.length > 0) ||
desc.webhook === true ||
description.name?.toLowerCase().includes('webhook');
}
/**
* Extracts the version from a node class.
*
* Priority Chain:
* 1. Instance currentVersion (VersionedNodeType's computed property)
* 2. Instance description.defaultVersion (explicit default)
* 3. Instance nodeVersions (fallback to max available version)
* 4. Description version array (legacy nodes)
* 5. Description version scalar (simple versioning)
* 6. Class-level properties (if instantiation fails)
* 7. Default to "1"
*
* Critical Fix (v2.17.4): Removed check for non-existent instance.baseDescription.defaultVersion
* which caused AI Agent to incorrectly return version "3" instead of "2.2"
*
* @param nodeClass - The node class or instance to extract version from
* @returns The version as a string
*/
private extractVersion(nodeClass: NodeClass): string {
// Check instance properties first
try {
const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
// Strategic any assertion - instance could be INodeType or IVersionedNodeType
const inst = instance as any;
// PRIORITY 1: Check currentVersion (what VersionedNodeType actually uses)
// For VersionedNodeType, currentVersion = defaultVersion ?? max(nodeVersions)
if (inst?.currentVersion !== undefined) {
return inst.currentVersion.toString();
}
// PRIORITY 2: Handle instance-level description.defaultVersion
// VersionedNodeType stores baseDescription as 'description', not 'baseDescription'
if (inst?.description?.defaultVersion) {
return inst.description.defaultVersion.toString();
}
// PRIORITY 3: Handle instance-level nodeVersions (fallback to max)
if (inst?.nodeVersions) {
const versions = Object.keys(inst.nodeVersions).map(Number);
if (versions.length > 0) {
const maxVersion = Math.max(...versions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
}
// Handle version array in description (e.g., [1, 1.1, 1.2])
if (inst?.description?.version) {
const version = inst.description.version;
if (Array.isArray(version)) {
const numericVersions = version.map((v: any) => parseFloat(v.toString()));
if (numericVersions.length > 0) {
const maxVersion = Math.max(...numericVersions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
} else if (typeof version === 'number' || typeof version === 'string') {
return version.toString();
}
}
} catch (e) {
// Some nodes might require parameters to instantiate
// Try class-level properties
}
// Handle class-level VersionedNodeType with defaultVersion
// Note: Most VersionedNodeType classes don't have static properties
// Strategic any assertion for class-level property access
const nodeClassAny = nodeClass as any;
if (nodeClassAny.description?.defaultVersion) {
return nodeClassAny.description.defaultVersion.toString();
}
// Handle class-level VersionedNodeType with nodeVersions
if (nodeClassAny.nodeVersions) {
const versions = Object.keys(nodeClassAny.nodeVersions).map(Number);
if (versions.length > 0) {
const maxVersion = Math.max(...versions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
}
// Also check class-level description for version array
const description = this.getNodeDescription(nodeClass);
const desc = description as any; // Strategic assertion for version property
if (desc?.version) {
if (Array.isArray(desc.version)) {
const numericVersions = desc.version.map((v: any) => parseFloat(v.toString()));
if (numericVersions.length > 0) {
const maxVersion = Math.max(...numericVersions);
if (!isNaN(maxVersion)) {
return maxVersion.toString();
}
}
} else if (typeof desc.version === 'number' || typeof desc.version === 'string') {
return desc.version.toString();
}
}
// Default to version 1
return '1';
}
private detectVersioned(nodeClass: NodeClass): boolean {
// Check instance-level properties first
try {
const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
// Strategic any assertion - instance could be INodeType or IVersionedNodeType
const inst = instance as any;
// Check for instance baseDescription with defaultVersion
if (inst?.baseDescription?.defaultVersion) {
return true;
}
// Check for nodeVersions
if (inst?.nodeVersions) {
return true;
}
// Check for version array in description
if (inst?.description?.version && Array.isArray(inst.description.version)) {
return true;
}
} catch (e) {
// Some nodes might require parameters to instantiate
// Try class-level checks
}
// Check class-level nodeVersions
// Strategic any assertion for class-level property access
const nodeClassAny = nodeClass as any;
if (nodeClassAny.nodeVersions || nodeClassAny.baseDescription?.defaultVersion) {
return true;
}
// Also check class-level description for version array
const description = this.getNodeDescription(nodeClass);
const desc = description as any; // Strategic assertion for version property
if (desc?.version && Array.isArray(desc.version)) {
return true;
}
return false;
}
private extractOutputs(description: INodeTypeBaseDescription | INodeTypeDescription): { outputs?: any[], outputNames?: string[] } {
const result: { outputs?: any[], outputNames?: string[] } = {};
// Strategic any assertion for outputs/outputNames properties
const desc = description as any;
// First check the base description
if (desc.outputs) {
result.outputs = Array.isArray(desc.outputs) ? desc.outputs : [desc.outputs];
}
if (desc.outputNames) {
result.outputNames = Array.isArray(desc.outputNames) ? desc.outputNames : [desc.outputNames];
}
// If no outputs found and this is a versioned node, check the latest version
if (!result.outputs && !result.outputNames) {
const nodeClass = this.currentNodeClass; // We'll need to track this
if (nodeClass) {
try {
const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
// Strategic any assertion for instance properties
const inst = instance as any;
if (inst.nodeVersions) {
// Get the latest version
const versions = Object.keys(inst.nodeVersions).map(Number);
if (versions.length > 0) {
const latestVersion = Math.max(...versions);
if (!isNaN(latestVersion)) {
const versionedDescription = inst.nodeVersions[latestVersion]?.description;
if (versionedDescription) {
if (versionedDescription.outputs) {
result.outputs = Array.isArray(versionedDescription.outputs)
? versionedDescription.outputs
: [versionedDescription.outputs];
}
if (versionedDescription.outputNames) {
result.outputNames = Array.isArray(versionedDescription.outputNames)
? versionedDescription.outputNames
: [versionedDescription.outputNames];
}
}
}
}
}
} catch (e) {
// Ignore errors from instantiating node
}
}
}
return result;
}
}
```
--------------------------------------------------------------------------------
/tests/unit/services/property-filter.test.ts:
--------------------------------------------------------------------------------
```typescript
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { PropertyFilter } from '@/services/property-filter';
import type { SimplifiedProperty, FilteredProperties } from '@/services/property-filter';
// Mock the database
vi.mock('better-sqlite3');
describe('PropertyFilter', () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe('deduplicateProperties', () => {
it('should remove duplicate properties with same name and conditions', () => {
const properties = [
{ name: 'url', type: 'string', displayOptions: { show: { method: ['GET'] } } },
{ name: 'url', type: 'string', displayOptions: { show: { method: ['GET'] } } }, // Duplicate
{ name: 'url', type: 'string', displayOptions: { show: { method: ['POST'] } } }, // Different condition
];
const result = PropertyFilter.deduplicateProperties(properties);
expect(result).toHaveLength(2);
expect(result[0].name).toBe('url');
expect(result[1].name).toBe('url');
expect(result[0].displayOptions).not.toEqual(result[1].displayOptions);
});
it('should handle properties without displayOptions', () => {
const properties = [
{ name: 'timeout', type: 'number' },
{ name: 'timeout', type: 'number' }, // Duplicate
{ name: 'retries', type: 'number' },
];
const result = PropertyFilter.deduplicateProperties(properties);
expect(result).toHaveLength(2);
expect(result.map(p => p.name)).toEqual(['timeout', 'retries']);
});
});
describe('getEssentials', () => {
it('should return configured essentials for HTTP Request node', () => {
const properties = [
{ name: 'url', type: 'string', required: true },
{ name: 'method', type: 'options', options: ['GET', 'POST'] },
{ name: 'authentication', type: 'options' },
{ name: 'sendBody', type: 'boolean' },
{ name: 'contentType', type: 'options' },
{ name: 'sendHeaders', type: 'boolean' },
{ name: 'someRareOption', type: 'string' },
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.httpRequest');
expect(result.required).toHaveLength(1);
expect(result.required[0].name).toBe('url');
expect(result.required[0].required).toBe(true);
expect(result.common).toHaveLength(5);
expect(result.common.map(p => p.name)).toEqual([
'method',
'authentication',
'sendBody',
'contentType',
'sendHeaders'
]);
});
it('should handle nested properties in collections', () => {
const properties = [
{
name: 'assignments',
type: 'collection',
options: [
{ name: 'field', type: 'string' },
{ name: 'value', type: 'string' }
]
}
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.set');
expect(result.common.some(p => p.name === 'assignments')).toBe(true);
});
it('should infer essentials for unconfigured nodes', () => {
const properties = [
{ name: 'requiredField', type: 'string', required: true },
{ name: 'simpleField', type: 'string' },
{ name: 'conditionalField', type: 'string', displayOptions: { show: { mode: ['advanced'] } } },
{ name: 'complexField', type: 'collection' },
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
expect(result.required).toHaveLength(1);
expect(result.required[0].name).toBe('requiredField');
// May include both simpleField and complexField (collection type)
expect(result.common.length).toBeGreaterThanOrEqual(1);
expect(result.common.some(p => p.name === 'simpleField')).toBe(true);
});
it('should include conditional properties when needed to reach minimum count', () => {
const properties = [
{ name: 'field1', type: 'string' },
{ name: 'field2', type: 'string', displayOptions: { show: { mode: ['basic'] } } },
{ name: 'field3', type: 'string', displayOptions: { show: { mode: ['advanced'], type: ['custom'] } } },
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
expect(result.common).toHaveLength(2);
expect(result.common[0].name).toBe('field1');
expect(result.common[1].name).toBe('field2'); // Single condition included
});
});
describe('property simplification', () => {
it('should simplify options properly', () => {
const properties = [
{
name: 'method',
type: 'options',
displayName: 'HTTP Method',
options: [
{ name: 'GET', value: 'GET' },
{ name: 'POST', value: 'POST' },
{ name: 'PUT', value: 'PUT' }
]
}
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.httpRequest');
const methodProp = result.common.find(p => p.name === 'method');
expect(methodProp?.options).toHaveLength(3);
expect(methodProp?.options?.[0]).toEqual({ value: 'GET', label: 'GET' });
});
it('should handle string array options', () => {
const properties = [
{
name: 'resource',
type: 'options',
options: ['user', 'post', 'comment']
}
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
const resourceProp = result.common.find(p => p.name === 'resource');
expect(resourceProp?.options).toEqual([
{ value: 'user', label: 'user' },
{ value: 'post', label: 'post' },
{ value: 'comment', label: 'comment' }
]);
});
it('should include simple display conditions', () => {
const properties = [
{
name: 'channel',
type: 'string',
displayOptions: {
show: {
resource: ['message'],
operation: ['post']
}
}
}
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.slack');
const channelProp = result.common.find(p => p.name === 'channel');
expect(channelProp?.showWhen).toEqual({
resource: ['message'],
operation: ['post']
});
});
it('should exclude complex display conditions', () => {
const properties = [
{
name: 'complexField',
type: 'string',
displayOptions: {
show: {
mode: ['advanced'],
type: ['custom'],
enabled: [true],
resource: ['special']
}
}
}
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
const complexProp = result.common.find(p => p.name === 'complexField');
expect(complexProp?.showWhen).toBeUndefined();
});
it('should generate usage hints for common property types', () => {
const properties = [
{ name: 'url', type: 'string' },
{ name: 'endpoint', type: 'string' },
{ name: 'authentication', type: 'options' },
{ name: 'jsonData', type: 'json' },
{ name: 'jsCode', type: 'code' },
{ name: 'enableFeature', type: 'boolean', displayOptions: { show: { mode: ['advanced'] } } }
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
const urlProp = result.common.find(p => p.name === 'url');
expect(urlProp?.usageHint).toBe('Enter the full URL including https://');
const authProp = result.common.find(p => p.name === 'authentication');
expect(authProp?.usageHint).toBe('Select authentication method or credentials');
const jsonProp = result.common.find(p => p.name === 'jsonData');
expect(jsonProp?.usageHint).toBe('Enter valid JSON data');
});
it('should extract descriptions from various fields', () => {
const properties = [
{ name: 'field1', description: 'Primary description' },
{ name: 'field2', hint: 'Hint description' },
{ name: 'field3', placeholder: 'Placeholder description' },
{ name: 'field4', displayName: 'Display Name Only' },
{ name: 'url' } // Should generate description
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
expect(result.common[0].description).toBe('Primary description');
expect(result.common[1].description).toBe('Hint description');
expect(result.common[2].description).toBe('Placeholder description');
expect(result.common[3].description).toBe('Display Name Only');
expect(result.common[4].description).toBe('The URL to make the request to');
});
});
describe('searchProperties', () => {
const testProperties = [
{
name: 'url',
displayName: 'URL',
type: 'string',
description: 'The endpoint URL for the request'
},
{
name: 'urlParams',
displayName: 'URL Parameters',
type: 'collection'
},
{
name: 'authentication',
displayName: 'Authentication',
type: 'options',
description: 'Select the authentication method'
},
{
name: 'headers',
type: 'collection',
options: [
{ name: 'Authorization', type: 'string' },
{ name: 'Content-Type', type: 'string' }
]
}
];
it('should find exact name matches with highest score', () => {
const results = PropertyFilter.searchProperties(testProperties, 'url');
expect(results).toHaveLength(2);
expect(results[0].name).toBe('url'); // Exact match
expect(results[1].name).toBe('urlParams'); // Prefix match
});
it('should find properties by partial name match', () => {
const results = PropertyFilter.searchProperties(testProperties, 'auth');
// May match both 'authentication' and 'Authorization' in headers
expect(results.length).toBeGreaterThanOrEqual(1);
expect(results.some(r => r.name === 'authentication')).toBe(true);
});
it('should find properties by description match', () => {
const results = PropertyFilter.searchProperties(testProperties, 'endpoint');
expect(results).toHaveLength(1);
expect(results[0].name).toBe('url');
});
it('should search nested properties in collections', () => {
const results = PropertyFilter.searchProperties(testProperties, 'authorization');
expect(results).toHaveLength(1);
expect(results[0].name).toBe('Authorization');
expect((results[0] as any).path).toBe('headers.Authorization');
});
it('should limit results to maxResults', () => {
const manyProperties = Array.from({ length: 30 }, (_, i) => ({
name: `authField${i}`,
type: 'string'
}));
const results = PropertyFilter.searchProperties(manyProperties, 'auth', 5);
expect(results).toHaveLength(5);
});
it('should handle empty query gracefully', () => {
const results = PropertyFilter.searchProperties(testProperties, '');
expect(results).toHaveLength(0);
});
it('should search in fixedCollection properties', () => {
const properties = [
{
name: 'options',
type: 'fixedCollection',
options: [
{
name: 'advanced',
values: [
{ name: 'timeout', type: 'number' },
{ name: 'retries', type: 'number' }
]
}
]
}
];
const results = PropertyFilter.searchProperties(properties, 'timeout');
expect(results).toHaveLength(1);
expect(results[0].name).toBe('timeout');
expect((results[0] as any).path).toBe('options.advanced.timeout');
});
});
describe('edge cases', () => {
it('should handle empty properties array', () => {
const result = PropertyFilter.getEssentials([], 'nodes-base.httpRequest');
expect(result.required).toHaveLength(0);
expect(result.common).toHaveLength(0);
});
it('should handle properties with missing fields gracefully', () => {
const properties = [
{ name: 'field1' }, // No type
{ type: 'string' }, // No name
{ name: 'field2', type: 'string' } // Valid
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
expect(result.common.length).toBeGreaterThan(0);
expect(result.common.every(p => p.name && p.type)).toBe(true);
});
it('should handle circular references in nested properties', () => {
const circularProp: any = {
name: 'circular',
type: 'collection',
options: []
};
circularProp.options.push(circularProp); // Create circular reference
const properties = [circularProp, { name: 'normal', type: 'string' }];
// Should not throw or hang
expect(() => {
PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
}).not.toThrow();
});
it('should preserve default values for simple types', () => {
const properties = [
{ name: 'method', type: 'options', default: 'GET' },
{ name: 'timeout', type: 'number', default: 30000 },
{ name: 'enabled', type: 'boolean', default: true },
{ name: 'complex', type: 'collection', default: { key: 'value' } } // Should not include
];
const result = PropertyFilter.getEssentials(properties, 'nodes-base.unknownNode');
const method = result.common.find(p => p.name === 'method');
expect(method?.default).toBe('GET');
const timeout = result.common.find(p => p.name === 'timeout');
expect(timeout?.default).toBe(30000);
const enabled = result.common.find(p => p.name === 'enabled');
expect(enabled?.default).toBe(true);
const complex = result.common.find(p => p.name === 'complex');
expect(complex?.default).toBeUndefined();
});
});
});
```