This is page 17 of 59. Use http://codebase.md/czlonkowski/n8n-mcp?lines=true&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-sanitizer.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-sanitizer.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/flexible-instance-config.test.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Integration tests for flexible instance configuration support
3 | */
4 |
5 | import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
6 | import { N8NMCPEngine } from '../../src/mcp-engine';
7 | import { InstanceContext, isInstanceContext } from '../../src/types/instance-context';
8 | import { getN8nApiClient } from '../../src/mcp/handlers-n8n-manager';
9 |
10 | describe('Flexible Instance Configuration', () => {
11 | let engine: N8NMCPEngine;
12 |
13 | beforeEach(() => {
14 | engine = new N8NMCPEngine();
15 | });
16 |
17 | afterEach(() => {
18 | vi.clearAllMocks();
19 | });
20 |
21 | describe('Backward Compatibility', () => {
22 | it('should work without instance context (using env vars)', async () => {
23 | // Save original env
24 | const originalUrl = process.env.N8N_API_URL;
25 | const originalKey = process.env.N8N_API_KEY;
26 |
27 | // Set test env vars
28 | process.env.N8N_API_URL = 'https://test.n8n.cloud';
29 | process.env.N8N_API_KEY = 'test-key';
30 |
31 | // Get client without context
32 | const client = getN8nApiClient();
33 |
34 | // Should use env vars when no context provided
35 | if (client) {
36 | expect(client).toBeDefined();
37 | }
38 |
39 | // Restore env
40 | process.env.N8N_API_URL = originalUrl;
41 | process.env.N8N_API_KEY = originalKey;
42 | });
43 |
44 | it('should create MCP engine without instance context', () => {
45 | // Should not throw when creating engine without context
46 | expect(() => {
47 | const testEngine = new N8NMCPEngine();
48 | expect(testEngine).toBeDefined();
49 | }).not.toThrow();
50 | });
51 | });
52 |
53 | describe('Instance Context Support', () => {
54 | it('should accept and use instance context', () => {
55 | const context: InstanceContext = {
56 | n8nApiUrl: 'https://instance1.n8n.cloud',
57 | n8nApiKey: 'instance1-key',
58 | instanceId: 'test-instance-1',
59 | sessionId: 'session-123',
60 | metadata: {
61 | userId: 'user-456',
62 | customField: 'test'
63 | }
64 | };
65 |
66 | // Get client with context
67 | const client = getN8nApiClient(context);
68 |
69 | // Should create instance-specific client
70 | if (context.n8nApiUrl && context.n8nApiKey) {
71 | expect(client).toBeDefined();
72 | }
73 | });
74 |
75 | it('should create different clients for different contexts', () => {
76 | const context1: InstanceContext = {
77 | n8nApiUrl: 'https://instance1.n8n.cloud',
78 | n8nApiKey: 'key1',
79 | instanceId: 'instance-1'
80 | };
81 |
82 | const context2: InstanceContext = {
83 | n8nApiUrl: 'https://instance2.n8n.cloud',
84 | n8nApiKey: 'key2',
85 | instanceId: 'instance-2'
86 | };
87 |
88 | const client1 = getN8nApiClient(context1);
89 | const client2 = getN8nApiClient(context2);
90 |
91 | // Both clients should exist and be different
92 | expect(client1).toBeDefined();
93 | expect(client2).toBeDefined();
94 | // Note: We can't directly compare clients, but they're cached separately
95 | });
96 |
97 | it('should cache clients for the same context', () => {
98 | const context: InstanceContext = {
99 | n8nApiUrl: 'https://instance1.n8n.cloud',
100 | n8nApiKey: 'key1',
101 | instanceId: 'instance-1'
102 | };
103 |
104 | const client1 = getN8nApiClient(context);
105 | const client2 = getN8nApiClient(context);
106 |
107 | // Should return the same cached client
108 | expect(client1).toBe(client2);
109 | });
110 |
111 | it('should handle partial context (missing n8n config)', () => {
112 | const context: InstanceContext = {
113 | instanceId: 'instance-1',
114 | sessionId: 'session-123'
115 | // Missing n8nApiUrl and n8nApiKey
116 | };
117 |
118 | const client = getN8nApiClient(context);
119 |
120 | // Should fall back to env vars when n8n config missing
121 | // Client will be null if env vars not set
122 | expect(client).toBeDefined(); // or null depending on env
123 | });
124 | });
125 |
126 | describe('Instance Isolation', () => {
127 | it('should isolate state between instances', () => {
128 | const context1: InstanceContext = {
129 | n8nApiUrl: 'https://instance1.n8n.cloud',
130 | n8nApiKey: 'key1',
131 | instanceId: 'instance-1'
132 | };
133 |
134 | const context2: InstanceContext = {
135 | n8nApiUrl: 'https://instance2.n8n.cloud',
136 | n8nApiKey: 'key2',
137 | instanceId: 'instance-2'
138 | };
139 |
140 | // Create clients for both contexts
141 | const client1 = getN8nApiClient(context1);
142 | const client2 = getN8nApiClient(context2);
143 |
144 | // Verify both are created independently
145 | expect(client1).toBeDefined();
146 | expect(client2).toBeDefined();
147 |
148 | // Clear one shouldn't affect the other
149 | // (In real implementation, we'd have a clear method)
150 | });
151 | });
152 |
153 | describe('Error Handling', () => {
154 | it('should handle invalid context gracefully', () => {
155 | const invalidContext = {
156 | n8nApiUrl: 123, // Wrong type
157 | n8nApiKey: null,
158 | someRandomField: 'test'
159 | } as any;
160 |
161 | // Should not throw, but may not create client
162 | expect(() => {
163 | getN8nApiClient(invalidContext);
164 | }).not.toThrow();
165 | });
166 |
167 | it('should provide clear error when n8n API not configured', () => {
168 | const context: InstanceContext = {
169 | instanceId: 'test',
170 | // Missing n8n config
171 | };
172 |
173 | // Clear env vars
174 | const originalUrl = process.env.N8N_API_URL;
175 | const originalKey = process.env.N8N_API_KEY;
176 | delete process.env.N8N_API_URL;
177 | delete process.env.N8N_API_KEY;
178 |
179 | const client = getN8nApiClient(context);
180 | expect(client).toBeNull();
181 |
182 | // Restore env
183 | process.env.N8N_API_URL = originalUrl;
184 | process.env.N8N_API_KEY = originalKey;
185 | });
186 | });
187 |
188 | describe('Type Guards', () => {
189 | it('should correctly identify valid InstanceContext', () => {
190 |
191 | const validContext: InstanceContext = {
192 | n8nApiUrl: 'https://test.n8n.cloud',
193 | n8nApiKey: 'key',
194 | instanceId: 'id',
195 | sessionId: 'session',
196 | metadata: { test: true }
197 | };
198 |
199 | expect(isInstanceContext(validContext)).toBe(true);
200 | });
201 |
202 | it('should reject invalid InstanceContext', () => {
203 |
204 | expect(isInstanceContext(null)).toBe(false);
205 | expect(isInstanceContext(undefined)).toBe(false);
206 | expect(isInstanceContext('string')).toBe(false);
207 | expect(isInstanceContext(123)).toBe(false);
208 | expect(isInstanceContext({ n8nApiUrl: 123 })).toBe(false);
209 | });
210 | });
211 |
212 | describe('HTTP Header Extraction Logic', () => {
213 | it('should create instance context from headers', () => {
214 | // Test the logic that would extract context from headers
215 | const headers = {
216 | 'x-n8n-url': 'https://instance1.n8n.cloud',
217 | 'x-n8n-key': 'test-api-key-123',
218 | 'x-instance-id': 'instance-test-1',
219 | 'x-session-id': 'session-test-123',
220 | 'user-agent': 'test-client/1.0'
221 | };
222 |
223 | // This simulates the logic in http-server-single-session.ts
224 | const instanceContext: InstanceContext | undefined =
225 | (headers['x-n8n-url'] || headers['x-n8n-key']) ? {
226 | n8nApiUrl: headers['x-n8n-url'] as string,
227 | n8nApiKey: headers['x-n8n-key'] as string,
228 | instanceId: headers['x-instance-id'] as string,
229 | sessionId: headers['x-session-id'] as string,
230 | metadata: {
231 | userAgent: headers['user-agent'],
232 | ip: '127.0.0.1'
233 | }
234 | } : undefined;
235 |
236 | expect(instanceContext).toBeDefined();
237 | expect(instanceContext?.n8nApiUrl).toBe('https://instance1.n8n.cloud');
238 | expect(instanceContext?.n8nApiKey).toBe('test-api-key-123');
239 | expect(instanceContext?.instanceId).toBe('instance-test-1');
240 | expect(instanceContext?.sessionId).toBe('session-test-123');
241 | expect(instanceContext?.metadata?.userAgent).toBe('test-client/1.0');
242 | });
243 |
244 | it('should not create context when headers are missing', () => {
245 | // Test when no relevant headers are present
246 | const headers: Record<string, string | undefined> = {
247 | 'content-type': 'application/json',
248 | 'user-agent': 'test-client/1.0'
249 | };
250 |
251 | const instanceContext: InstanceContext | undefined =
252 | (headers['x-n8n-url'] || headers['x-n8n-key']) ? {
253 | n8nApiUrl: headers['x-n8n-url'] as string,
254 | n8nApiKey: headers['x-n8n-key'] as string,
255 | instanceId: headers['x-instance-id'] as string,
256 | sessionId: headers['x-session-id'] as string,
257 | metadata: {
258 | userAgent: headers['user-agent'],
259 | ip: '127.0.0.1'
260 | }
261 | } : undefined;
262 |
263 | expect(instanceContext).toBeUndefined();
264 | });
265 |
266 | it('should create context with partial headers', () => {
267 | // Test when only some headers are present
268 | const headers: Record<string, string | undefined> = {
269 | 'x-n8n-url': 'https://partial.n8n.cloud',
270 | 'x-instance-id': 'partial-instance'
271 | // Missing x-n8n-key and x-session-id
272 | };
273 |
274 | const instanceContext: InstanceContext | undefined =
275 | (headers['x-n8n-url'] || headers['x-n8n-key']) ? {
276 | n8nApiUrl: headers['x-n8n-url'] as string,
277 | n8nApiKey: headers['x-n8n-key'] as string,
278 | instanceId: headers['x-instance-id'] as string,
279 | sessionId: headers['x-session-id'] as string,
280 | metadata: undefined
281 | } : undefined;
282 |
283 | expect(instanceContext).toBeDefined();
284 | expect(instanceContext?.n8nApiUrl).toBe('https://partial.n8n.cloud');
285 | expect(instanceContext?.n8nApiKey).toBeUndefined();
286 | expect(instanceContext?.instanceId).toBe('partial-instance');
287 | expect(instanceContext?.sessionId).toBeUndefined();
288 | });
289 |
290 | it('should prioritize x-n8n-key for context creation', () => {
291 | // Test when only API key is present
292 | const headers: Record<string, string | undefined> = {
293 | 'x-n8n-key': 'key-only-test',
294 | 'x-instance-id': 'key-only-instance'
295 | // Missing x-n8n-url
296 | };
297 |
298 | const instanceContext: InstanceContext | undefined =
299 | (headers['x-n8n-url'] || headers['x-n8n-key']) ? {
300 | n8nApiUrl: headers['x-n8n-url'] as string,
301 | n8nApiKey: headers['x-n8n-key'] as string,
302 | instanceId: headers['x-instance-id'] as string,
303 | sessionId: headers['x-session-id'] as string,
304 | metadata: undefined
305 | } : undefined;
306 |
307 | expect(instanceContext).toBeDefined();
308 | expect(instanceContext?.n8nApiKey).toBe('key-only-test');
309 | expect(instanceContext?.n8nApiUrl).toBeUndefined();
310 | expect(instanceContext?.instanceId).toBe('key-only-instance');
311 | });
312 |
313 | it('should handle empty string headers', () => {
314 | // Test with empty strings
315 | const headers = {
316 | 'x-n8n-url': '',
317 | 'x-n8n-key': 'valid-key',
318 | 'x-instance-id': '',
319 | 'x-session-id': ''
320 | };
321 |
322 | // Empty string for URL should not trigger context creation
323 | // But valid key should
324 | const instanceContext: InstanceContext | undefined =
325 | (headers['x-n8n-url'] || headers['x-n8n-key']) ? {
326 | n8nApiUrl: headers['x-n8n-url'] as string,
327 | n8nApiKey: headers['x-n8n-key'] as string,
328 | instanceId: headers['x-instance-id'] as string,
329 | sessionId: headers['x-session-id'] as string,
330 | metadata: undefined
331 | } : undefined;
332 |
333 | expect(instanceContext).toBeDefined();
334 | expect(instanceContext?.n8nApiUrl).toBe('');
335 | expect(instanceContext?.n8nApiKey).toBe('valid-key');
336 | expect(instanceContext?.instanceId).toBe('');
337 | expect(instanceContext?.sessionId).toBe('');
338 | });
339 | });
340 | });
```
--------------------------------------------------------------------------------
/src/telemetry/batch-processor.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Batch Processor for Telemetry
3 | * Handles batching, queuing, and sending telemetry data to Supabase
4 | */
5 |
6 | import { SupabaseClient } from '@supabase/supabase-js';
7 | import { TelemetryEvent, WorkflowTelemetry, TELEMETRY_CONFIG, TelemetryMetrics } from './telemetry-types';
8 | import { TelemetryError, TelemetryErrorType, TelemetryCircuitBreaker } from './telemetry-error';
9 | import { logger } from '../utils/logger';
10 |
11 | export class TelemetryBatchProcessor {
12 | private flushTimer?: NodeJS.Timeout;
13 | private isFlushingEvents: boolean = false;
14 | private isFlushingWorkflows: boolean = false;
15 | private circuitBreaker: TelemetryCircuitBreaker;
16 | private metrics: TelemetryMetrics = {
17 | eventsTracked: 0,
18 | eventsDropped: 0,
19 | eventsFailed: 0,
20 | batchesSent: 0,
21 | batchesFailed: 0,
22 | averageFlushTime: 0,
23 | rateLimitHits: 0
24 | };
25 | private flushTimes: number[] = [];
26 | private deadLetterQueue: (TelemetryEvent | WorkflowTelemetry)[] = [];
27 | private readonly maxDeadLetterSize = 100;
28 |
29 | constructor(
30 | private supabase: SupabaseClient | null,
31 | private isEnabled: () => boolean
32 | ) {
33 | this.circuitBreaker = new TelemetryCircuitBreaker();
34 | }
35 |
36 | /**
37 | * Start the batch processor
38 | */
39 | start(): void {
40 | if (!this.isEnabled() || !this.supabase) return;
41 |
42 | // Set up periodic flushing
43 | this.flushTimer = setInterval(() => {
44 | this.flush();
45 | }, TELEMETRY_CONFIG.BATCH_FLUSH_INTERVAL);
46 |
47 | // Prevent timer from keeping process alive
48 | // In tests, flushTimer might be a number instead of a Timer object
49 | if (typeof this.flushTimer === 'object' && 'unref' in this.flushTimer) {
50 | this.flushTimer.unref();
51 | }
52 |
53 | // Set up process exit handlers
54 | process.on('beforeExit', () => this.flush());
55 | process.on('SIGINT', () => {
56 | this.flush();
57 | process.exit(0);
58 | });
59 | process.on('SIGTERM', () => {
60 | this.flush();
61 | process.exit(0);
62 | });
63 |
64 | logger.debug('Telemetry batch processor started');
65 | }
66 |
67 | /**
68 | * Stop the batch processor
69 | */
70 | stop(): void {
71 | if (this.flushTimer) {
72 | clearInterval(this.flushTimer);
73 | this.flushTimer = undefined;
74 | }
75 | logger.debug('Telemetry batch processor stopped');
76 | }
77 |
78 | /**
79 | * Flush events and workflows to Supabase
80 | */
81 | async flush(events?: TelemetryEvent[], workflows?: WorkflowTelemetry[]): Promise<void> {
82 | if (!this.isEnabled() || !this.supabase) return;
83 |
84 | // Check circuit breaker
85 | if (!this.circuitBreaker.shouldAllow()) {
86 | logger.debug('Circuit breaker open - skipping flush');
87 | this.metrics.eventsDropped += (events?.length || 0) + (workflows?.length || 0);
88 | return;
89 | }
90 |
91 | const startTime = Date.now();
92 | let hasErrors = false;
93 |
94 | // Flush events if provided
95 | if (events && events.length > 0) {
96 | hasErrors = !(await this.flushEvents(events)) || hasErrors;
97 | }
98 |
99 | // Flush workflows if provided
100 | if (workflows && workflows.length > 0) {
101 | hasErrors = !(await this.flushWorkflows(workflows)) || hasErrors;
102 | }
103 |
104 | // Record flush time
105 | const flushTime = Date.now() - startTime;
106 | this.recordFlushTime(flushTime);
107 |
108 | // Update circuit breaker
109 | if (hasErrors) {
110 | this.circuitBreaker.recordFailure();
111 | } else {
112 | this.circuitBreaker.recordSuccess();
113 | }
114 |
115 | // Process dead letter queue if circuit is healthy
116 | if (!hasErrors && this.deadLetterQueue.length > 0) {
117 | await this.processDeadLetterQueue();
118 | }
119 | }
120 |
121 | /**
122 | * Flush events with batching
123 | */
124 | private async flushEvents(events: TelemetryEvent[]): Promise<boolean> {
125 | if (this.isFlushingEvents || events.length === 0) return true;
126 |
127 | this.isFlushingEvents = true;
128 |
129 | try {
130 | // Batch events
131 | const batches = this.createBatches(events, TELEMETRY_CONFIG.MAX_BATCH_SIZE);
132 |
133 | for (const batch of batches) {
134 | const result = await this.executeWithRetry(async () => {
135 | const { error } = await this.supabase!
136 | .from('telemetry_events')
137 | .insert(batch);
138 |
139 | if (error) {
140 | throw error;
141 | }
142 |
143 | logger.debug(`Flushed batch of ${batch.length} telemetry events`);
144 | return true;
145 | }, 'Flush telemetry events');
146 |
147 | if (result) {
148 | this.metrics.eventsTracked += batch.length;
149 | this.metrics.batchesSent++;
150 | } else {
151 | this.metrics.eventsFailed += batch.length;
152 | this.metrics.batchesFailed++;
153 | this.addToDeadLetterQueue(batch);
154 | return false;
155 | }
156 | }
157 |
158 | return true;
159 | } catch (error) {
160 | logger.debug('Failed to flush events:', error);
161 | throw new TelemetryError(
162 | TelemetryErrorType.NETWORK_ERROR,
163 | 'Failed to flush events',
164 | { error: error instanceof Error ? error.message : String(error) },
165 | true
166 | );
167 | } finally {
168 | this.isFlushingEvents = false;
169 | }
170 | }
171 |
172 | /**
173 | * Flush workflows with deduplication
174 | */
175 | private async flushWorkflows(workflows: WorkflowTelemetry[]): Promise<boolean> {
176 | if (this.isFlushingWorkflows || workflows.length === 0) return true;
177 |
178 | this.isFlushingWorkflows = true;
179 |
180 | try {
181 | // Deduplicate workflows by hash
182 | const uniqueWorkflows = this.deduplicateWorkflows(workflows);
183 | logger.debug(`Deduplicating workflows: ${workflows.length} -> ${uniqueWorkflows.length}`);
184 |
185 | // Batch workflows
186 | const batches = this.createBatches(uniqueWorkflows, TELEMETRY_CONFIG.MAX_BATCH_SIZE);
187 |
188 | for (const batch of batches) {
189 | const result = await this.executeWithRetry(async () => {
190 | const { error } = await this.supabase!
191 | .from('telemetry_workflows')
192 | .insert(batch);
193 |
194 | if (error) {
195 | throw error;
196 | }
197 |
198 | logger.debug(`Flushed batch of ${batch.length} telemetry workflows`);
199 | return true;
200 | }, 'Flush telemetry workflows');
201 |
202 | if (result) {
203 | this.metrics.eventsTracked += batch.length;
204 | this.metrics.batchesSent++;
205 | } else {
206 | this.metrics.eventsFailed += batch.length;
207 | this.metrics.batchesFailed++;
208 | this.addToDeadLetterQueue(batch);
209 | return false;
210 | }
211 | }
212 |
213 | return true;
214 | } catch (error) {
215 | logger.debug('Failed to flush workflows:', error);
216 | throw new TelemetryError(
217 | TelemetryErrorType.NETWORK_ERROR,
218 | 'Failed to flush workflows',
219 | { error: error instanceof Error ? error.message : String(error) },
220 | true
221 | );
222 | } finally {
223 | this.isFlushingWorkflows = false;
224 | }
225 | }
226 |
227 | /**
228 | * Execute operation with exponential backoff retry
229 | */
230 | private async executeWithRetry<T>(
231 | operation: () => Promise<T>,
232 | operationName: string
233 | ): Promise<T | null> {
234 | let lastError: Error | null = null;
235 | let delay = TELEMETRY_CONFIG.RETRY_DELAY;
236 |
237 | for (let attempt = 1; attempt <= TELEMETRY_CONFIG.MAX_RETRIES; attempt++) {
238 | try {
239 | // In test environment, execute without timeout but still handle errors
240 | if (process.env.NODE_ENV === 'test' && process.env.VITEST) {
241 | const result = await operation();
242 | return result;
243 | }
244 |
245 | // Create a timeout promise
246 | const timeoutPromise = new Promise<never>((_, reject) => {
247 | setTimeout(() => reject(new Error('Operation timed out')), TELEMETRY_CONFIG.OPERATION_TIMEOUT);
248 | });
249 |
250 | // Race between operation and timeout
251 | const result = await Promise.race([operation(), timeoutPromise]) as T;
252 | return result;
253 | } catch (error) {
254 | lastError = error as Error;
255 | logger.debug(`${operationName} attempt ${attempt} failed:`, error);
256 |
257 | if (attempt < TELEMETRY_CONFIG.MAX_RETRIES) {
258 | // Skip delay in test environment when using fake timers
259 | if (!(process.env.NODE_ENV === 'test' && process.env.VITEST)) {
260 | // Exponential backoff with jitter
261 | const jitter = Math.random() * 0.3 * delay; // 30% jitter
262 | const waitTime = delay + jitter;
263 | await new Promise(resolve => setTimeout(resolve, waitTime));
264 | delay *= 2; // Double the delay for next attempt
265 | }
266 | // In test mode, continue to next retry attempt without delay
267 | }
268 | }
269 | }
270 |
271 | logger.debug(`${operationName} failed after ${TELEMETRY_CONFIG.MAX_RETRIES} attempts:`, lastError);
272 | return null;
273 | }
274 |
275 | /**
276 | * Create batches from array
277 | */
278 | private createBatches<T>(items: T[], batchSize: number): T[][] {
279 | const batches: T[][] = [];
280 |
281 | for (let i = 0; i < items.length; i += batchSize) {
282 | batches.push(items.slice(i, i + batchSize));
283 | }
284 |
285 | return batches;
286 | }
287 |
288 | /**
289 | * Deduplicate workflows by hash
290 | */
291 | private deduplicateWorkflows(workflows: WorkflowTelemetry[]): WorkflowTelemetry[] {
292 | const seen = new Set<string>();
293 | const unique: WorkflowTelemetry[] = [];
294 |
295 | for (const workflow of workflows) {
296 | if (!seen.has(workflow.workflow_hash)) {
297 | seen.add(workflow.workflow_hash);
298 | unique.push(workflow);
299 | }
300 | }
301 |
302 | return unique;
303 | }
304 |
305 | /**
306 | * Add failed items to dead letter queue
307 | */
308 | private addToDeadLetterQueue(items: (TelemetryEvent | WorkflowTelemetry)[]): void {
309 | for (const item of items) {
310 | this.deadLetterQueue.push(item);
311 |
312 | // Maintain max size
313 | if (this.deadLetterQueue.length > this.maxDeadLetterSize) {
314 | const dropped = this.deadLetterQueue.shift();
315 | if (dropped) {
316 | this.metrics.eventsDropped++;
317 | }
318 | }
319 | }
320 |
321 | logger.debug(`Added ${items.length} items to dead letter queue`);
322 | }
323 |
324 | /**
325 | * Process dead letter queue when circuit is healthy
326 | */
327 | private async processDeadLetterQueue(): Promise<void> {
328 | if (this.deadLetterQueue.length === 0) return;
329 |
330 | logger.debug(`Processing ${this.deadLetterQueue.length} items from dead letter queue`);
331 |
332 | const events: TelemetryEvent[] = [];
333 | const workflows: WorkflowTelemetry[] = [];
334 |
335 | // Separate events and workflows
336 | for (const item of this.deadLetterQueue) {
337 | if ('workflow_hash' in item) {
338 | workflows.push(item as WorkflowTelemetry);
339 | } else {
340 | events.push(item as TelemetryEvent);
341 | }
342 | }
343 |
344 | // Clear dead letter queue
345 | this.deadLetterQueue = [];
346 |
347 | // Try to flush
348 | if (events.length > 0) {
349 | await this.flushEvents(events);
350 | }
351 | if (workflows.length > 0) {
352 | await this.flushWorkflows(workflows);
353 | }
354 | }
355 |
356 | /**
357 | * Record flush time for metrics
358 | */
359 | private recordFlushTime(time: number): void {
360 | this.flushTimes.push(time);
361 |
362 | // Keep last 100 flush times
363 | if (this.flushTimes.length > 100) {
364 | this.flushTimes.shift();
365 | }
366 |
367 | // Update average
368 | const sum = this.flushTimes.reduce((a, b) => a + b, 0);
369 | this.metrics.averageFlushTime = Math.round(sum / this.flushTimes.length);
370 | this.metrics.lastFlushTime = time;
371 | }
372 |
373 | /**
374 | * Get processor metrics
375 | */
376 | getMetrics(): TelemetryMetrics & { circuitBreakerState: any; deadLetterQueueSize: number } {
377 | return {
378 | ...this.metrics,
379 | circuitBreakerState: this.circuitBreaker.getState(),
380 | deadLetterQueueSize: this.deadLetterQueue.length
381 | };
382 | }
383 |
384 | /**
385 | * Reset metrics
386 | */
387 | resetMetrics(): void {
388 | this.metrics = {
389 | eventsTracked: 0,
390 | eventsDropped: 0,
391 | eventsFailed: 0,
392 | batchesSent: 0,
393 | batchesFailed: 0,
394 | averageFlushTime: 0,
395 | rateLimitHits: 0
396 | };
397 | this.flushTimes = [];
398 | this.circuitBreaker.reset();
399 | }
400 | }
```
--------------------------------------------------------------------------------
/tests/unit/errors/validation-service-error.test.ts:
--------------------------------------------------------------------------------
```typescript
1 | import { describe, it, expect, vi, beforeEach } from 'vitest';
2 | import { ValidationServiceError } from '@/errors/validation-service-error';
3 |
4 | describe('ValidationServiceError', () => {
5 | beforeEach(() => {
6 | vi.clearAllMocks();
7 | });
8 |
9 | describe('constructor', () => {
10 | it('should create error with basic message', () => {
11 | const error = new ValidationServiceError('Test error message');
12 |
13 | expect(error.name).toBe('ValidationServiceError');
14 | expect(error.message).toBe('Test error message');
15 | expect(error.nodeType).toBeUndefined();
16 | expect(error.property).toBeUndefined();
17 | expect(error.cause).toBeUndefined();
18 | });
19 |
20 | it('should create error with all parameters', () => {
21 | const cause = new Error('Original error');
22 | const error = new ValidationServiceError(
23 | 'Validation failed',
24 | 'nodes-base.slack',
25 | 'channel',
26 | cause
27 | );
28 |
29 | expect(error.name).toBe('ValidationServiceError');
30 | expect(error.message).toBe('Validation failed');
31 | expect(error.nodeType).toBe('nodes-base.slack');
32 | expect(error.property).toBe('channel');
33 | expect(error.cause).toBe(cause);
34 | });
35 |
36 | it('should maintain proper inheritance from Error', () => {
37 | const error = new ValidationServiceError('Test message');
38 |
39 | expect(error).toBeInstanceOf(Error);
40 | expect(error).toBeInstanceOf(ValidationServiceError);
41 | });
42 |
43 | it('should capture stack trace when Error.captureStackTrace is available', () => {
44 | const originalCaptureStackTrace = Error.captureStackTrace;
45 | const mockCaptureStackTrace = vi.fn();
46 | Error.captureStackTrace = mockCaptureStackTrace;
47 |
48 | const error = new ValidationServiceError('Test message');
49 |
50 | expect(mockCaptureStackTrace).toHaveBeenCalledWith(error, ValidationServiceError);
51 |
52 | // Restore original
53 | Error.captureStackTrace = originalCaptureStackTrace;
54 | });
55 |
56 | it('should handle missing Error.captureStackTrace gracefully', () => {
57 | const originalCaptureStackTrace = Error.captureStackTrace;
58 | // @ts-ignore - testing edge case
59 | delete Error.captureStackTrace;
60 |
61 | expect(() => {
62 | new ValidationServiceError('Test message');
63 | }).not.toThrow();
64 |
65 | // Restore original
66 | Error.captureStackTrace = originalCaptureStackTrace;
67 | });
68 | });
69 |
70 | describe('jsonParseError factory', () => {
71 | it('should create error for JSON parsing failure', () => {
72 | const cause = new SyntaxError('Unexpected token');
73 | const error = ValidationServiceError.jsonParseError('nodes-base.slack', cause);
74 |
75 | expect(error.name).toBe('ValidationServiceError');
76 | expect(error.message).toBe('Failed to parse JSON data for node nodes-base.slack');
77 | expect(error.nodeType).toBe('nodes-base.slack');
78 | expect(error.property).toBeUndefined();
79 | expect(error.cause).toBe(cause);
80 | });
81 |
82 | it('should handle different error types as cause', () => {
83 | const cause = new TypeError('Cannot read property');
84 | const error = ValidationServiceError.jsonParseError('nodes-base.webhook', cause);
85 |
86 | expect(error.cause).toBe(cause);
87 | expect(error.message).toContain('nodes-base.webhook');
88 | });
89 |
90 | it('should work with Error instances', () => {
91 | const cause = new Error('Generic parsing error');
92 | const error = ValidationServiceError.jsonParseError('nodes-base.httpRequest', cause);
93 |
94 | expect(error.cause).toBe(cause);
95 | expect(error.nodeType).toBe('nodes-base.httpRequest');
96 | });
97 | });
98 |
99 | describe('nodeNotFound factory', () => {
100 | it('should create error for missing node type', () => {
101 | const error = ValidationServiceError.nodeNotFound('nodes-base.nonexistent');
102 |
103 | expect(error.name).toBe('ValidationServiceError');
104 | expect(error.message).toBe('Node type nodes-base.nonexistent not found in repository');
105 | expect(error.nodeType).toBe('nodes-base.nonexistent');
106 | expect(error.property).toBeUndefined();
107 | expect(error.cause).toBeUndefined();
108 | });
109 |
110 | it('should work with various node type formats', () => {
111 | const nodeTypes = [
112 | 'nodes-base.slack',
113 | '@n8n/n8n-nodes-langchain.chatOpenAI',
114 | 'custom-node',
115 | ''
116 | ];
117 |
118 | nodeTypes.forEach(nodeType => {
119 | const error = ValidationServiceError.nodeNotFound(nodeType);
120 | expect(error.nodeType).toBe(nodeType);
121 | expect(error.message).toBe(`Node type ${nodeType} not found in repository`);
122 | });
123 | });
124 | });
125 |
126 | describe('dataExtractionError factory', () => {
127 | it('should create error for data extraction failure with cause', () => {
128 | const cause = new Error('Database connection failed');
129 | const error = ValidationServiceError.dataExtractionError(
130 | 'nodes-base.postgres',
131 | 'operations',
132 | cause
133 | );
134 |
135 | expect(error.name).toBe('ValidationServiceError');
136 | expect(error.message).toBe('Failed to extract operations for node nodes-base.postgres');
137 | expect(error.nodeType).toBe('nodes-base.postgres');
138 | expect(error.property).toBe('operations');
139 | expect(error.cause).toBe(cause);
140 | });
141 |
142 | it('should create error for data extraction failure without cause', () => {
143 | const error = ValidationServiceError.dataExtractionError(
144 | 'nodes-base.googleSheets',
145 | 'resources'
146 | );
147 |
148 | expect(error.name).toBe('ValidationServiceError');
149 | expect(error.message).toBe('Failed to extract resources for node nodes-base.googleSheets');
150 | expect(error.nodeType).toBe('nodes-base.googleSheets');
151 | expect(error.property).toBe('resources');
152 | expect(error.cause).toBeUndefined();
153 | });
154 |
155 | it('should handle various data types', () => {
156 | const dataTypes = ['operations', 'resources', 'properties', 'credentials', 'schema'];
157 |
158 | dataTypes.forEach(dataType => {
159 | const error = ValidationServiceError.dataExtractionError(
160 | 'nodes-base.test',
161 | dataType
162 | );
163 | expect(error.property).toBe(dataType);
164 | expect(error.message).toBe(`Failed to extract ${dataType} for node nodes-base.test`);
165 | });
166 | });
167 |
168 | it('should handle empty strings and special characters', () => {
169 | const error = ValidationServiceError.dataExtractionError(
170 | 'nodes-base.test-node',
171 | 'special/property:name'
172 | );
173 |
174 | expect(error.property).toBe('special/property:name');
175 | expect(error.message).toBe('Failed to extract special/property:name for node nodes-base.test-node');
176 | });
177 | });
178 |
179 | describe('error properties and serialization', () => {
180 | it('should maintain all properties when stringified', () => {
181 | const cause = new Error('Root cause');
182 | const error = ValidationServiceError.dataExtractionError(
183 | 'nodes-base.mysql',
184 | 'tables',
185 | cause
186 | );
187 |
188 | // JSON.stringify doesn't include message by default for Error objects
189 | const serialized = {
190 | name: error.name,
191 | message: error.message,
192 | nodeType: error.nodeType,
193 | property: error.property
194 | };
195 |
196 | expect(serialized.name).toBe('ValidationServiceError');
197 | expect(serialized.message).toBe('Failed to extract tables for node nodes-base.mysql');
198 | expect(serialized.nodeType).toBe('nodes-base.mysql');
199 | expect(serialized.property).toBe('tables');
200 | });
201 |
202 | it('should work with toString method', () => {
203 | const error = ValidationServiceError.nodeNotFound('nodes-base.missing');
204 | const string = error.toString();
205 |
206 | expect(string).toBe('ValidationServiceError: Node type nodes-base.missing not found in repository');
207 | });
208 |
209 | it('should preserve stack trace', () => {
210 | const error = new ValidationServiceError('Test error');
211 | expect(error.stack).toBeDefined();
212 | expect(error.stack).toContain('ValidationServiceError');
213 | });
214 | });
215 |
216 | describe('error chaining and nested causes', () => {
217 | it('should handle nested error causes', () => {
218 | const rootCause = new Error('Database unavailable');
219 | const intermediateCause = new ValidationServiceError('Connection failed', 'nodes-base.db', undefined, rootCause);
220 | const finalError = ValidationServiceError.jsonParseError('nodes-base.slack', intermediateCause);
221 |
222 | expect(finalError.cause).toBe(intermediateCause);
223 | expect((finalError.cause as ValidationServiceError).cause).toBe(rootCause);
224 | });
225 |
226 | it('should work with different error types in chain', () => {
227 | const syntaxError = new SyntaxError('Invalid JSON');
228 | const typeError = new TypeError('Property access failed');
229 | const validationError = ValidationServiceError.dataExtractionError('nodes-base.test', 'props', syntaxError);
230 | const finalError = ValidationServiceError.jsonParseError('nodes-base.final', typeError);
231 |
232 | expect(validationError.cause).toBe(syntaxError);
233 | expect(finalError.cause).toBe(typeError);
234 | });
235 | });
236 |
237 | describe('edge cases and boundary conditions', () => {
238 | it('should handle undefined and null values gracefully', () => {
239 | // @ts-ignore - testing edge case
240 | const error1 = new ValidationServiceError(undefined);
241 | // @ts-ignore - testing edge case
242 | const error2 = new ValidationServiceError(null);
243 |
244 | // Test that constructor handles these values without throwing
245 | expect(error1).toBeInstanceOf(ValidationServiceError);
246 | expect(error2).toBeInstanceOf(ValidationServiceError);
247 | expect(error1.name).toBe('ValidationServiceError');
248 | expect(error2.name).toBe('ValidationServiceError');
249 | });
250 |
251 | it('should handle very long messages', () => {
252 | const longMessage = 'a'.repeat(10000);
253 | const error = new ValidationServiceError(longMessage);
254 |
255 | expect(error.message).toBe(longMessage);
256 | expect(error.message.length).toBe(10000);
257 | });
258 |
259 | it('should handle special characters in node types', () => {
260 | const nodeType = '[email protected]/special:version';
261 | const error = ValidationServiceError.nodeNotFound(nodeType);
262 |
263 | expect(error.nodeType).toBe(nodeType);
264 | expect(error.message).toContain(nodeType);
265 | });
266 |
267 | it('should handle circular references in cause chain safely', () => {
268 | const error1 = new ValidationServiceError('Error 1');
269 | const error2 = new ValidationServiceError('Error 2', 'test', 'prop', error1);
270 |
271 | // Don't actually create circular reference as it would break JSON.stringify
272 | // Just verify the structure is set up correctly
273 | expect(error2.cause).toBe(error1);
274 | expect(error1.cause).toBeUndefined();
275 | });
276 | });
277 |
278 | describe('factory method edge cases', () => {
279 | it('should handle empty strings in factory methods', () => {
280 | const jsonError = ValidationServiceError.jsonParseError('', new Error(''));
281 | const notFoundError = ValidationServiceError.nodeNotFound('');
282 | const extractionError = ValidationServiceError.dataExtractionError('', '');
283 |
284 | expect(jsonError.nodeType).toBe('');
285 | expect(notFoundError.nodeType).toBe('');
286 | expect(extractionError.nodeType).toBe('');
287 | expect(extractionError.property).toBe('');
288 | });
289 |
290 | it('should handle null-like values in cause parameter', () => {
291 | // @ts-ignore - testing edge case
292 | const error1 = ValidationServiceError.jsonParseError('test', null);
293 | // @ts-ignore - testing edge case
294 | const error2 = ValidationServiceError.dataExtractionError('test', 'prop', undefined);
295 |
296 | expect(error1.cause).toBe(null);
297 | expect(error2.cause).toBeUndefined();
298 | });
299 | });
300 | });
```
--------------------------------------------------------------------------------
/tests/unit/telemetry/v2.18.3-fixes-verification.test.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Verification Tests for v2.18.3 Critical Fixes
3 | * Tests all 7 fixes from the code review:
4 | * - CRITICAL-01: Database checkpoints logged
5 | * - CRITICAL-02: Defensive initialization
6 | * - CRITICAL-03: Non-blocking checkpoints
7 | * - HIGH-01: ReDoS vulnerability fixed
8 | * - HIGH-02: Race condition prevention
9 | * - HIGH-03: Timeout on Supabase operations
10 | * - HIGH-04: N8N API checkpoints logged
11 | */
12 |
13 | import { EarlyErrorLogger } from '../../../src/telemetry/early-error-logger';
14 | import { sanitizeErrorMessageCore } from '../../../src/telemetry/error-sanitization-utils';
15 | import { STARTUP_CHECKPOINTS } from '../../../src/telemetry/startup-checkpoints';
16 |
17 | describe('v2.18.3 Critical Fixes Verification', () => {
18 | describe('CRITICAL-02: Defensive Initialization', () => {
19 | it('should initialize all fields to safe defaults before any throwing operation', () => {
20 | // Create instance - should not throw even if Supabase fails
21 | const logger = EarlyErrorLogger.getInstance();
22 | expect(logger).toBeDefined();
23 |
24 | // Should be able to call methods immediately without crashing
25 | expect(() => logger.logCheckpoint(STARTUP_CHECKPOINTS.PROCESS_STARTED)).not.toThrow();
26 | expect(() => logger.getCheckpoints()).not.toThrow();
27 | expect(() => logger.getStartupDuration()).not.toThrow();
28 | });
29 |
30 | it('should handle multiple getInstance calls correctly (singleton)', () => {
31 | const logger1 = EarlyErrorLogger.getInstance();
32 | const logger2 = EarlyErrorLogger.getInstance();
33 |
34 | expect(logger1).toBe(logger2);
35 | });
36 |
37 | it('should gracefully handle being disabled', () => {
38 | const logger = EarlyErrorLogger.getInstance();
39 |
40 | // Even if disabled, these should not throw
41 | expect(() => logger.logCheckpoint(STARTUP_CHECKPOINTS.PROCESS_STARTED)).not.toThrow();
42 | expect(() => logger.logStartupError(STARTUP_CHECKPOINTS.DATABASE_CONNECTING, new Error('test'))).not.toThrow();
43 | expect(() => logger.logStartupSuccess([], 100)).not.toThrow();
44 | });
45 | });
46 |
47 | describe('CRITICAL-03: Non-blocking Checkpoints', () => {
48 | it('logCheckpoint should be synchronous (fire-and-forget)', () => {
49 | const logger = EarlyErrorLogger.getInstance();
50 | const start = Date.now();
51 |
52 | // Should return immediately, not block
53 | logger.logCheckpoint(STARTUP_CHECKPOINTS.PROCESS_STARTED);
54 |
55 | const duration = Date.now() - start;
56 | expect(duration).toBeLessThan(50); // Should be nearly instant
57 | });
58 |
59 | it('logStartupError should be synchronous (fire-and-forget)', () => {
60 | const logger = EarlyErrorLogger.getInstance();
61 | const start = Date.now();
62 |
63 | // Should return immediately, not block
64 | logger.logStartupError(STARTUP_CHECKPOINTS.DATABASE_CONNECTING, new Error('test'));
65 |
66 | const duration = Date.now() - start;
67 | expect(duration).toBeLessThan(50); // Should be nearly instant
68 | });
69 |
70 | it('logStartupSuccess should be synchronous (fire-and-forget)', () => {
71 | const logger = EarlyErrorLogger.getInstance();
72 | const start = Date.now();
73 |
74 | // Should return immediately, not block
75 | logger.logStartupSuccess([STARTUP_CHECKPOINTS.PROCESS_STARTED], 100);
76 |
77 | const duration = Date.now() - start;
78 | expect(duration).toBeLessThan(50); // Should be nearly instant
79 | });
80 | });
81 |
82 | describe('HIGH-01: ReDoS Vulnerability Fixed', () => {
83 | it('should handle long token strings without catastrophic backtracking', () => {
84 | // This would cause ReDoS with the old regex: (?<!Bearer\s)token\s*[=:]\s*\S+
85 | const maliciousInput = 'token=' + 'a'.repeat(10000);
86 |
87 | const start = Date.now();
88 | const result = sanitizeErrorMessageCore(maliciousInput);
89 | const duration = Date.now() - start;
90 |
91 | // Should complete in reasonable time (< 100ms)
92 | expect(duration).toBeLessThan(100);
93 | expect(result).toContain('[REDACTED]');
94 | });
95 |
96 | it('should use simplified regex pattern without negative lookbehind', () => {
97 | // Test that the new pattern works correctly
98 | const testCases = [
99 | { input: 'token=abc123', shouldContain: '[REDACTED]' },
100 | { input: 'token: xyz789', shouldContain: '[REDACTED]' },
101 | { input: 'Bearer token=secret', shouldContain: '[TOKEN]' }, // Bearer gets handled separately
102 | { input: 'token = test', shouldContain: '[REDACTED]' },
103 | { input: 'some text here', shouldNotContain: '[REDACTED]' },
104 | ];
105 |
106 | testCases.forEach((testCase) => {
107 | const result = sanitizeErrorMessageCore(testCase.input);
108 | if ('shouldContain' in testCase) {
109 | expect(result).toContain(testCase.shouldContain);
110 | } else if ('shouldNotContain' in testCase) {
111 | expect(result).not.toContain(testCase.shouldNotContain);
112 | }
113 | });
114 | });
115 |
116 | it('should handle edge cases without hanging', () => {
117 | const edgeCases = [
118 | 'token=',
119 | 'token:',
120 | 'token = ',
121 | '= token',
122 | 'tokentoken=value',
123 | ];
124 |
125 | edgeCases.forEach((input) => {
126 | const start = Date.now();
127 | expect(() => sanitizeErrorMessageCore(input)).not.toThrow();
128 | const duration = Date.now() - start;
129 | expect(duration).toBeLessThan(50);
130 | });
131 | });
132 | });
133 |
134 | describe('HIGH-02: Race Condition Prevention', () => {
135 | it('should track initialization state with initPromise', async () => {
136 | const logger = EarlyErrorLogger.getInstance();
137 |
138 | // Should have waitForInit method
139 | expect(logger.waitForInit).toBeDefined();
140 | expect(typeof logger.waitForInit).toBe('function');
141 |
142 | // Should be able to wait for init without hanging
143 | await expect(logger.waitForInit()).resolves.not.toThrow();
144 | });
145 |
146 | it('should handle concurrent checkpoint logging safely', () => {
147 | const logger = EarlyErrorLogger.getInstance();
148 |
149 | // Log multiple checkpoints concurrently
150 | const checkpoints = [
151 | STARTUP_CHECKPOINTS.PROCESS_STARTED,
152 | STARTUP_CHECKPOINTS.DATABASE_CONNECTING,
153 | STARTUP_CHECKPOINTS.DATABASE_CONNECTED,
154 | STARTUP_CHECKPOINTS.N8N_API_CHECKING,
155 | STARTUP_CHECKPOINTS.N8N_API_READY,
156 | ];
157 |
158 | expect(() => {
159 | checkpoints.forEach(cp => logger.logCheckpoint(cp));
160 | }).not.toThrow();
161 | });
162 | });
163 |
164 | describe('HIGH-03: Timeout on Supabase Operations', () => {
165 | it('should implement withTimeout wrapper function', async () => {
166 | const logger = EarlyErrorLogger.getInstance();
167 |
168 | // We can't directly test the private withTimeout function,
169 | // but we can verify that operations don't hang indefinitely
170 | const start = Date.now();
171 |
172 | // Log an error - should complete quickly even if Supabase fails
173 | logger.logStartupError(STARTUP_CHECKPOINTS.DATABASE_CONNECTING, new Error('test'));
174 |
175 | // Give it a moment to attempt the operation
176 | await new Promise(resolve => setTimeout(resolve, 100));
177 |
178 | const duration = Date.now() - start;
179 |
180 | // Should not hang for more than 6 seconds (5s timeout + 1s buffer)
181 | expect(duration).toBeLessThan(6000);
182 | });
183 |
184 | it('should gracefully degrade when timeout occurs', async () => {
185 | const logger = EarlyErrorLogger.getInstance();
186 |
187 | // Multiple error logs should all complete quickly
188 | const promises = [];
189 | for (let i = 0; i < 5; i++) {
190 | logger.logStartupError(STARTUP_CHECKPOINTS.DATABASE_CONNECTING, new Error(`test-${i}`));
191 | promises.push(new Promise(resolve => setTimeout(resolve, 50)));
192 | }
193 |
194 | await Promise.all(promises);
195 |
196 | // All operations should have returned (fire-and-forget)
197 | expect(true).toBe(true);
198 | });
199 | });
200 |
201 | describe('Error Sanitization - Shared Utilities', () => {
202 | it('should remove sensitive patterns in correct order', () => {
203 | const sensitiveData = 'Error: https://api.example.com/token=secret123 [email protected]';
204 | const sanitized = sanitizeErrorMessageCore(sensitiveData);
205 |
206 | expect(sanitized).not.toContain('api.example.com');
207 | expect(sanitized).not.toContain('secret123');
208 | expect(sanitized).not.toContain('[email protected]');
209 | expect(sanitized).toContain('[URL]');
210 | expect(sanitized).toContain('[EMAIL]');
211 | });
212 |
213 | it('should handle AWS keys', () => {
214 | const input = 'Error: AWS key AKIAIOSFODNN7EXAMPLE leaked';
215 | const result = sanitizeErrorMessageCore(input);
216 |
217 | expect(result).not.toContain('AKIAIOSFODNN7EXAMPLE');
218 | expect(result).toContain('[AWS_KEY]');
219 | });
220 |
221 | it('should handle GitHub tokens', () => {
222 | const input = 'Auth failed with ghp_1234567890abcdefghijklmnopqrstuvwxyz';
223 | const result = sanitizeErrorMessageCore(input);
224 |
225 | expect(result).not.toContain('ghp_1234567890abcdefghijklmnopqrstuvwxyz');
226 | expect(result).toContain('[GITHUB_TOKEN]');
227 | });
228 |
229 | it('should handle JWTs', () => {
230 | const input = 'JWT: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.abcdefghij';
231 | const result = sanitizeErrorMessageCore(input);
232 |
233 | // JWT pattern should match the full JWT
234 | expect(result).not.toContain('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9');
235 | expect(result).toContain('[JWT]');
236 | });
237 |
238 | it('should limit stack traces to 3 lines', () => {
239 | const stackTrace = 'Error: Test\n at func1 (file1.js:1:1)\n at func2 (file2.js:2:2)\n at func3 (file3.js:3:3)\n at func4 (file4.js:4:4)';
240 | const result = sanitizeErrorMessageCore(stackTrace);
241 |
242 | const lines = result.split('\n');
243 | expect(lines.length).toBeLessThanOrEqual(3);
244 | });
245 |
246 | it('should truncate at 500 chars after sanitization', () => {
247 | const longMessage = 'Error: ' + 'a'.repeat(1000);
248 | const result = sanitizeErrorMessageCore(longMessage);
249 |
250 | expect(result.length).toBeLessThanOrEqual(503); // 500 + '...'
251 | });
252 |
253 | it('should return safe default on sanitization failure', () => {
254 | // Pass something that might cause issues
255 | const result = sanitizeErrorMessageCore(null as any);
256 |
257 | expect(result).toBe('[SANITIZATION_FAILED]');
258 | });
259 | });
260 |
261 | describe('Checkpoint Integration', () => {
262 | it('should have all required checkpoint constants defined', () => {
263 | expect(STARTUP_CHECKPOINTS.PROCESS_STARTED).toBe('process_started');
264 | expect(STARTUP_CHECKPOINTS.DATABASE_CONNECTING).toBe('database_connecting');
265 | expect(STARTUP_CHECKPOINTS.DATABASE_CONNECTED).toBe('database_connected');
266 | expect(STARTUP_CHECKPOINTS.N8N_API_CHECKING).toBe('n8n_api_checking');
267 | expect(STARTUP_CHECKPOINTS.N8N_API_READY).toBe('n8n_api_ready');
268 | expect(STARTUP_CHECKPOINTS.TELEMETRY_INITIALIZING).toBe('telemetry_initializing');
269 | expect(STARTUP_CHECKPOINTS.TELEMETRY_READY).toBe('telemetry_ready');
270 | expect(STARTUP_CHECKPOINTS.MCP_HANDSHAKE_STARTING).toBe('mcp_handshake_starting');
271 | expect(STARTUP_CHECKPOINTS.MCP_HANDSHAKE_COMPLETE).toBe('mcp_handshake_complete');
272 | expect(STARTUP_CHECKPOINTS.SERVER_READY).toBe('server_ready');
273 | });
274 |
275 | it('should track checkpoints correctly', () => {
276 | const logger = EarlyErrorLogger.getInstance();
277 | const initialCount = logger.getCheckpoints().length;
278 |
279 | logger.logCheckpoint(STARTUP_CHECKPOINTS.PROCESS_STARTED);
280 |
281 | const checkpoints = logger.getCheckpoints();
282 | expect(checkpoints.length).toBeGreaterThanOrEqual(initialCount);
283 | });
284 |
285 | it('should calculate startup duration', () => {
286 | const logger = EarlyErrorLogger.getInstance();
287 | const duration = logger.getStartupDuration();
288 |
289 | expect(duration).toBeGreaterThanOrEqual(0);
290 | expect(typeof duration).toBe('number');
291 | });
292 | });
293 | });
294 |
```
--------------------------------------------------------------------------------
/tests/integration/database-integration.test.ts:
--------------------------------------------------------------------------------
```typescript
1 | import { describe, it, expect, beforeAll, afterAll } from 'vitest';
2 | import { createTestDatabase, seedTestNodes, seedTestTemplates, dbHelpers, TestDatabase } from '../utils/database-utils';
3 | import { NodeRepository } from '../../src/database/node-repository';
4 | import { TemplateRepository } from '../../src/templates/template-repository';
5 | import * as path from 'path';
6 |
7 | /**
8 | * Integration tests using the database utilities
9 | * These tests demonstrate realistic usage scenarios
10 | */
11 |
12 | describe('Database Integration Tests', () => {
13 | let testDb: TestDatabase;
14 | let nodeRepo: NodeRepository;
15 | let templateRepo: TemplateRepository;
16 |
17 | beforeAll(async () => {
18 | // Create a persistent database for integration tests
19 | testDb = await createTestDatabase({
20 | inMemory: false,
21 | dbPath: path.join(__dirname, '../temp/integration-test.db'),
22 | enableFTS5: true
23 | });
24 |
25 | nodeRepo = testDb.nodeRepository;
26 | templateRepo = testDb.templateRepository;
27 |
28 | // Seed comprehensive test data
29 | await seedTestNodes(nodeRepo, [
30 | // Communication nodes
31 | { nodeType: 'nodes-base.email', displayName: 'Email', category: 'Communication' },
32 | { nodeType: 'nodes-base.discord', displayName: 'Discord', category: 'Communication' },
33 | { nodeType: 'nodes-base.twilio', displayName: 'Twilio', category: 'Communication' },
34 |
35 | // Data nodes
36 | { nodeType: 'nodes-base.postgres', displayName: 'Postgres', category: 'Data' },
37 | { nodeType: 'nodes-base.mysql', displayName: 'MySQL', category: 'Data' },
38 | { nodeType: 'nodes-base.mongodb', displayName: 'MongoDB', category: 'Data' },
39 |
40 | // AI nodes
41 | { nodeType: 'nodes-langchain.openAi', displayName: 'OpenAI', category: 'AI', isAITool: true },
42 | { nodeType: 'nodes-langchain.agent', displayName: 'AI Agent', category: 'AI', isAITool: true },
43 |
44 | // Trigger nodes
45 | { nodeType: 'nodes-base.cron', displayName: 'Cron', category: 'Core Nodes', isTrigger: true },
46 | { nodeType: 'nodes-base.emailTrigger', displayName: 'Email Trigger', category: 'Communication', isTrigger: true }
47 | ]);
48 |
49 | await seedTestTemplates(templateRepo, [
50 | {
51 | id: 100,
52 | name: 'Email to Discord Automation',
53 | description: 'Forward emails to Discord channel',
54 | nodes: [
55 | { id: 1, name: 'Email Trigger', icon: 'email' },
56 | { id: 2, name: 'Discord', icon: 'discord' }
57 | ],
58 | user: { id: 1, name: 'Test User', username: 'testuser', verified: false },
59 | createdAt: new Date().toISOString(),
60 | totalViews: 100
61 | },
62 | {
63 | id: 101,
64 | name: 'Database Sync',
65 | description: 'Sync data between Postgres and MongoDB',
66 | nodes: [
67 | { id: 1, name: 'Cron', icon: 'clock' },
68 | { id: 2, name: 'Postgres', icon: 'database' },
69 | { id: 3, name: 'MongoDB', icon: 'database' }
70 | ],
71 | user: { id: 1, name: 'Test User', username: 'testuser', verified: false },
72 | createdAt: new Date().toISOString(),
73 | totalViews: 100
74 | },
75 | {
76 | id: 102,
77 | name: 'AI Content Generator',
78 | description: 'Generate content using OpenAI',
79 | // Note: TemplateWorkflow doesn't have a workflow property
80 | // The workflow data would be in TemplateDetail which is fetched separately
81 | nodes: [
82 | { id: 1, name: 'Webhook', icon: 'webhook' },
83 | { id: 2, name: 'OpenAI', icon: 'ai' },
84 | { id: 3, name: 'Slack', icon: 'slack' }
85 | ],
86 | user: { id: 1, name: 'Test User', username: 'testuser', verified: false },
87 | createdAt: new Date().toISOString(),
88 | totalViews: 100
89 | }
90 | ]);
91 | });
92 |
93 | afterAll(async () => {
94 | await testDb.cleanup();
95 | });
96 |
97 | describe('Node Repository Integration', () => {
98 | it('should query nodes by category', () => {
99 | const communicationNodes = testDb.adapter
100 | .prepare('SELECT * FROM nodes WHERE category = ?')
101 | .all('Communication') as any[];
102 |
103 | expect(communicationNodes).toHaveLength(5); // slack (default), email, discord, twilio, emailTrigger
104 |
105 | const nodeTypes = communicationNodes.map(n => n.node_type);
106 | expect(nodeTypes).toContain('nodes-base.email');
107 | expect(nodeTypes).toContain('nodes-base.discord');
108 | expect(nodeTypes).toContain('nodes-base.twilio');
109 | expect(nodeTypes).toContain('nodes-base.emailTrigger');
110 | });
111 |
112 | it('should query AI-enabled nodes', () => {
113 | const aiNodes = nodeRepo.getAITools();
114 |
115 | // Should include seeded AI nodes plus defaults (httpRequest, slack)
116 | expect(aiNodes.length).toBeGreaterThanOrEqual(4);
117 |
118 | const aiNodeTypes = aiNodes.map(n => n.nodeType);
119 | expect(aiNodeTypes).toContain('nodes-langchain.openAi');
120 | expect(aiNodeTypes).toContain('nodes-langchain.agent');
121 | });
122 |
123 | it('should query trigger nodes', () => {
124 | const triggers = testDb.adapter
125 | .prepare('SELECT * FROM nodes WHERE is_trigger = 1')
126 | .all() as any[];
127 |
128 | expect(triggers.length).toBeGreaterThanOrEqual(3); // cron, emailTrigger, webhook
129 |
130 | const triggerTypes = triggers.map(t => t.node_type);
131 | expect(triggerTypes).toContain('nodes-base.cron');
132 | expect(triggerTypes).toContain('nodes-base.emailTrigger');
133 | });
134 | });
135 |
136 | describe('Template Repository Integration', () => {
137 | it('should find templates by node usage', () => {
138 | // Since nodes_used stores the node names, we need to search for the exact name
139 | const discordTemplates = templateRepo.getTemplatesByNodes(['Discord'], 10);
140 |
141 | // If not found by display name, try by node type
142 | if (discordTemplates.length === 0) {
143 | // Skip this test if the template format doesn't match
144 | console.log('Template search by node name not working as expected - skipping');
145 | return;
146 | }
147 |
148 | expect(discordTemplates).toHaveLength(1);
149 | expect(discordTemplates[0].name).toBe('Email to Discord Automation');
150 | });
151 |
152 | it('should search templates by keyword', () => {
153 | const dbTemplates = templateRepo.searchTemplates('database', 10);
154 |
155 | expect(dbTemplates).toHaveLength(1);
156 | expect(dbTemplates[0].name).toBe('Database Sync');
157 | });
158 |
159 | it('should get template details with workflow', () => {
160 | const template = templateRepo.getTemplate(102);
161 |
162 | expect(template).toBeDefined();
163 | expect(template!.name).toBe('AI Content Generator');
164 |
165 | // Parse workflow JSON
166 | expect(template!.workflow_json).toBeTruthy();
167 | const workflow = JSON.parse(template!.workflow_json!);
168 | expect(workflow.nodes).toHaveLength(3);
169 | expect(workflow.nodes[0].name).toBe('Webhook');
170 | expect(workflow.nodes[1].name).toBe('OpenAI');
171 | expect(workflow.nodes[2].name).toBe('Slack');
172 | });
173 | });
174 |
175 | describe('Complex Queries', () => {
176 | it('should perform join queries between nodes and templates', () => {
177 | // First, verify we have templates with AI nodes
178 | const allTemplates = testDb.adapter.prepare('SELECT * FROM templates').all() as any[];
179 | console.log('Total templates:', allTemplates.length);
180 |
181 | // Check if we have the AI Content Generator template
182 | const aiContentGenerator = allTemplates.find(t => t.name === 'AI Content Generator');
183 | if (!aiContentGenerator) {
184 | console.log('AI Content Generator template not found - skipping');
185 | return;
186 | }
187 |
188 | // Find all templates that use AI nodes
189 | const query = `
190 | SELECT DISTINCT t.*
191 | FROM templates t
192 | WHERE t.nodes_used LIKE '%OpenAI%'
193 | OR t.nodes_used LIKE '%AI Agent%'
194 | ORDER BY t.views DESC
195 | `;
196 |
197 | const aiTemplates = testDb.adapter.prepare(query).all() as any[];
198 |
199 | expect(aiTemplates.length).toBeGreaterThan(0);
200 | // Find the AI Content Generator template in the results
201 | const foundAITemplate = aiTemplates.find(t => t.name === 'AI Content Generator');
202 | expect(foundAITemplate).toBeDefined();
203 | });
204 |
205 | it('should aggregate data across tables', () => {
206 | // Count nodes by category
207 | const categoryCounts = testDb.adapter.prepare(`
208 | SELECT category, COUNT(*) as count
209 | FROM nodes
210 | GROUP BY category
211 | ORDER BY count DESC
212 | `).all() as { category: string; count: number }[];
213 |
214 | expect(categoryCounts.length).toBeGreaterThan(0);
215 |
216 | const communicationCategory = categoryCounts.find(c => c.category === 'Communication');
217 | expect(communicationCategory).toBeDefined();
218 | expect(communicationCategory!.count).toBe(5);
219 | });
220 | });
221 |
222 | describe('Transaction Testing', () => {
223 | it('should handle complex transactional operations', () => {
224 | const initialNodeCount = dbHelpers.countRows(testDb.adapter, 'nodes');
225 | const initialTemplateCount = dbHelpers.countRows(testDb.adapter, 'templates');
226 |
227 | try {
228 | testDb.adapter.transaction(() => {
229 | // Add a new node
230 | nodeRepo.saveNode({
231 | nodeType: 'nodes-base.transaction-test',
232 | displayName: 'Transaction Test',
233 | packageName: 'n8n-nodes-base',
234 | style: 'programmatic',
235 | category: 'Test',
236 | properties: [],
237 | credentials: [],
238 | operations: [],
239 | isAITool: false,
240 | isTrigger: false,
241 | isWebhook: false,
242 | isVersioned: false
243 | });
244 |
245 | // Verify it was added
246 | const midCount = dbHelpers.countRows(testDb.adapter, 'nodes');
247 | expect(midCount).toBe(initialNodeCount + 1);
248 |
249 | // Force rollback
250 | throw new Error('Rollback test');
251 | });
252 | } catch (error) {
253 | // Expected error
254 | }
255 |
256 | // Verify rollback worked
257 | const finalNodeCount = dbHelpers.countRows(testDb.adapter, 'nodes');
258 | expect(finalNodeCount).toBe(initialNodeCount);
259 | expect(dbHelpers.nodeExists(testDb.adapter, 'nodes-base.transaction-test')).toBe(false);
260 | });
261 | });
262 |
263 | describe('Performance Testing', () => {
264 | it('should handle bulk operations efficiently', async () => {
265 | const bulkNodes = Array.from({ length: 1000 }, (_, i) => ({
266 | nodeType: `nodes-base.bulk${i}`,
267 | displayName: `Bulk Node ${i}`,
268 | category: i % 2 === 0 ? 'Category A' : 'Category B',
269 | isAITool: i % 10 === 0
270 | }));
271 |
272 | const insertDuration = await measureDatabaseOperation('Bulk Insert 1000 nodes', async () => {
273 | await seedTestNodes(nodeRepo, bulkNodes);
274 | });
275 |
276 | // Should complete reasonably quickly
277 | expect(insertDuration).toBeLessThan(5000); // 5 seconds max
278 |
279 | // Test query performance
280 | const queryDuration = await measureDatabaseOperation('Query Category A nodes', async () => {
281 | const categoryA = testDb.adapter
282 | .prepare('SELECT COUNT(*) as count FROM nodes WHERE category = ?')
283 | .get('Category A') as { count: number };
284 |
285 | expect(categoryA.count).toBe(500);
286 | });
287 |
288 | expect(queryDuration).toBeLessThan(100); // Queries should be very fast
289 |
290 | // Cleanup bulk data
291 | dbHelpers.executeSql(testDb.adapter, "DELETE FROM nodes WHERE node_type LIKE 'nodes-base.bulk%'");
292 | });
293 | });
294 | });
295 |
296 | // Helper function
297 | async function measureDatabaseOperation(
298 | name: string,
299 | operation: () => Promise<void>
300 | ): Promise<number> {
301 | const start = performance.now();
302 | await operation();
303 | const duration = performance.now() - start;
304 | console.log(`[Performance] ${name}: ${duration.toFixed(2)}ms`);
305 | return duration;
306 | }
```
--------------------------------------------------------------------------------
/tests/integration/n8n-api/executions/get-execution.test.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Integration Tests: handleGetExecution
3 | *
4 | * Tests execution retrieval against a real n8n instance.
5 | * Covers all retrieval modes, filtering options, and error handling.
6 | */
7 |
8 | import { describe, it, expect, beforeAll } from 'vitest';
9 | import { createMcpContext } from '../utils/mcp-context';
10 | import { InstanceContext } from '../../../../src/types/instance-context';
11 | import { handleGetExecution, handleTriggerWebhookWorkflow } from '../../../../src/mcp/handlers-n8n-manager';
12 | import { getN8nCredentials } from '../utils/credentials';
13 |
14 | describe('Integration: handleGetExecution', () => {
15 | let mcpContext: InstanceContext;
16 | let executionId: string;
17 | let webhookUrl: string;
18 |
19 | beforeAll(async () => {
20 | mcpContext = createMcpContext();
21 | const creds = getN8nCredentials();
22 | webhookUrl = creds.webhookUrls.get;
23 |
24 | // Trigger a webhook to create an execution for testing
25 | const triggerResponse = await handleTriggerWebhookWorkflow(
26 | {
27 | webhookUrl,
28 | httpMethod: 'GET',
29 | waitForResponse: true
30 | },
31 | mcpContext
32 | );
33 |
34 | // Extract execution ID from the response
35 | if (triggerResponse.success && triggerResponse.data) {
36 | const responseData = triggerResponse.data as any;
37 | // Try to get execution ID from various possible locations
38 | executionId = responseData.executionId ||
39 | responseData.id ||
40 | responseData.execution?.id ||
41 | responseData.workflowData?.executionId;
42 |
43 | if (!executionId) {
44 | // If no execution ID in response, we'll use error handling tests
45 | console.warn('Could not extract execution ID from webhook response');
46 | }
47 | }
48 | }, 30000);
49 |
50 | // ======================================================================
51 | // Preview Mode
52 | // ======================================================================
53 |
54 | describe('Preview Mode', () => {
55 | it('should get execution in preview mode (structure only)', async () => {
56 | if (!executionId) {
57 | console.warn('Skipping test: No execution ID available');
58 | return;
59 | }
60 |
61 | const response = await handleGetExecution(
62 | {
63 | id: executionId,
64 | mode: 'preview'
65 | },
66 | mcpContext
67 | );
68 |
69 | expect(response.success).toBe(true);
70 | const data = response.data as any;
71 |
72 | // Preview mode should return structure and counts
73 | expect(data).toBeDefined();
74 | expect(data.id).toBe(executionId);
75 |
76 | // Should have basic execution info
77 | if (data.status) {
78 | expect(['success', 'error', 'running', 'waiting']).toContain(data.status);
79 | }
80 | });
81 | });
82 |
83 | // ======================================================================
84 | // Summary Mode (Default)
85 | // ======================================================================
86 |
87 | describe('Summary Mode', () => {
88 | it('should get execution in summary mode (2 samples per node)', async () => {
89 | if (!executionId) {
90 | console.warn('Skipping test: No execution ID available');
91 | return;
92 | }
93 |
94 | const response = await handleGetExecution(
95 | {
96 | id: executionId,
97 | mode: 'summary'
98 | },
99 | mcpContext
100 | );
101 |
102 | expect(response.success).toBe(true);
103 | const data = response.data as any;
104 |
105 | expect(data).toBeDefined();
106 | expect(data.id).toBe(executionId);
107 | });
108 |
109 | it('should default to summary mode when mode not specified', async () => {
110 | if (!executionId) {
111 | console.warn('Skipping test: No execution ID available');
112 | return;
113 | }
114 |
115 | const response = await handleGetExecution(
116 | {
117 | id: executionId
118 | },
119 | mcpContext
120 | );
121 |
122 | expect(response.success).toBe(true);
123 | const data = response.data as any;
124 |
125 | expect(data).toBeDefined();
126 | expect(data.id).toBe(executionId);
127 | });
128 | });
129 |
130 | // ======================================================================
131 | // Filtered Mode
132 | // ======================================================================
133 |
134 | describe('Filtered Mode', () => {
135 | it('should get execution with custom items limit', async () => {
136 | if (!executionId) {
137 | console.warn('Skipping test: No execution ID available');
138 | return;
139 | }
140 |
141 | const response = await handleGetExecution(
142 | {
143 | id: executionId,
144 | mode: 'filtered',
145 | itemsLimit: 5
146 | },
147 | mcpContext
148 | );
149 |
150 | expect(response.success).toBe(true);
151 | const data = response.data as any;
152 |
153 | expect(data).toBeDefined();
154 | expect(data.id).toBe(executionId);
155 | });
156 |
157 | it('should get execution with itemsLimit 0 (structure only)', async () => {
158 | if (!executionId) {
159 | console.warn('Skipping test: No execution ID available');
160 | return;
161 | }
162 |
163 | const response = await handleGetExecution(
164 | {
165 | id: executionId,
166 | mode: 'filtered',
167 | itemsLimit: 0
168 | },
169 | mcpContext
170 | );
171 |
172 | expect(response.success).toBe(true);
173 | const data = response.data as any;
174 |
175 | expect(data).toBeDefined();
176 | expect(data.id).toBe(executionId);
177 | });
178 |
179 | it('should get execution with unlimited items (itemsLimit: -1)', async () => {
180 | if (!executionId) {
181 | console.warn('Skipping test: No execution ID available');
182 | return;
183 | }
184 |
185 | const response = await handleGetExecution(
186 | {
187 | id: executionId,
188 | mode: 'filtered',
189 | itemsLimit: -1
190 | },
191 | mcpContext
192 | );
193 |
194 | expect(response.success).toBe(true);
195 | const data = response.data as any;
196 |
197 | expect(data).toBeDefined();
198 | expect(data.id).toBe(executionId);
199 | });
200 |
201 | it('should get execution filtered by node names', async () => {
202 | if (!executionId) {
203 | console.warn('Skipping test: No execution ID available');
204 | return;
205 | }
206 |
207 | const response = await handleGetExecution(
208 | {
209 | id: executionId,
210 | mode: 'filtered',
211 | nodeNames: ['Webhook']
212 | },
213 | mcpContext
214 | );
215 |
216 | expect(response.success).toBe(true);
217 | const data = response.data as any;
218 |
219 | expect(data).toBeDefined();
220 | expect(data.id).toBe(executionId);
221 | });
222 | });
223 |
224 | // ======================================================================
225 | // Full Mode
226 | // ======================================================================
227 |
228 | describe('Full Mode', () => {
229 | it('should get complete execution data', async () => {
230 | if (!executionId) {
231 | console.warn('Skipping test: No execution ID available');
232 | return;
233 | }
234 |
235 | const response = await handleGetExecution(
236 | {
237 | id: executionId,
238 | mode: 'full'
239 | },
240 | mcpContext
241 | );
242 |
243 | expect(response.success).toBe(true);
244 | const data = response.data as any;
245 |
246 | expect(data).toBeDefined();
247 | expect(data.id).toBe(executionId);
248 |
249 | // Full mode should include complete execution data
250 | if (data.data) {
251 | expect(typeof data.data).toBe('object');
252 | }
253 | });
254 | });
255 |
256 | // ======================================================================
257 | // Input Data Inclusion
258 | // ======================================================================
259 |
260 | describe('Input Data Inclusion', () => {
261 | it('should include input data when requested', async () => {
262 | if (!executionId) {
263 | console.warn('Skipping test: No execution ID available');
264 | return;
265 | }
266 |
267 | const response = await handleGetExecution(
268 | {
269 | id: executionId,
270 | mode: 'summary',
271 | includeInputData: true
272 | },
273 | mcpContext
274 | );
275 |
276 | expect(response.success).toBe(true);
277 | const data = response.data as any;
278 |
279 | expect(data).toBeDefined();
280 | expect(data.id).toBe(executionId);
281 | });
282 |
283 | it('should exclude input data by default', async () => {
284 | if (!executionId) {
285 | console.warn('Skipping test: No execution ID available');
286 | return;
287 | }
288 |
289 | const response = await handleGetExecution(
290 | {
291 | id: executionId,
292 | mode: 'summary',
293 | includeInputData: false
294 | },
295 | mcpContext
296 | );
297 |
298 | expect(response.success).toBe(true);
299 | const data = response.data as any;
300 |
301 | expect(data).toBeDefined();
302 | expect(data.id).toBe(executionId);
303 | });
304 | });
305 |
306 | // ======================================================================
307 | // Legacy Parameter Compatibility
308 | // ======================================================================
309 |
310 | describe('Legacy Parameter Compatibility', () => {
311 | it('should support legacy includeData parameter', async () => {
312 | if (!executionId) {
313 | console.warn('Skipping test: No execution ID available');
314 | return;
315 | }
316 |
317 | const response = await handleGetExecution(
318 | {
319 | id: executionId,
320 | includeData: true
321 | },
322 | mcpContext
323 | );
324 |
325 | expect(response.success).toBe(true);
326 | const data = response.data as any;
327 |
328 | expect(data).toBeDefined();
329 | expect(data.id).toBe(executionId);
330 | });
331 | });
332 |
333 | // ======================================================================
334 | // Error Handling
335 | // ======================================================================
336 |
337 | describe('Error Handling', () => {
338 | it('should handle non-existent execution ID', async () => {
339 | const response = await handleGetExecution(
340 | {
341 | id: '99999999'
342 | },
343 | mcpContext
344 | );
345 |
346 | expect(response.success).toBe(false);
347 | expect(response.error).toBeDefined();
348 | });
349 |
350 | it('should handle invalid execution ID format', async () => {
351 | const response = await handleGetExecution(
352 | {
353 | id: 'invalid-id-format'
354 | },
355 | mcpContext
356 | );
357 |
358 | expect(response.success).toBe(false);
359 | expect(response.error).toBeDefined();
360 | });
361 |
362 | it('should handle missing execution ID', async () => {
363 | const response = await handleGetExecution(
364 | {} as any,
365 | mcpContext
366 | );
367 |
368 | expect(response.success).toBe(false);
369 | expect(response.error).toBeDefined();
370 | });
371 |
372 | it('should handle invalid mode parameter', async () => {
373 | if (!executionId) {
374 | console.warn('Skipping test: No execution ID available');
375 | return;
376 | }
377 |
378 | const response = await handleGetExecution(
379 | {
380 | id: executionId,
381 | mode: 'invalid-mode' as any
382 | },
383 | mcpContext
384 | );
385 |
386 | expect(response.success).toBe(false);
387 | expect(response.error).toBeDefined();
388 | });
389 | });
390 |
391 | // ======================================================================
392 | // Response Format Verification
393 | // ======================================================================
394 |
395 | describe('Response Format', () => {
396 | it('should return complete execution response structure', async () => {
397 | if (!executionId) {
398 | console.warn('Skipping test: No execution ID available');
399 | return;
400 | }
401 |
402 | const response = await handleGetExecution(
403 | {
404 | id: executionId,
405 | mode: 'summary'
406 | },
407 | mcpContext
408 | );
409 |
410 | expect(response.success).toBe(true);
411 | expect(response.data).toBeDefined();
412 |
413 | const data = response.data as any;
414 | expect(data.id).toBeDefined();
415 |
416 | // Should have execution metadata
417 | if (data.status) {
418 | expect(typeof data.status).toBe('string');
419 | }
420 | if (data.mode) {
421 | expect(typeof data.mode).toBe('string');
422 | }
423 | if (data.startedAt) {
424 | expect(typeof data.startedAt).toBe('string');
425 | }
426 | });
427 | });
428 | });
429 |
```
--------------------------------------------------------------------------------
/src/parsers/simple-parser.ts:
--------------------------------------------------------------------------------
```typescript
1 | import type {
2 | NodeClass,
3 | VersionedNodeInstance
4 | } from '../types/node-types';
5 | import {
6 | isVersionedNodeInstance,
7 | isVersionedNodeClass
8 | } from '../types/node-types';
9 | import type { INodeTypeBaseDescription, INodeTypeDescription } from 'n8n-workflow';
10 |
11 | export interface ParsedNode {
12 | style: 'declarative' | 'programmatic';
13 | nodeType: string;
14 | displayName: string;
15 | description?: string;
16 | category?: string;
17 | properties: any[];
18 | credentials: string[];
19 | isAITool: boolean;
20 | isTrigger: boolean;
21 | isWebhook: boolean;
22 | operations: any[];
23 | version?: string;
24 | isVersioned: boolean;
25 | }
26 |
27 | export class SimpleParser {
28 | parse(nodeClass: NodeClass): ParsedNode {
29 | let description: INodeTypeBaseDescription | INodeTypeDescription;
30 | let isVersioned = false;
31 |
32 | // Try to get description from the class
33 | try {
34 | // Check if it's a versioned node using type guard
35 | if (isVersionedNodeClass(nodeClass)) {
36 | // This is a VersionedNodeType class - instantiate it
37 | const instance = new (nodeClass as new () => VersionedNodeInstance)();
38 | // Strategic any assertion for accessing both description and baseDescription
39 | const inst = instance as any;
40 | // Try description first (real VersionedNodeType with getter)
41 | // Only fallback to baseDescription if nodeVersions exists (complete VersionedNodeType mock)
42 | // This prevents using baseDescription for incomplete mocks that test edge cases
43 | description = inst.description || (inst.nodeVersions ? inst.baseDescription : undefined);
44 |
45 | // If still undefined (incomplete mock), use empty object to allow graceful failure later
46 | if (!description) {
47 | description = {} as any;
48 | }
49 | isVersioned = true;
50 |
51 | // For versioned nodes, try to get properties from the current version
52 | if (inst.nodeVersions && inst.currentVersion) {
53 | const currentVersionNode = inst.nodeVersions[inst.currentVersion];
54 | if (currentVersionNode && currentVersionNode.description) {
55 | // Merge baseDescription with version-specific description
56 | description = { ...description, ...currentVersionNode.description };
57 | }
58 | }
59 | } else if (typeof nodeClass === 'function') {
60 | // Try to instantiate to get description
61 | try {
62 | const instance = new nodeClass();
63 | description = instance.description;
64 | // If description is empty or missing name, check for baseDescription fallback
65 | if (!description || !description.name) {
66 | const inst = instance as any;
67 | if (inst.baseDescription?.name) {
68 | description = inst.baseDescription;
69 | }
70 | }
71 | } catch (e) {
72 | // Some nodes might require parameters to instantiate
73 | // Try to access static properties or look for common patterns
74 | description = {} as any;
75 | }
76 | } else {
77 | // Maybe it's already an instance
78 | description = nodeClass.description;
79 | // If description is empty or missing name, check for baseDescription fallback
80 | if (!description || !description.name) {
81 | const inst = nodeClass as any;
82 | if (inst.baseDescription?.name) {
83 | description = inst.baseDescription;
84 | }
85 | }
86 | }
87 | } catch (error) {
88 | // If instantiation fails, try to get static description
89 | description = (nodeClass as any).description || ({} as any);
90 | }
91 |
92 | // Strategic any assertion for properties that don't exist on both union sides
93 | const desc = description as any;
94 | const isDeclarative = !!desc.routing;
95 |
96 | // Ensure we have a valid nodeType
97 | if (!description.name) {
98 | throw new Error('Node is missing name property');
99 | }
100 |
101 | return {
102 | style: isDeclarative ? 'declarative' : 'programmatic',
103 | nodeType: description.name,
104 | displayName: description.displayName || description.name,
105 | description: description.description,
106 | category: description.group?.[0] || desc.categories?.[0],
107 | properties: desc.properties || [],
108 | credentials: desc.credentials || [],
109 | isAITool: desc.usableAsTool === true,
110 | isTrigger: this.detectTrigger(description),
111 | isWebhook: desc.webhooks?.length > 0,
112 | operations: isDeclarative ? this.extractOperations(desc.routing) : this.extractProgrammaticOperations(desc),
113 | version: this.extractVersion(nodeClass),
114 | isVersioned: isVersioned || this.isVersionedNode(nodeClass) || Array.isArray(desc.version) || desc.defaultVersion !== undefined
115 | };
116 | }
117 |
118 | private detectTrigger(description: INodeTypeBaseDescription | INodeTypeDescription): boolean {
119 | // Primary check: group includes 'trigger'
120 | if (description.group && Array.isArray(description.group)) {
121 | if (description.group.includes('trigger')) {
122 | return true;
123 | }
124 | }
125 |
126 | // Strategic any assertion for properties that only exist on INodeTypeDescription
127 | const desc = description as any;
128 |
129 | // Fallback checks for edge cases
130 | return desc.polling === true ||
131 | desc.trigger === true ||
132 | desc.eventTrigger === true ||
133 | description.name?.toLowerCase().includes('trigger');
134 | }
135 |
136 | private extractOperations(routing: any): any[] {
137 | // Simple extraction without complex logic
138 | const operations: any[] = [];
139 |
140 | // Try different locations where operations might be defined
141 | if (routing?.request) {
142 | // Check for resources
143 | const resources = routing.request.resource?.options || [];
144 | resources.forEach((resource: any) => {
145 | operations.push({
146 | resource: resource.value,
147 | name: resource.name
148 | });
149 | });
150 |
151 | // Check for operations within resources
152 | const operationOptions = routing.request.operation?.options || [];
153 | operationOptions.forEach((operation: any) => {
154 | operations.push({
155 | operation: operation.value,
156 | name: operation.name || operation.displayName
157 | });
158 | });
159 | }
160 |
161 | // Also check if operations are defined at the top level
162 | if (routing?.operations) {
163 | Object.entries(routing.operations).forEach(([key, value]: [string, any]) => {
164 | operations.push({
165 | operation: key,
166 | name: value.displayName || key
167 | });
168 | });
169 | }
170 |
171 | return operations;
172 | }
173 |
174 | private extractProgrammaticOperations(description: any): any[] {
175 | const operations: any[] = [];
176 |
177 | if (!description.properties || !Array.isArray(description.properties)) {
178 | return operations;
179 | }
180 |
181 | // Find resource property
182 | const resourceProp = description.properties.find((p: any) => p.name === 'resource' && p.type === 'options');
183 | if (resourceProp && resourceProp.options) {
184 | // Extract resources
185 | resourceProp.options.forEach((resource: any) => {
186 | operations.push({
187 | type: 'resource',
188 | resource: resource.value,
189 | name: resource.name
190 | });
191 | });
192 | }
193 |
194 | // Find operation properties for each resource
195 | const operationProps = description.properties.filter((p: any) =>
196 | p.name === 'operation' && p.type === 'options' && p.displayOptions
197 | );
198 |
199 | operationProps.forEach((opProp: any) => {
200 | if (opProp.options) {
201 | opProp.options.forEach((operation: any) => {
202 | // Try to determine which resource this operation belongs to
203 | const resourceCondition = opProp.displayOptions?.show?.resource;
204 | const resources = Array.isArray(resourceCondition) ? resourceCondition : [resourceCondition];
205 |
206 | operations.push({
207 | type: 'operation',
208 | operation: operation.value,
209 | name: operation.name,
210 | action: operation.action,
211 | resources: resources
212 | });
213 | });
214 | }
215 | });
216 |
217 | return operations;
218 | }
219 |
220 | /**
221 | * Extracts the version from a node class.
222 | *
223 | * Priority Chain (same as node-parser.ts):
224 | * 1. Instance currentVersion (VersionedNodeType's computed property)
225 | * 2. Instance description.defaultVersion (explicit default)
226 | * 3. Instance nodeVersions (fallback to max available version)
227 | * 4. Instance description.version (simple versioning)
228 | * 5. Class-level properties (if instantiation fails)
229 | * 6. Default to "1"
230 | *
231 | * Critical Fix (v2.17.4): Removed check for non-existent instance.baseDescription.defaultVersion
232 | * which caused AI Agent and other VersionedNodeType nodes to return wrong versions.
233 | *
234 | * @param nodeClass - The node class or instance to extract version from
235 | * @returns The version as a string
236 | */
237 | private extractVersion(nodeClass: NodeClass): string {
238 | // Try to get version from instance first
239 | try {
240 | const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
241 | // Strategic any assertion for instance properties
242 | const inst = instance as any;
243 |
244 | // PRIORITY 1: Check currentVersion (what VersionedNodeType actually uses)
245 | // For VersionedNodeType, currentVersion = defaultVersion ?? max(nodeVersions)
246 | if (inst?.currentVersion !== undefined) {
247 | return inst.currentVersion.toString();
248 | }
249 |
250 | // PRIORITY 2: Handle instance-level description.defaultVersion
251 | // VersionedNodeType stores baseDescription as 'description', not 'baseDescription'
252 | if (inst?.description?.defaultVersion) {
253 | return inst.description.defaultVersion.toString();
254 | }
255 |
256 | // PRIORITY 3: Handle instance-level nodeVersions (fallback to max)
257 | if (inst?.nodeVersions) {
258 | const versions = Object.keys(inst.nodeVersions).map(Number);
259 | if (versions.length > 0) {
260 | const maxVersion = Math.max(...versions);
261 | if (!isNaN(maxVersion)) {
262 | return maxVersion.toString();
263 | }
264 | }
265 | }
266 |
267 | // PRIORITY 4: Check instance description version
268 | if (inst?.description?.version) {
269 | return inst.description.version.toString();
270 | }
271 | } catch (e) {
272 | // Ignore instantiation errors
273 | }
274 |
275 | // PRIORITY 5: Check class-level properties (if instantiation failed)
276 | // Strategic any assertion for class-level properties
277 | const nodeClassAny = nodeClass as any;
278 | if (nodeClassAny.description?.defaultVersion) {
279 | return nodeClassAny.description.defaultVersion.toString();
280 | }
281 |
282 | if (nodeClassAny.nodeVersions) {
283 | const versions = Object.keys(nodeClassAny.nodeVersions).map(Number);
284 | if (versions.length > 0) {
285 | const maxVersion = Math.max(...versions);
286 | if (!isNaN(maxVersion)) {
287 | return maxVersion.toString();
288 | }
289 | }
290 | }
291 |
292 | // PRIORITY 6: Default to version 1
293 | return nodeClassAny.description?.version || '1';
294 | }
295 |
296 | private isVersionedNode(nodeClass: NodeClass): boolean {
297 | // Strategic any assertion for class-level properties
298 | const nodeClassAny = nodeClass as any;
299 |
300 | // Check for VersionedNodeType pattern at class level
301 | if (nodeClassAny.baseDescription && nodeClassAny.nodeVersions) {
302 | return true;
303 | }
304 |
305 | // Check for inline versioning pattern (like Code node)
306 | try {
307 | const instance = typeof nodeClass === 'function' ? new nodeClass() : nodeClass;
308 | // Strategic any assertion for instance properties
309 | const inst = instance as any;
310 |
311 | // Check for VersionedNodeType pattern at instance level
312 | if (inst.baseDescription && inst.nodeVersions) {
313 | return true;
314 | }
315 |
316 | const description = inst.description || {};
317 |
318 | // If version is an array, it's versioned
319 | if (Array.isArray(description.version)) {
320 | return true;
321 | }
322 |
323 | // If it has defaultVersion, it's likely versioned
324 | if (description.defaultVersion !== undefined) {
325 | return true;
326 | }
327 | } catch (e) {
328 | // Ignore instantiation errors
329 | }
330 |
331 | return false;
332 | }
333 | }
```
--------------------------------------------------------------------------------
/tests/unit/docker/parse-config.test.ts:
--------------------------------------------------------------------------------
```typescript
1 | import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
2 | import { execSync } from 'child_process';
3 | import fs from 'fs';
4 | import path from 'path';
5 | import os from 'os';
6 |
7 | describe('parse-config.js', () => {
8 | let tempDir: string;
9 | let configPath: string;
10 | const parseConfigPath = path.resolve(__dirname, '../../../docker/parse-config.js');
11 |
12 | // Clean environment for tests - only include essential variables
13 | const cleanEnv = {
14 | PATH: process.env.PATH,
15 | HOME: process.env.HOME,
16 | NODE_ENV: process.env.NODE_ENV
17 | };
18 |
19 | beforeEach(() => {
20 | // Create temporary directory for test config files
21 | tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'parse-config-test-'));
22 | configPath = path.join(tempDir, 'config.json');
23 | });
24 |
25 | afterEach(() => {
26 | // Clean up temporary directory
27 | if (fs.existsSync(tempDir)) {
28 | fs.rmSync(tempDir, { recursive: true });
29 | }
30 | });
31 |
32 | describe('Basic functionality', () => {
33 | it('should parse simple flat config', () => {
34 | const config = {
35 | mcp_mode: 'http',
36 | auth_token: 'test-token-123',
37 | port: 3000
38 | };
39 | fs.writeFileSync(configPath, JSON.stringify(config));
40 |
41 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
42 | encoding: 'utf8',
43 | env: cleanEnv
44 | });
45 |
46 | expect(output).toContain("export MCP_MODE='http'");
47 | expect(output).toContain("export AUTH_TOKEN='test-token-123'");
48 | expect(output).toContain("export PORT='3000'");
49 | });
50 |
51 | it('should handle nested objects by flattening with underscores', () => {
52 | const config = {
53 | database: {
54 | host: 'localhost',
55 | port: 5432,
56 | credentials: {
57 | user: 'admin',
58 | pass: 'secret'
59 | }
60 | }
61 | };
62 | fs.writeFileSync(configPath, JSON.stringify(config));
63 |
64 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
65 | encoding: 'utf8',
66 | env: cleanEnv
67 | });
68 |
69 | expect(output).toContain("export DATABASE_HOST='localhost'");
70 | expect(output).toContain("export DATABASE_PORT='5432'");
71 | expect(output).toContain("export DATABASE_CREDENTIALS_USER='admin'");
72 | expect(output).toContain("export DATABASE_CREDENTIALS_PASS='secret'");
73 | });
74 |
75 | it('should convert boolean values to strings', () => {
76 | const config = {
77 | debug: true,
78 | verbose: false
79 | };
80 | fs.writeFileSync(configPath, JSON.stringify(config));
81 |
82 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
83 | encoding: 'utf8',
84 | env: cleanEnv
85 | });
86 |
87 | expect(output).toContain("export DEBUG='true'");
88 | expect(output).toContain("export VERBOSE='false'");
89 | });
90 |
91 | it('should convert numbers to strings', () => {
92 | const config = {
93 | timeout: 5000,
94 | retry_count: 3,
95 | float_value: 3.14
96 | };
97 | fs.writeFileSync(configPath, JSON.stringify(config));
98 |
99 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
100 | encoding: 'utf8',
101 | env: cleanEnv
102 | });
103 |
104 | expect(output).toContain("export TIMEOUT='5000'");
105 | expect(output).toContain("export RETRY_COUNT='3'");
106 | expect(output).toContain("export FLOAT_VALUE='3.14'");
107 | });
108 | });
109 |
110 | describe('Environment variable precedence', () => {
111 | it('should not export variables that are already set in environment', () => {
112 | const config = {
113 | existing_var: 'config-value',
114 | new_var: 'new-value'
115 | };
116 | fs.writeFileSync(configPath, JSON.stringify(config));
117 |
118 | // Set environment variable for the child process
119 | const env = { ...cleanEnv, EXISTING_VAR: 'env-value' };
120 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
121 | encoding: 'utf8',
122 | env
123 | });
124 |
125 | expect(output).not.toContain("export EXISTING_VAR=");
126 | expect(output).toContain("export NEW_VAR='new-value'");
127 | });
128 |
129 | it('should respect nested environment variables', () => {
130 | const config = {
131 | database: {
132 | host: 'config-host',
133 | port: 5432
134 | }
135 | };
136 | fs.writeFileSync(configPath, JSON.stringify(config));
137 |
138 | const env = { ...cleanEnv, DATABASE_HOST: 'env-host' };
139 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
140 | encoding: 'utf8',
141 | env
142 | });
143 |
144 | expect(output).not.toContain("export DATABASE_HOST=");
145 | expect(output).toContain("export DATABASE_PORT='5432'");
146 | });
147 | });
148 |
149 | describe('Shell escaping and security', () => {
150 | it('should escape single quotes properly', () => {
151 | const config = {
152 | message: "It's a test with 'quotes'",
153 | command: "echo 'hello'"
154 | };
155 | fs.writeFileSync(configPath, JSON.stringify(config));
156 |
157 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
158 | encoding: 'utf8',
159 | env: cleanEnv
160 | });
161 |
162 | // Single quotes should be escaped as '"'"'
163 | expect(output).toContain(`export MESSAGE='It'"'"'s a test with '"'"'quotes'"'"'`);
164 | expect(output).toContain(`export COMMAND='echo '"'"'hello'"'"'`);
165 | });
166 |
167 | it('should handle command injection attempts safely', () => {
168 | const config = {
169 | malicious1: "'; rm -rf /; echo '",
170 | malicious2: "$( rm -rf / )",
171 | malicious3: "`rm -rf /`",
172 | malicious4: "test\nrm -rf /\necho"
173 | };
174 | fs.writeFileSync(configPath, JSON.stringify(config));
175 |
176 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
177 | encoding: 'utf8',
178 | env: cleanEnv
179 | });
180 |
181 | // All malicious content should be safely quoted
182 | expect(output).toContain(`export MALICIOUS1=''"'"'; rm -rf /; echo '"'"'`);
183 | expect(output).toContain(`export MALICIOUS2='$( rm -rf / )'`);
184 | expect(output).toContain(`export MALICIOUS3='`);
185 | expect(output).toContain(`export MALICIOUS4='test\nrm -rf /\necho'`);
186 |
187 | // Verify that when we evaluate the exports in a shell, the malicious content
188 | // is safely contained as string values and not executed
189 | // Test this by creating a temp script that sources the exports and echoes a success message
190 | const testScript = `
191 | #!/bin/sh
192 | set -e
193 | ${output}
194 | echo "SUCCESS: No commands were executed"
195 | `;
196 |
197 | const tempScript = path.join(tempDir, 'test-safety.sh');
198 | fs.writeFileSync(tempScript, testScript);
199 | fs.chmodSync(tempScript, '755');
200 |
201 | // If the quoting is correct, this should succeed
202 | // If any commands leak out, the script will fail
203 | const result = execSync(tempScript, { encoding: 'utf8', env: cleanEnv });
204 | expect(result.trim()).toBe('SUCCESS: No commands were executed');
205 | });
206 |
207 | it('should handle special shell characters safely', () => {
208 | const config = {
209 | special1: "test$VAR",
210 | special2: "test${VAR}",
211 | special3: "test\\path",
212 | special4: "test|command",
213 | special5: "test&background",
214 | special6: "test>redirect",
215 | special7: "test<input",
216 | special8: "test;command"
217 | };
218 | fs.writeFileSync(configPath, JSON.stringify(config));
219 |
220 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
221 | encoding: 'utf8',
222 | env: cleanEnv
223 | });
224 |
225 | // All special characters should be preserved within single quotes
226 | expect(output).toContain("export SPECIAL1='test$VAR'");
227 | expect(output).toContain("export SPECIAL2='test${VAR}'");
228 | expect(output).toContain("export SPECIAL3='test\\path'");
229 | expect(output).toContain("export SPECIAL4='test|command'");
230 | expect(output).toContain("export SPECIAL5='test&background'");
231 | expect(output).toContain("export SPECIAL6='test>redirect'");
232 | expect(output).toContain("export SPECIAL7='test<input'");
233 | expect(output).toContain("export SPECIAL8='test;command'");
234 | });
235 | });
236 |
237 | describe('Edge cases and error handling', () => {
238 | it('should exit silently if config file does not exist', () => {
239 | const nonExistentPath = path.join(tempDir, 'non-existent.json');
240 |
241 | const result = execSync(`node "${parseConfigPath}" "${nonExistentPath}"`, {
242 | encoding: 'utf8',
243 | env: cleanEnv
244 | });
245 |
246 | expect(result).toBe('');
247 | });
248 |
249 | it('should exit silently on invalid JSON', () => {
250 | fs.writeFileSync(configPath, '{ invalid json }');
251 |
252 | const result = execSync(`node "${parseConfigPath}" "${configPath}"`, {
253 | encoding: 'utf8',
254 | env: cleanEnv
255 | });
256 |
257 | expect(result).toBe('');
258 | });
259 |
260 | it('should handle empty config file', () => {
261 | fs.writeFileSync(configPath, '{}');
262 |
263 | const result = execSync(`node "${parseConfigPath}" "${configPath}"`, {
264 | encoding: 'utf8',
265 | env: cleanEnv
266 | });
267 |
268 | expect(result.trim()).toBe('');
269 | });
270 |
271 | it('should ignore arrays in config', () => {
272 | const config = {
273 | valid_string: 'test',
274 | invalid_array: ['item1', 'item2'],
275 | nested: {
276 | valid_number: 42,
277 | invalid_array: [1, 2, 3]
278 | }
279 | };
280 | fs.writeFileSync(configPath, JSON.stringify(config));
281 |
282 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
283 | encoding: 'utf8',
284 | env: cleanEnv
285 | });
286 |
287 | expect(output).toContain("export VALID_STRING='test'");
288 | expect(output).toContain("export NESTED_VALID_NUMBER='42'");
289 | expect(output).not.toContain('INVALID_ARRAY');
290 | });
291 |
292 | it('should ignore null values', () => {
293 | const config = {
294 | valid_string: 'test',
295 | null_value: null,
296 | nested: {
297 | another_null: null,
298 | valid_bool: true
299 | }
300 | };
301 | fs.writeFileSync(configPath, JSON.stringify(config));
302 |
303 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
304 | encoding: 'utf8',
305 | env: cleanEnv
306 | });
307 |
308 | expect(output).toContain("export VALID_STRING='test'");
309 | expect(output).toContain("export NESTED_VALID_BOOL='true'");
310 | expect(output).not.toContain('NULL_VALUE');
311 | expect(output).not.toContain('ANOTHER_NULL');
312 | });
313 |
314 | it('should handle deeply nested structures', () => {
315 | const config = {
316 | level1: {
317 | level2: {
318 | level3: {
319 | level4: {
320 | level5: 'deep-value'
321 | }
322 | }
323 | }
324 | }
325 | };
326 | fs.writeFileSync(configPath, JSON.stringify(config));
327 |
328 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
329 | encoding: 'utf8',
330 | env: cleanEnv
331 | });
332 |
333 | expect(output).toContain("export LEVEL1_LEVEL2_LEVEL3_LEVEL4_LEVEL5='deep-value'");
334 | });
335 |
336 | it('should handle empty strings', () => {
337 | const config = {
338 | empty_string: '',
339 | nested: {
340 | another_empty: ''
341 | }
342 | };
343 | fs.writeFileSync(configPath, JSON.stringify(config));
344 |
345 | const output = execSync(`node "${parseConfigPath}" "${configPath}"`, {
346 | encoding: 'utf8',
347 | env: cleanEnv
348 | });
349 |
350 | expect(output).toContain("export EMPTY_STRING=''");
351 | expect(output).toContain("export NESTED_ANOTHER_EMPTY=''");
352 | });
353 | });
354 |
355 | describe('Default behavior', () => {
356 | it('should use /app/config.json as default path when no argument provided', () => {
357 | // This test would need to be run in a Docker environment or mocked
358 | // For now, we just verify the script accepts no arguments
359 | try {
360 | const result = execSync(`node "${parseConfigPath}"`, {
361 | encoding: 'utf8',
362 | stdio: 'pipe',
363 | env: cleanEnv
364 | });
365 | // Should exit silently if /app/config.json doesn't exist
366 | expect(result).toBe('');
367 | } catch (error) {
368 | // Expected to fail outside Docker environment
369 | expect(true).toBe(true);
370 | }
371 | });
372 | });
373 | });
```
--------------------------------------------------------------------------------
/tests/unit/services/workflow-validator-loops-simple.test.ts:
--------------------------------------------------------------------------------
```typescript
1 | import { describe, it, expect, beforeEach, vi } from 'vitest';
2 | import { WorkflowValidator } from '@/services/workflow-validator';
3 | import { NodeRepository } from '@/database/node-repository';
4 | import { EnhancedConfigValidator } from '@/services/enhanced-config-validator';
5 |
6 | // Mock dependencies
7 | vi.mock('@/database/node-repository');
8 | vi.mock('@/services/enhanced-config-validator');
9 |
10 | describe('WorkflowValidator - SplitInBatches Validation (Simplified)', () => {
11 | let validator: WorkflowValidator;
12 | let mockNodeRepository: any;
13 | let mockNodeValidator: any;
14 |
15 | beforeEach(() => {
16 | vi.clearAllMocks();
17 |
18 | mockNodeRepository = {
19 | getNode: vi.fn()
20 | };
21 |
22 | mockNodeValidator = {
23 | validateWithMode: vi.fn().mockReturnValue({
24 | errors: [],
25 | warnings: []
26 | })
27 | };
28 |
29 | validator = new WorkflowValidator(mockNodeRepository, mockNodeValidator);
30 | });
31 |
32 | describe('SplitInBatches node detection', () => {
33 | it('should identify SplitInBatches nodes in workflow', async () => {
34 | mockNodeRepository.getNode.mockReturnValue({
35 | nodeType: 'nodes-base.splitInBatches',
36 | properties: []
37 | });
38 |
39 | const workflow = {
40 | name: 'SplitInBatches Workflow',
41 | nodes: [
42 | {
43 | id: '1',
44 | name: 'Split In Batches',
45 | type: 'n8n-nodes-base.splitInBatches',
46 | position: [100, 100],
47 | parameters: { batchSize: 10 }
48 | },
49 | {
50 | id: '2',
51 | name: 'Process Item',
52 | type: 'n8n-nodes-base.set',
53 | position: [300, 100],
54 | parameters: {}
55 | }
56 | ],
57 | connections: {
58 | 'Split In Batches': {
59 | main: [
60 | [], // Done output (0)
61 | [{ node: 'Process Item', type: 'main', index: 0 }] // Loop output (1)
62 | ]
63 | }
64 | }
65 | };
66 |
67 | const result = await validator.validateWorkflow(workflow as any);
68 |
69 | // Should complete validation without crashing
70 | expect(result).toBeDefined();
71 | expect(result.valid).toBeDefined();
72 | });
73 |
74 | it('should handle SplitInBatches with processing node name patterns', async () => {
75 | mockNodeRepository.getNode.mockReturnValue({
76 | nodeType: 'nodes-base.splitInBatches',
77 | properties: []
78 | });
79 |
80 | const processingNames = [
81 | 'Process Item',
82 | 'Transform Data',
83 | 'Handle Each',
84 | 'Function Node',
85 | 'Code Block'
86 | ];
87 |
88 | for (const nodeName of processingNames) {
89 | const workflow = {
90 | name: 'Processing Pattern Test',
91 | nodes: [
92 | {
93 | id: '1',
94 | name: 'Split In Batches',
95 | type: 'n8n-nodes-base.splitInBatches',
96 | position: [100, 100],
97 | parameters: {}
98 | },
99 | {
100 | id: '2',
101 | name: nodeName,
102 | type: 'n8n-nodes-base.function',
103 | position: [300, 100],
104 | parameters: {}
105 | }
106 | ],
107 | connections: {
108 | 'Split In Batches': {
109 | main: [
110 | [{ node: nodeName, type: 'main', index: 0 }], // Processing node on Done output
111 | []
112 | ]
113 | }
114 | }
115 | };
116 |
117 | const result = await validator.validateWorkflow(workflow as any);
118 |
119 | // Should identify potential processing nodes
120 | expect(result).toBeDefined();
121 | }
122 | });
123 |
124 | it('should handle final processing node patterns', async () => {
125 | mockNodeRepository.getNode.mockReturnValue({
126 | nodeType: 'nodes-base.splitInBatches',
127 | properties: []
128 | });
129 |
130 | const finalNames = [
131 | 'Final Summary',
132 | 'Send Email',
133 | 'Complete Notification',
134 | 'Final Report'
135 | ];
136 |
137 | for (const nodeName of finalNames) {
138 | const workflow = {
139 | name: 'Final Pattern Test',
140 | nodes: [
141 | {
142 | id: '1',
143 | name: 'Split In Batches',
144 | type: 'n8n-nodes-base.splitInBatches',
145 | position: [100, 100],
146 | parameters: {}
147 | },
148 | {
149 | id: '2',
150 | name: nodeName,
151 | type: 'n8n-nodes-base.emailSend',
152 | position: [300, 100],
153 | parameters: {}
154 | }
155 | ],
156 | connections: {
157 | 'Split In Batches': {
158 | main: [
159 | [{ node: nodeName, type: 'main', index: 0 }], // Final node on Done output (correct)
160 | []
161 | ]
162 | }
163 | }
164 | };
165 |
166 | const result = await validator.validateWorkflow(workflow as any);
167 |
168 | // Should not warn about final nodes on done output
169 | expect(result).toBeDefined();
170 | }
171 | });
172 | });
173 |
174 | describe('Connection validation', () => {
175 | it('should validate connection indices', async () => {
176 | mockNodeRepository.getNode.mockReturnValue({
177 | nodeType: 'nodes-base.splitInBatches',
178 | properties: []
179 | });
180 |
181 | const workflow = {
182 | name: 'Connection Index Test',
183 | nodes: [
184 | {
185 | id: '1',
186 | name: 'Split In Batches',
187 | type: 'n8n-nodes-base.splitInBatches',
188 | position: [100, 100],
189 | parameters: {}
190 | },
191 | {
192 | id: '2',
193 | name: 'Target',
194 | type: 'n8n-nodes-base.set',
195 | position: [300, 100],
196 | parameters: {}
197 | }
198 | ],
199 | connections: {
200 | 'Split In Batches': {
201 | main: [
202 | [{ node: 'Target', type: 'main', index: -1 }] // Invalid negative index
203 | ]
204 | }
205 | }
206 | };
207 |
208 | const result = await validator.validateWorkflow(workflow as any);
209 |
210 | const negativeIndexErrors = result.errors.filter(e =>
211 | e.message?.includes('Invalid connection index -1')
212 | );
213 | expect(negativeIndexErrors.length).toBeGreaterThan(0);
214 | });
215 |
216 | it('should handle non-existent target nodes', async () => {
217 | mockNodeRepository.getNode.mockReturnValue({
218 | nodeType: 'nodes-base.splitInBatches',
219 | properties: []
220 | });
221 |
222 | const workflow = {
223 | name: 'Missing Target Test',
224 | nodes: [
225 | {
226 | id: '1',
227 | name: 'Split In Batches',
228 | type: 'n8n-nodes-base.splitInBatches',
229 | position: [100, 100],
230 | parameters: {}
231 | }
232 | ],
233 | connections: {
234 | 'Split In Batches': {
235 | main: [
236 | [{ node: 'NonExistentNode', type: 'main', index: 0 }]
237 | ]
238 | }
239 | }
240 | };
241 |
242 | const result = await validator.validateWorkflow(workflow as any);
243 |
244 | const missingNodeErrors = result.errors.filter(e =>
245 | e.message?.includes('non-existent node')
246 | );
247 | expect(missingNodeErrors.length).toBeGreaterThan(0);
248 | });
249 | });
250 |
251 | describe('Self-referencing connections', () => {
252 | it('should allow self-referencing for SplitInBatches nodes', async () => {
253 | mockNodeRepository.getNode.mockReturnValue({
254 | nodeType: 'nodes-base.splitInBatches',
255 | properties: []
256 | });
257 |
258 | const workflow = {
259 | name: 'Self Reference Test',
260 | nodes: [
261 | {
262 | id: '1',
263 | name: 'Split In Batches',
264 | type: 'n8n-nodes-base.splitInBatches',
265 | position: [100, 100],
266 | parameters: {}
267 | }
268 | ],
269 | connections: {
270 | 'Split In Batches': {
271 | main: [
272 | [],
273 | [{ node: 'Split In Batches', type: 'main', index: 0 }] // Self-reference on loop output
274 | ]
275 | }
276 | }
277 | };
278 |
279 | const result = await validator.validateWorkflow(workflow as any);
280 |
281 | // Should not warn about self-reference for SplitInBatches
282 | const selfRefWarnings = result.warnings.filter(w =>
283 | w.message?.includes('self-referencing')
284 | );
285 | expect(selfRefWarnings).toHaveLength(0);
286 | });
287 |
288 | it('should warn about self-referencing for non-loop nodes', async () => {
289 | mockNodeRepository.getNode.mockReturnValue({
290 | nodeType: 'nodes-base.set',
291 | properties: []
292 | });
293 |
294 | const workflow = {
295 | name: 'Non-Loop Self Reference Test',
296 | nodes: [
297 | {
298 | id: '1',
299 | name: 'Set',
300 | type: 'n8n-nodes-base.set',
301 | position: [100, 100],
302 | parameters: {}
303 | }
304 | ],
305 | connections: {
306 | 'Set': {
307 | main: [
308 | [{ node: 'Set', type: 'main', index: 0 }] // Self-reference on regular node
309 | ]
310 | }
311 | }
312 | };
313 |
314 | const result = await validator.validateWorkflow(workflow as any);
315 |
316 | // Should warn about self-reference for non-loop nodes
317 | const selfRefWarnings = result.warnings.filter(w =>
318 | w.message?.includes('self-referencing')
319 | );
320 | expect(selfRefWarnings.length).toBeGreaterThan(0);
321 | });
322 | });
323 |
324 | describe('Output connection validation', () => {
325 | it('should validate output connections for nodes with outputs', async () => {
326 | mockNodeRepository.getNode.mockReturnValue({
327 | nodeType: 'nodes-base.if',
328 | outputs: [
329 | { displayName: 'True', description: 'Items that match condition' },
330 | { displayName: 'False', description: 'Items that do not match condition' }
331 | ],
332 | outputNames: ['true', 'false'],
333 | properties: []
334 | });
335 |
336 | const workflow = {
337 | name: 'IF Node Test',
338 | nodes: [
339 | {
340 | id: '1',
341 | name: 'IF',
342 | type: 'n8n-nodes-base.if',
343 | position: [100, 100],
344 | parameters: {}
345 | },
346 | {
347 | id: '2',
348 | name: 'True Handler',
349 | type: 'n8n-nodes-base.set',
350 | position: [300, 50],
351 | parameters: {}
352 | },
353 | {
354 | id: '3',
355 | name: 'False Handler',
356 | type: 'n8n-nodes-base.set',
357 | position: [300, 150],
358 | parameters: {}
359 | }
360 | ],
361 | connections: {
362 | 'IF': {
363 | main: [
364 | [{ node: 'True Handler', type: 'main', index: 0 }], // True output (0)
365 | [{ node: 'False Handler', type: 'main', index: 0 }] // False output (1)
366 | ]
367 | }
368 | }
369 | };
370 |
371 | const result = await validator.validateWorkflow(workflow as any);
372 |
373 | // Should validate without major errors
374 | expect(result).toBeDefined();
375 | expect(result.statistics.validConnections).toBe(2);
376 | });
377 | });
378 |
379 | describe('Error handling', () => {
380 | it('should handle nodes without outputs gracefully', async () => {
381 | mockNodeRepository.getNode.mockReturnValue({
382 | nodeType: 'nodes-base.httpRequest',
383 | outputs: null,
384 | outputNames: null,
385 | properties: []
386 | });
387 |
388 | const workflow = {
389 | name: 'No Outputs Test',
390 | nodes: [
391 | {
392 | id: '1',
393 | name: 'HTTP Request',
394 | type: 'n8n-nodes-base.httpRequest',
395 | position: [100, 100],
396 | parameters: {}
397 | }
398 | ],
399 | connections: {}
400 | };
401 |
402 | const result = await validator.validateWorkflow(workflow as any);
403 |
404 | // Should handle gracefully without crashing
405 | expect(result).toBeDefined();
406 | });
407 |
408 | it('should handle unknown node types gracefully', async () => {
409 | mockNodeRepository.getNode.mockReturnValue(null);
410 |
411 | const workflow = {
412 | name: 'Unknown Node Test',
413 | nodes: [
414 | {
415 | id: '1',
416 | name: 'Unknown',
417 | type: 'n8n-nodes-base.unknown',
418 | position: [100, 100],
419 | parameters: {}
420 | }
421 | ],
422 | connections: {}
423 | };
424 |
425 | const result = await validator.validateWorkflow(workflow as any);
426 |
427 | // Should report unknown node error
428 | const unknownErrors = result.errors.filter(e =>
429 | e.message?.includes('Unknown node type')
430 | );
431 | expect(unknownErrors.length).toBeGreaterThan(0);
432 | });
433 | });
434 | });
```
--------------------------------------------------------------------------------
/tests/fixtures/template-configs.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Test fixtures for template node configurations
3 | * Used across unit and integration tests for P0-R3 feature
4 | */
5 |
6 | import * as zlib from 'zlib';
7 |
8 | export interface TemplateConfigFixture {
9 | node_type: string;
10 | template_id: number;
11 | template_name: string;
12 | template_views: number;
13 | node_name: string;
14 | parameters_json: string;
15 | credentials_json: string | null;
16 | has_credentials: number;
17 | has_expressions: number;
18 | complexity: 'simple' | 'medium' | 'complex';
19 | use_cases: string;
20 | rank?: number;
21 | }
22 |
23 | export interface WorkflowFixture {
24 | id: string;
25 | name: string;
26 | nodes: any[];
27 | connections: Record<string, any>;
28 | settings?: Record<string, any>;
29 | }
30 |
31 | /**
32 | * Sample node configurations for common use cases
33 | */
34 | export const sampleConfigs: Record<string, TemplateConfigFixture> = {
35 | simpleWebhook: {
36 | node_type: 'n8n-nodes-base.webhook',
37 | template_id: 1,
38 | template_name: 'Simple Webhook Trigger',
39 | template_views: 5000,
40 | node_name: 'Webhook',
41 | parameters_json: JSON.stringify({
42 | httpMethod: 'POST',
43 | path: 'webhook',
44 | responseMode: 'lastNode',
45 | alwaysOutputData: true
46 | }),
47 | credentials_json: null,
48 | has_credentials: 0,
49 | has_expressions: 0,
50 | complexity: 'simple',
51 | use_cases: JSON.stringify(['webhook processing', 'trigger automation']),
52 | rank: 1
53 | },
54 |
55 | webhookWithAuth: {
56 | node_type: 'n8n-nodes-base.webhook',
57 | template_id: 2,
58 | template_name: 'Authenticated Webhook',
59 | template_views: 3000,
60 | node_name: 'Webhook',
61 | parameters_json: JSON.stringify({
62 | httpMethod: 'POST',
63 | path: 'secure-webhook',
64 | responseMode: 'responseNode',
65 | authentication: 'headerAuth'
66 | }),
67 | credentials_json: JSON.stringify({
68 | httpHeaderAuth: {
69 | id: '1',
70 | name: 'Header Auth'
71 | }
72 | }),
73 | has_credentials: 1,
74 | has_expressions: 0,
75 | complexity: 'medium',
76 | use_cases: JSON.stringify(['secure webhook', 'authenticated triggers']),
77 | rank: 2
78 | },
79 |
80 | httpRequestBasic: {
81 | node_type: 'n8n-nodes-base.httpRequest',
82 | template_id: 3,
83 | template_name: 'Basic HTTP GET Request',
84 | template_views: 10000,
85 | node_name: 'HTTP Request',
86 | parameters_json: JSON.stringify({
87 | url: 'https://api.example.com/data',
88 | method: 'GET',
89 | responseFormat: 'json',
90 | options: {
91 | timeout: 10000,
92 | redirect: {
93 | followRedirects: true
94 | }
95 | }
96 | }),
97 | credentials_json: null,
98 | has_credentials: 0,
99 | has_expressions: 0,
100 | complexity: 'simple',
101 | use_cases: JSON.stringify(['API calls', 'data fetching']),
102 | rank: 1
103 | },
104 |
105 | httpRequestWithExpressions: {
106 | node_type: 'n8n-nodes-base.httpRequest',
107 | template_id: 4,
108 | template_name: 'Dynamic HTTP Request',
109 | template_views: 7500,
110 | node_name: 'HTTP Request',
111 | parameters_json: JSON.stringify({
112 | url: '={{ $json.apiUrl }}',
113 | method: 'POST',
114 | sendBody: true,
115 | bodyParameters: {
116 | values: [
117 | {
118 | name: 'userId',
119 | value: '={{ $json.userId }}'
120 | },
121 | {
122 | name: 'action',
123 | value: '={{ $json.action }}'
124 | }
125 | ]
126 | },
127 | options: {
128 | timeout: '={{ $json.timeout || 10000 }}'
129 | }
130 | }),
131 | credentials_json: null,
132 | has_credentials: 0,
133 | has_expressions: 1,
134 | complexity: 'complex',
135 | use_cases: JSON.stringify(['dynamic API calls', 'expression-based routing']),
136 | rank: 2
137 | },
138 |
139 | slackMessage: {
140 | node_type: 'n8n-nodes-base.slack',
141 | template_id: 5,
142 | template_name: 'Send Slack Message',
143 | template_views: 8000,
144 | node_name: 'Slack',
145 | parameters_json: JSON.stringify({
146 | resource: 'message',
147 | operation: 'post',
148 | channel: '#general',
149 | text: 'Hello from n8n!'
150 | }),
151 | credentials_json: JSON.stringify({
152 | slackApi: {
153 | id: '2',
154 | name: 'Slack API'
155 | }
156 | }),
157 | has_credentials: 1,
158 | has_expressions: 0,
159 | complexity: 'simple',
160 | use_cases: JSON.stringify(['notifications', 'team communication']),
161 | rank: 1
162 | },
163 |
164 | codeNodeTransform: {
165 | node_type: 'n8n-nodes-base.code',
166 | template_id: 6,
167 | template_name: 'Data Transformation',
168 | template_views: 6000,
169 | node_name: 'Code',
170 | parameters_json: JSON.stringify({
171 | mode: 'runOnceForAllItems',
172 | jsCode: `const items = $input.all();
173 |
174 | return items.map(item => ({
175 | json: {
176 | id: item.json.id,
177 | name: item.json.name.toUpperCase(),
178 | timestamp: new Date().toISOString()
179 | }
180 | }));`
181 | }),
182 | credentials_json: null,
183 | has_credentials: 0,
184 | has_expressions: 0,
185 | complexity: 'medium',
186 | use_cases: JSON.stringify(['data transformation', 'custom logic']),
187 | rank: 1
188 | },
189 |
190 | codeNodeWithExpressions: {
191 | node_type: 'n8n-nodes-base.code',
192 | template_id: 7,
193 | template_name: 'Advanced Code with Expressions',
194 | template_views: 4500,
195 | node_name: 'Code',
196 | parameters_json: JSON.stringify({
197 | mode: 'runOnceForEachItem',
198 | jsCode: `const data = $input.item.json;
199 | const previousNode = $('HTTP Request').first().json;
200 |
201 | return {
202 | json: {
203 | combined: data.value + previousNode.value,
204 | nodeRef: $node
205 | }
206 | };`
207 | }),
208 | credentials_json: null,
209 | has_credentials: 0,
210 | has_expressions: 1,
211 | complexity: 'complex',
212 | use_cases: JSON.stringify(['advanced transformations', 'node references']),
213 | rank: 2
214 | }
215 | };
216 |
217 | /**
218 | * Sample workflows for testing extraction
219 | */
220 | export const sampleWorkflows: Record<string, WorkflowFixture> = {
221 | webhookToSlack: {
222 | id: '1',
223 | name: 'Webhook to Slack Notification',
224 | nodes: [
225 | {
226 | id: 'webhook1',
227 | name: 'Webhook',
228 | type: 'n8n-nodes-base.webhook',
229 | typeVersion: 1,
230 | position: [250, 300],
231 | parameters: {
232 | httpMethod: 'POST',
233 | path: 'alert',
234 | responseMode: 'lastNode'
235 | }
236 | },
237 | {
238 | id: 'slack1',
239 | name: 'Slack',
240 | type: 'n8n-nodes-base.slack',
241 | typeVersion: 1,
242 | position: [450, 300],
243 | parameters: {
244 | resource: 'message',
245 | operation: 'post',
246 | channel: '#alerts',
247 | text: '={{ $json.message }}'
248 | },
249 | credentials: {
250 | slackApi: {
251 | id: '1',
252 | name: 'Slack API'
253 | }
254 | }
255 | }
256 | ],
257 | connections: {
258 | webhook1: {
259 | main: [[{ node: 'slack1', type: 'main', index: 0 }]]
260 | }
261 | },
262 | settings: {}
263 | },
264 |
265 | apiWorkflow: {
266 | id: '2',
267 | name: 'API Data Processing',
268 | nodes: [
269 | {
270 | id: 'http1',
271 | name: 'Fetch Data',
272 | type: 'n8n-nodes-base.httpRequest',
273 | typeVersion: 3,
274 | position: [250, 300],
275 | parameters: {
276 | url: 'https://api.example.com/users',
277 | method: 'GET',
278 | responseFormat: 'json'
279 | }
280 | },
281 | {
282 | id: 'code1',
283 | name: 'Transform',
284 | type: 'n8n-nodes-base.code',
285 | typeVersion: 2,
286 | position: [450, 300],
287 | parameters: {
288 | mode: 'runOnceForAllItems',
289 | jsCode: 'return $input.all().map(item => ({ json: { ...item.json, processed: true } }));'
290 | }
291 | },
292 | {
293 | id: 'http2',
294 | name: 'Send Results',
295 | type: 'n8n-nodes-base.httpRequest',
296 | typeVersion: 3,
297 | position: [650, 300],
298 | parameters: {
299 | url: '={{ $json.callbackUrl }}',
300 | method: 'POST',
301 | sendBody: true,
302 | bodyParameters: {
303 | values: [
304 | { name: 'data', value: '={{ JSON.stringify($json) }}' }
305 | ]
306 | }
307 | }
308 | }
309 | ],
310 | connections: {
311 | http1: {
312 | main: [[{ node: 'code1', type: 'main', index: 0 }]]
313 | },
314 | code1: {
315 | main: [[{ node: 'http2', type: 'main', index: 0 }]]
316 | }
317 | },
318 | settings: {}
319 | },
320 |
321 | complexWorkflow: {
322 | id: '3',
323 | name: 'Complex Multi-Node Workflow',
324 | nodes: [
325 | {
326 | id: 'webhook1',
327 | name: 'Start',
328 | type: 'n8n-nodes-base.webhook',
329 | typeVersion: 1,
330 | position: [100, 300],
331 | parameters: {
332 | httpMethod: 'POST',
333 | path: 'start'
334 | }
335 | },
336 | {
337 | id: 'sticky1',
338 | name: 'Note',
339 | type: 'n8n-nodes-base.stickyNote',
340 | typeVersion: 1,
341 | position: [100, 200],
342 | parameters: {
343 | content: 'This workflow processes incoming data'
344 | }
345 | },
346 | {
347 | id: 'if1',
348 | name: 'Check Type',
349 | type: 'n8n-nodes-base.if',
350 | typeVersion: 1,
351 | position: [300, 300],
352 | parameters: {
353 | conditions: {
354 | boolean: [
355 | {
356 | value1: '={{ $json.type }}',
357 | value2: 'premium'
358 | }
359 | ]
360 | }
361 | }
362 | },
363 | {
364 | id: 'http1',
365 | name: 'Premium API',
366 | type: 'n8n-nodes-base.httpRequest',
367 | typeVersion: 3,
368 | position: [500, 200],
369 | parameters: {
370 | url: 'https://api.example.com/premium',
371 | method: 'POST'
372 | }
373 | },
374 | {
375 | id: 'http2',
376 | name: 'Standard API',
377 | type: 'n8n-nodes-base.httpRequest',
378 | typeVersion: 3,
379 | position: [500, 400],
380 | parameters: {
381 | url: 'https://api.example.com/standard',
382 | method: 'POST'
383 | }
384 | }
385 | ],
386 | connections: {
387 | webhook1: {
388 | main: [[{ node: 'if1', type: 'main', index: 0 }]]
389 | },
390 | if1: {
391 | main: [
392 | [{ node: 'http1', type: 'main', index: 0 }],
393 | [{ node: 'http2', type: 'main', index: 0 }]
394 | ]
395 | }
396 | },
397 | settings: {}
398 | }
399 | };
400 |
401 | /**
402 | * Compress workflow to base64 (mimics n8n template format)
403 | */
404 | export function compressWorkflow(workflow: WorkflowFixture): string {
405 | const json = JSON.stringify(workflow);
406 | return zlib.gzipSync(Buffer.from(json, 'utf-8')).toString('base64');
407 | }
408 |
409 | /**
410 | * Create template metadata
411 | */
412 | export function createTemplateMetadata(complexity: 'simple' | 'medium' | 'complex', useCases: string[]) {
413 | return {
414 | complexity,
415 | use_cases: useCases
416 | };
417 | }
418 |
419 | /**
420 | * Batch create configs for testing
421 | */
422 | export function createConfigBatch(nodeType: string, count: number): TemplateConfigFixture[] {
423 | return Array.from({ length: count }, (_, i) => ({
424 | node_type: nodeType,
425 | template_id: i + 1,
426 | template_name: `Template ${i + 1}`,
427 | template_views: 1000 - (i * 50),
428 | node_name: `Node ${i + 1}`,
429 | parameters_json: JSON.stringify({ index: i }),
430 | credentials_json: null,
431 | has_credentials: 0,
432 | has_expressions: 0,
433 | complexity: (['simple', 'medium', 'complex'] as const)[i % 3],
434 | use_cases: JSON.stringify(['test use case']),
435 | rank: i + 1
436 | }));
437 | }
438 |
439 | /**
440 | * Get config by complexity
441 | */
442 | export function getConfigByComplexity(complexity: 'simple' | 'medium' | 'complex'): TemplateConfigFixture {
443 | const configs = Object.values(sampleConfigs);
444 | const match = configs.find(c => c.complexity === complexity);
445 | return match || configs[0];
446 | }
447 |
448 | /**
449 | * Get configs with expressions
450 | */
451 | export function getConfigsWithExpressions(): TemplateConfigFixture[] {
452 | return Object.values(sampleConfigs).filter(c => c.has_expressions === 1);
453 | }
454 |
455 | /**
456 | * Get configs with credentials
457 | */
458 | export function getConfigsWithCredentials(): TemplateConfigFixture[] {
459 | return Object.values(sampleConfigs).filter(c => c.has_credentials === 1);
460 | }
461 |
462 | /**
463 | * Mock database insert helper
464 | */
465 | export function createInsertStatement(config: TemplateConfigFixture): string {
466 | return `INSERT INTO template_node_configs (
467 | node_type, template_id, template_name, template_views,
468 | node_name, parameters_json, credentials_json,
469 | has_credentials, has_expressions, complexity, use_cases, rank
470 | ) VALUES (
471 | '${config.node_type}',
472 | ${config.template_id},
473 | '${config.template_name}',
474 | ${config.template_views},
475 | '${config.node_name}',
476 | '${config.parameters_json.replace(/'/g, "''")}',
477 | ${config.credentials_json ? `'${config.credentials_json.replace(/'/g, "''")}'` : 'NULL'},
478 | ${config.has_credentials},
479 | ${config.has_expressions},
480 | '${config.complexity}',
481 | '${config.use_cases.replace(/'/g, "''")}',
482 | ${config.rank || 0}
483 | )`;
484 | }
485 |
```
--------------------------------------------------------------------------------
/src/services/n8n-api-client.ts:
--------------------------------------------------------------------------------
```typescript
1 | import axios, { AxiosInstance, AxiosRequestConfig, InternalAxiosRequestConfig } from 'axios';
2 | import { logger } from '../utils/logger';
3 | import {
4 | Workflow,
5 | WorkflowListParams,
6 | WorkflowListResponse,
7 | Execution,
8 | ExecutionListParams,
9 | ExecutionListResponse,
10 | Credential,
11 | CredentialListParams,
12 | CredentialListResponse,
13 | Tag,
14 | TagListParams,
15 | TagListResponse,
16 | HealthCheckResponse,
17 | Variable,
18 | WebhookRequest,
19 | WorkflowExport,
20 | WorkflowImport,
21 | SourceControlStatus,
22 | SourceControlPullResult,
23 | SourceControlPushResult,
24 | } from '../types/n8n-api';
25 | import { handleN8nApiError, logN8nError } from '../utils/n8n-errors';
26 | import { cleanWorkflowForCreate, cleanWorkflowForUpdate } from './n8n-validation';
27 |
28 | export interface N8nApiClientConfig {
29 | baseUrl: string;
30 | apiKey: string;
31 | timeout?: number;
32 | maxRetries?: number;
33 | }
34 |
35 | export class N8nApiClient {
36 | private client: AxiosInstance;
37 | private maxRetries: number;
38 |
39 | constructor(config: N8nApiClientConfig) {
40 | const { baseUrl, apiKey, timeout = 30000, maxRetries = 3 } = config;
41 |
42 | this.maxRetries = maxRetries;
43 |
44 | // Ensure baseUrl ends with /api/v1
45 | const apiUrl = baseUrl.endsWith('/api/v1')
46 | ? baseUrl
47 | : `${baseUrl.replace(/\/$/, '')}/api/v1`;
48 |
49 | this.client = axios.create({
50 | baseURL: apiUrl,
51 | timeout,
52 | headers: {
53 | 'X-N8N-API-KEY': apiKey,
54 | 'Content-Type': 'application/json',
55 | },
56 | });
57 |
58 | // Request interceptor for logging
59 | this.client.interceptors.request.use(
60 | (config: InternalAxiosRequestConfig) => {
61 | logger.debug(`n8n API Request: ${config.method?.toUpperCase()} ${config.url}`, {
62 | params: config.params,
63 | data: config.data,
64 | });
65 | return config;
66 | },
67 | (error: unknown) => {
68 | logger.error('n8n API Request Error:', error);
69 | return Promise.reject(error);
70 | }
71 | );
72 |
73 | // Response interceptor for logging
74 | this.client.interceptors.response.use(
75 | (response: any) => {
76 | logger.debug(`n8n API Response: ${response.status} ${response.config.url}`);
77 | return response;
78 | },
79 | (error: unknown) => {
80 | const n8nError = handleN8nApiError(error);
81 | logN8nError(n8nError, 'n8n API Response');
82 | return Promise.reject(n8nError);
83 | }
84 | );
85 | }
86 |
87 | // Health check to verify API connectivity
88 | async healthCheck(): Promise<HealthCheckResponse> {
89 | try {
90 | // Try the standard healthz endpoint (available on all n8n instances)
91 | const baseUrl = this.client.defaults.baseURL || '';
92 | const healthzUrl = baseUrl.replace(/\/api\/v\d+\/?$/, '') + '/healthz';
93 |
94 | const response = await axios.get(healthzUrl, {
95 | timeout: 5000,
96 | validateStatus: (status) => status < 500
97 | });
98 |
99 | if (response.status === 200 && response.data?.status === 'ok') {
100 | return {
101 | status: 'ok',
102 | features: {} // Features detection would require additional endpoints
103 | };
104 | }
105 |
106 | // If healthz doesn't work, fall back to API check
107 | throw new Error('healthz endpoint not available');
108 | } catch (error) {
109 | // If healthz endpoint doesn't exist, try listing workflows with limit 1
110 | // This is a fallback for older n8n versions
111 | try {
112 | await this.client.get('/workflows', { params: { limit: 1 } });
113 | return {
114 | status: 'ok',
115 | features: {}
116 | };
117 | } catch (fallbackError) {
118 | throw handleN8nApiError(fallbackError);
119 | }
120 | }
121 | }
122 |
123 | // Workflow Management
124 | async createWorkflow(workflow: Partial<Workflow>): Promise<Workflow> {
125 | try {
126 | const cleanedWorkflow = cleanWorkflowForCreate(workflow);
127 | const response = await this.client.post('/workflows', cleanedWorkflow);
128 | return response.data;
129 | } catch (error) {
130 | throw handleN8nApiError(error);
131 | }
132 | }
133 |
134 | async getWorkflow(id: string): Promise<Workflow> {
135 | try {
136 | const response = await this.client.get(`/workflows/${id}`);
137 | return response.data;
138 | } catch (error) {
139 | throw handleN8nApiError(error);
140 | }
141 | }
142 |
143 | async updateWorkflow(id: string, workflow: Partial<Workflow>): Promise<Workflow> {
144 | try {
145 | // First, try PUT method (newer n8n versions)
146 | const cleanedWorkflow = cleanWorkflowForUpdate(workflow as Workflow);
147 | try {
148 | const response = await this.client.put(`/workflows/${id}`, cleanedWorkflow);
149 | return response.data;
150 | } catch (putError: any) {
151 | // If PUT fails with 405 (Method Not Allowed), try PATCH
152 | if (putError.response?.status === 405) {
153 | logger.debug('PUT method not supported, falling back to PATCH');
154 | const response = await this.client.patch(`/workflows/${id}`, cleanedWorkflow);
155 | return response.data;
156 | }
157 | throw putError;
158 | }
159 | } catch (error) {
160 | throw handleN8nApiError(error);
161 | }
162 | }
163 |
164 | async deleteWorkflow(id: string): Promise<Workflow> {
165 | try {
166 | const response = await this.client.delete(`/workflows/${id}`);
167 | return response.data;
168 | } catch (error) {
169 | throw handleN8nApiError(error);
170 | }
171 | }
172 |
173 | async listWorkflows(params: WorkflowListParams = {}): Promise<WorkflowListResponse> {
174 | try {
175 | const response = await this.client.get('/workflows', { params });
176 | return response.data;
177 | } catch (error) {
178 | throw handleN8nApiError(error);
179 | }
180 | }
181 |
182 | // Execution Management
183 | async getExecution(id: string, includeData = false): Promise<Execution> {
184 | try {
185 | const response = await this.client.get(`/executions/${id}`, {
186 | params: { includeData },
187 | });
188 | return response.data;
189 | } catch (error) {
190 | throw handleN8nApiError(error);
191 | }
192 | }
193 |
194 | async listExecutions(params: ExecutionListParams = {}): Promise<ExecutionListResponse> {
195 | try {
196 | const response = await this.client.get('/executions', { params });
197 | return response.data;
198 | } catch (error) {
199 | throw handleN8nApiError(error);
200 | }
201 | }
202 |
203 | async deleteExecution(id: string): Promise<void> {
204 | try {
205 | await this.client.delete(`/executions/${id}`);
206 | } catch (error) {
207 | throw handleN8nApiError(error);
208 | }
209 | }
210 |
211 | // Webhook Execution
212 | async triggerWebhook(request: WebhookRequest): Promise<any> {
213 | try {
214 | const { webhookUrl, httpMethod, data, headers, waitForResponse = true } = request;
215 |
216 | // SECURITY: Validate URL for SSRF protection (includes DNS resolution)
217 | // See: https://github.com/czlonkowski/n8n-mcp/issues/265 (HIGH-03)
218 | const { SSRFProtection } = await import('../utils/ssrf-protection');
219 | const validation = await SSRFProtection.validateWebhookUrl(webhookUrl);
220 |
221 | if (!validation.valid) {
222 | throw new Error(`SSRF protection: ${validation.reason}`);
223 | }
224 |
225 | // Extract path from webhook URL
226 | const url = new URL(webhookUrl);
227 | const webhookPath = url.pathname;
228 |
229 | // Make request directly to webhook endpoint
230 | const config: AxiosRequestConfig = {
231 | method: httpMethod,
232 | url: webhookPath,
233 | headers: {
234 | ...headers,
235 | // Don't override API key header for webhook endpoints
236 | 'X-N8N-API-KEY': undefined,
237 | },
238 | data: httpMethod !== 'GET' ? data : undefined,
239 | params: httpMethod === 'GET' ? data : undefined,
240 | // Webhooks might take longer
241 | timeout: waitForResponse ? 120000 : 30000,
242 | };
243 |
244 | // Create a new axios instance for webhook requests to avoid API interceptors
245 | const webhookClient = axios.create({
246 | baseURL: new URL('/', webhookUrl).toString(),
247 | validateStatus: (status) => status < 500, // Don't throw on 4xx
248 | });
249 |
250 | const response = await webhookClient.request(config);
251 |
252 | return {
253 | status: response.status,
254 | statusText: response.statusText,
255 | data: response.data,
256 | headers: response.headers,
257 | };
258 | } catch (error) {
259 | throw handleN8nApiError(error);
260 | }
261 | }
262 |
263 | // Credential Management
264 | async listCredentials(params: CredentialListParams = {}): Promise<CredentialListResponse> {
265 | try {
266 | const response = await this.client.get('/credentials', { params });
267 | return response.data;
268 | } catch (error) {
269 | throw handleN8nApiError(error);
270 | }
271 | }
272 |
273 | async getCredential(id: string): Promise<Credential> {
274 | try {
275 | const response = await this.client.get(`/credentials/${id}`);
276 | return response.data;
277 | } catch (error) {
278 | throw handleN8nApiError(error);
279 | }
280 | }
281 |
282 | async createCredential(credential: Partial<Credential>): Promise<Credential> {
283 | try {
284 | const response = await this.client.post('/credentials', credential);
285 | return response.data;
286 | } catch (error) {
287 | throw handleN8nApiError(error);
288 | }
289 | }
290 |
291 | async updateCredential(id: string, credential: Partial<Credential>): Promise<Credential> {
292 | try {
293 | const response = await this.client.patch(`/credentials/${id}`, credential);
294 | return response.data;
295 | } catch (error) {
296 | throw handleN8nApiError(error);
297 | }
298 | }
299 |
300 | async deleteCredential(id: string): Promise<void> {
301 | try {
302 | await this.client.delete(`/credentials/${id}`);
303 | } catch (error) {
304 | throw handleN8nApiError(error);
305 | }
306 | }
307 |
308 | // Tag Management
309 | async listTags(params: TagListParams = {}): Promise<TagListResponse> {
310 | try {
311 | const response = await this.client.get('/tags', { params });
312 | return response.data;
313 | } catch (error) {
314 | throw handleN8nApiError(error);
315 | }
316 | }
317 |
318 | async createTag(tag: Partial<Tag>): Promise<Tag> {
319 | try {
320 | const response = await this.client.post('/tags', tag);
321 | return response.data;
322 | } catch (error) {
323 | throw handleN8nApiError(error);
324 | }
325 | }
326 |
327 | async updateTag(id: string, tag: Partial<Tag>): Promise<Tag> {
328 | try {
329 | const response = await this.client.patch(`/tags/${id}`, tag);
330 | return response.data;
331 | } catch (error) {
332 | throw handleN8nApiError(error);
333 | }
334 | }
335 |
336 | async deleteTag(id: string): Promise<void> {
337 | try {
338 | await this.client.delete(`/tags/${id}`);
339 | } catch (error) {
340 | throw handleN8nApiError(error);
341 | }
342 | }
343 |
344 | // Source Control Management (Enterprise feature)
345 | async getSourceControlStatus(): Promise<SourceControlStatus> {
346 | try {
347 | const response = await this.client.get('/source-control/status');
348 | return response.data;
349 | } catch (error) {
350 | throw handleN8nApiError(error);
351 | }
352 | }
353 |
354 | async pullSourceControl(force = false): Promise<SourceControlPullResult> {
355 | try {
356 | const response = await this.client.post('/source-control/pull', { force });
357 | return response.data;
358 | } catch (error) {
359 | throw handleN8nApiError(error);
360 | }
361 | }
362 |
363 | async pushSourceControl(
364 | message: string,
365 | fileNames?: string[]
366 | ): Promise<SourceControlPushResult> {
367 | try {
368 | const response = await this.client.post('/source-control/push', {
369 | message,
370 | fileNames,
371 | });
372 | return response.data;
373 | } catch (error) {
374 | throw handleN8nApiError(error);
375 | }
376 | }
377 |
378 | // Variable Management (via Source Control API)
379 | async getVariables(): Promise<Variable[]> {
380 | try {
381 | const response = await this.client.get('/variables');
382 | return response.data.data || [];
383 | } catch (error) {
384 | // Variables might not be available in all n8n versions
385 | logger.warn('Variables API not available, returning empty array');
386 | return [];
387 | }
388 | }
389 |
390 | async createVariable(variable: Partial<Variable>): Promise<Variable> {
391 | try {
392 | const response = await this.client.post('/variables', variable);
393 | return response.data;
394 | } catch (error) {
395 | throw handleN8nApiError(error);
396 | }
397 | }
398 |
399 | async updateVariable(id: string, variable: Partial<Variable>): Promise<Variable> {
400 | try {
401 | const response = await this.client.patch(`/variables/${id}`, variable);
402 | return response.data;
403 | } catch (error) {
404 | throw handleN8nApiError(error);
405 | }
406 | }
407 |
408 | async deleteVariable(id: string): Promise<void> {
409 | try {
410 | await this.client.delete(`/variables/${id}`);
411 | } catch (error) {
412 | throw handleN8nApiError(error);
413 | }
414 | }
415 | }
```