n8n-mcp 2.7.9 → 2.7.11

package/dist/services/node-specific-validators.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeSpecificValidators = void 0;
 class NodeSpecificValidators {
     static validateSlack(context) {
-        const { config, errors, warnings, suggestions } = context;
+        const { config, errors, warnings, suggestions, autofix } = context;
         const { resource, operation } = config;
         if (resource === 'message') {
             switch (operation) {
@@ -38,6 +38,26 @@ class NodeSpecificValidators {
                 });
             }
         }
+        if (!config.onError && !config.retryOnFail && !config.continueOnFail) {
+            warnings.push({
+                type: 'best_practice',
+                property: 'errorHandling',
+                message: 'Slack API can have rate limits and transient failures',
+                suggestion: 'Add onError: "continueRegularOutput" with retryOnFail for resilience'
+            });
+            autofix.onError = 'continueRegularOutput';
+            autofix.retryOnFail = true;
+            autofix.maxTries = 2;
+            autofix.waitBetweenTries = 3000;
+        }
+        if (config.continueOnFail !== undefined) {
+            warnings.push({
+                type: 'deprecated',
+                property: 'continueOnFail',
+                message: 'continueOnFail is deprecated. Use onError instead',
+                suggestion: 'Replace with onError: "continueRegularOutput"'
+            });
+        }
     }
     static validateSlackSendMessage(context) {
         const { config, errors, warnings, suggestions, autofix } = context;
@@ -293,7 +313,7 @@ class NodeSpecificValidators {
         }
     }
     static validateOpenAI(context) {
-        const { config, errors, warnings, suggestions } = context;
+        const { config, errors, warnings, suggestions, autofix } = context;
         const { resource, operation } = config;
         if (resource === 'chat' && operation === 'create') {
             if (!config.model) {
@@ -342,9 +362,30 @@ class NodeSpecificValidators {
                 }
             }
         }
+        if (!config.onError && !config.retryOnFail && !config.continueOnFail) {
+            warnings.push({
+                type: 'best_practice',
+                property: 'errorHandling',
+                message: 'AI APIs have rate limits and can return errors',
+                suggestion: 'Add onError: "continueRegularOutput" with retryOnFail and longer wait times'
+            });
+            autofix.onError = 'continueRegularOutput';
+            autofix.retryOnFail = true;
+            autofix.maxTries = 3;
+            autofix.waitBetweenTries = 5000;
+            autofix.alwaysOutputData = true;
+        }
+        if (config.continueOnFail !== undefined) {
+            warnings.push({
+                type: 'deprecated',
+                property: 'continueOnFail',
+                message: 'continueOnFail is deprecated. Use onError instead',
+                suggestion: 'Replace with onError: "continueRegularOutput"'
+            });
+        }
     }
     static validateMongoDB(context) {
-        const { config, errors, warnings } = context;
+        const { config, errors, warnings, autofix } = context;
         const { operation } = config;
         if (!config.collection) {
             errors.push({
@@ -400,70 +441,37 @@ class NodeSpecificValidators {
                 }
                 break;
         }
-    }
-    static validateWebhook(context) {
-        const { config, errors, warnings, suggestions } = context;
-        if (!config.path) {
-            errors.push({
-                type: 'missing_required',
-                property: 'path',
-                message: 'Webhook path is required',
-                fix: 'Set a unique path like "my-webhook" (no leading slash)'
-            });
-        }
-        else {
-            const path = config.path;
-            if (path.startsWith('/')) {
+        if (!config.onError && !config.retryOnFail && !config.continueOnFail) {
+            if (operation === 'find') {
                 warnings.push({
-                    type: 'inefficient',
-                    property: 'path',
-                    message: 'Webhook path should not start with /',
-                    suggestion: 'Remove the leading slash: use "my-webhook" instead of "/my-webhook"'
-                });
-            }
-            if (path.includes(' ')) {
-                errors.push({
-                    type: 'invalid_value',
-                    property: 'path',
-                    message: 'Webhook path cannot contain spaces',
-                    fix: 'Replace spaces with hyphens or underscores'
+                    type: 'best_practice',
+                    property: 'errorHandling',
+                    message: 'MongoDB queries can fail due to connection issues',
+                    suggestion: 'Add onError: "continueRegularOutput" with retryOnFail'
                 });
+                autofix.onError = 'continueRegularOutput';
+                autofix.retryOnFail = true;
+                autofix.maxTries = 3;
             }
-            if (!/^[a-zA-Z0-9\-_\/]+$/.test(path.replace(/^\//, ''))) {
+            else if (['insert', 'update', 'delete'].includes(operation)) {
                 warnings.push({
-                    type: 'inefficient',
-                    property: 'path',
-                    message: 'Webhook path contains special characters',
-                    suggestion: 'Use only letters, numbers, hyphens, and underscores'
+                    type: 'best_practice',
+                    property: 'errorHandling',
+                    message: 'MongoDB write operations should handle errors carefully',
+                    suggestion: 'Add onError: "continueErrorOutput" to handle write failures separately'
                 });
+                autofix.onError = 'continueErrorOutput';
+                autofix.retryOnFail = true;
+                autofix.maxTries = 2;
+                autofix.waitBetweenTries = 1000;
             }
         }
-        if (config.responseMode === 'responseNode') {
-            suggestions.push('Add a "Respond to Webhook" node to send custom responses');
-            if (!config.responseData) {
-                warnings.push({
-                    type: 'missing_common',
-                    property: 'responseData',
-                    message: 'Response data not configured for responseNode mode',
-                    suggestion: 'Add a "Respond to Webhook" node or change responseMode'
-                });
-            }
-        }
-        if (config.httpMethod && Array.isArray(config.httpMethod)) {
-            if (config.httpMethod.length === 0) {
-                errors.push({
-                    type: 'invalid_value',
-                    property: 'httpMethod',
-                    message: 'At least one HTTP method must be selected',
-                    fix: 'Select GET, POST, or other methods your webhook should accept'
-                });
-            }
-        }
-        if (!config.authentication || config.authentication === 'none') {
+        if (config.continueOnFail !== undefined) {
             warnings.push({
-                type: 'security',
-                message: 'Webhook has no authentication',
-                suggestion: 'Consider adding authentication to prevent unauthorized access'
+                type: 'deprecated',
+                property: 'continueOnFail',
+                message: 'continueOnFail is deprecated. Use onError instead',
+                suggestion: 'Replace with onError: "continueRegularOutput" or "continueErrorOutput"'
             });
         }
     }
@@ -542,6 +550,39 @@ class NodeSpecificValidators {
         if (config.connectionTimeout === undefined) {
             suggestions.push('Consider setting connectionTimeout to handle slow connections');
         }
+        if (!config.onError && !config.retryOnFail && !config.continueOnFail) {
+            if (operation === 'execute' && config.query?.toLowerCase().includes('select')) {
+                warnings.push({
+                    type: 'best_practice',
+                    property: 'errorHandling',
+                    message: 'Database reads can fail due to connection issues',
+                    suggestion: 'Add onError: "continueRegularOutput" and retryOnFail: true'
+                });
+                autofix.onError = 'continueRegularOutput';
+                autofix.retryOnFail = true;
+                autofix.maxTries = 3;
+            }
+            else if (['insert', 'update', 'delete'].includes(operation)) {
+                warnings.push({
+                    type: 'best_practice',
+                    property: 'errorHandling',
+                    message: 'Database writes should handle errors carefully',
+                    suggestion: 'Add onError: "stopWorkflow" with retryOnFail for transient failures'
+                });
+                autofix.onError = 'stopWorkflow';
+                autofix.retryOnFail = true;
+                autofix.maxTries = 2;
+                autofix.waitBetweenTries = 2000;
+            }
+        }
+        if (config.continueOnFail !== undefined) {
+            warnings.push({
+                type: 'deprecated',
+                property: 'continueOnFail',
+                message: 'continueOnFail is deprecated. Use onError instead',
+                suggestion: 'Replace with onError: "continueRegularOutput" or "stopWorkflow"'
+            });
+        }
     }
     static validateMySQL(context) {
         const { config, errors, warnings, suggestions } = context;
@@ -602,6 +643,24 @@ class NodeSpecificValidators {
         if (config.timezone === undefined) {
             suggestions.push('Consider setting timezone to ensure consistent date/time handling');
         }
+        if (!config.onError && !config.retryOnFail && !config.continueOnFail) {
+            if (operation === 'execute' && config.query?.toLowerCase().includes('select')) {
+                warnings.push({
+                    type: 'best_practice',
+                    property: 'errorHandling',
+                    message: 'Database queries can fail due to connection issues',
+                    suggestion: 'Add onError: "continueRegularOutput" and retryOnFail: true'
+                });
+            }
+            else if (['insert', 'update', 'delete'].includes(operation)) {
+                warnings.push({
+                    type: 'best_practice',
+                    property: 'errorHandling',
+                    message: 'Database modifications should handle errors carefully',
+                    suggestion: 'Add onError: "stopWorkflow" with retryOnFail for transient failures'
+                });
+            }
+        }
     }
     static validateSQLQuery(context, dbType = 'generic') {
         const { config, errors, warnings, suggestions } = context;
@@ -661,6 +720,496 @@ class NodeSpecificValidators {
             }
         }
     }
+    static validateHttpRequest(context) {
+        const { config, errors, warnings, suggestions, autofix } = context;
+        const { method = 'GET', url, sendBody, authentication } = config;
+        if (!url) {
+            errors.push({
+                type: 'missing_required',
+                property: 'url',
+                message: 'URL is required for HTTP requests',
+                fix: 'Provide the full URL including protocol (https://...)'
+            });
+        }
+        else if (!url.startsWith('http://') && !url.startsWith('https://') && !url.includes('{{')) {
+            warnings.push({
+                type: 'invalid_value',
+                property: 'url',
+                message: 'URL should start with http:// or https://',
+                suggestion: 'Use https:// for secure connections'
+            });
+        }
+        if (['POST', 'PUT', 'PATCH'].includes(method) && !sendBody) {
+            warnings.push({
+                type: 'missing_common',
+                property: 'sendBody',
+                message: `${method} requests typically include a body`,
+                suggestion: 'Set sendBody: true and configure the body content'
+            });
+        }
+        if (!config.retryOnFail && !config.onError && !config.continueOnFail) {
+            warnings.push({
+                type: 'best_practice',
+                property: 'errorHandling',
+                message: 'HTTP requests can fail due to network issues or server errors',
+                suggestion: 'Add onError: "continueRegularOutput" and retryOnFail: true for resilience'
+            });
+            autofix.onError = 'continueRegularOutput';
+            autofix.retryOnFail = true;
+            autofix.maxTries = 3;
+            autofix.waitBetweenTries = 1000;
+        }
+        if (config.continueOnFail !== undefined) {
+            warnings.push({
+                type: 'deprecated',
+                property: 'continueOnFail',
+                message: 'continueOnFail is deprecated. Use onError instead',
+                suggestion: 'Replace with onError: "continueRegularOutput"'
+            });
+            autofix.onError = config.continueOnFail ? 'continueRegularOutput' : 'stopWorkflow';
+            delete autofix.continueOnFail;
+        }
+        if (config.retryOnFail) {
+            if (!['GET', 'HEAD', 'OPTIONS'].includes(method) && (!config.maxTries || config.maxTries > 3)) {
+                warnings.push({
+                    type: 'best_practice',
+                    property: 'maxTries',
+                    message: `${method} requests might not be idempotent. Use fewer retries.`,
+                    suggestion: 'Set maxTries: 2 for non-idempotent operations'
+                });
+            }
+            if (!config.alwaysOutputData) {
+                suggestions.push('Enable alwaysOutputData to capture error responses for debugging');
+                autofix.alwaysOutputData = true;
+            }
+        }
+        if (url && url.includes('api') && !authentication) {
+            warnings.push({
+                type: 'security',
+                property: 'authentication',
+                message: 'API endpoints typically require authentication',
+                suggestion: 'Configure authentication method (Bearer token, API key, etc.)'
+            });
+        }
+        if (!config.timeout) {
+            suggestions.push('Consider setting a timeout to prevent hanging requests');
+        }
+    }
+    static validateWebhook(context) {
+        const { config, errors, warnings, suggestions, autofix } = context;
+        const { path, httpMethod = 'POST', responseMode } = config;
+        if (!path) {
+            errors.push({
+                type: 'missing_required',
+                property: 'path',
+                message: 'Webhook path is required',
+                fix: 'Provide a unique path like "my-webhook" or "github-events"'
+            });
+        }
+        else if (path.startsWith('/')) {
+            warnings.push({
+                type: 'invalid_value',
+                property: 'path',
+                message: 'Webhook path should not start with /',
+                suggestion: 'Use "webhook-name" instead of "/webhook-name"'
+            });
+        }
+        if (!config.onError && !config.continueOnFail) {
+            warnings.push({
+                type: 'best_practice',
+                property: 'onError',
+                message: 'Webhooks should always send a response, even on error',
+                suggestion: 'Set onError: "continueRegularOutput" to ensure webhook responses'
+            });
+            autofix.onError = 'continueRegularOutput';
+        }
+        if (config.continueOnFail !== undefined) {
+            warnings.push({
+                type: 'deprecated',
+                property: 'continueOnFail',
+                message: 'continueOnFail is deprecated. Use onError instead',
+                suggestion: 'Replace with onError: "continueRegularOutput"'
+            });
+            autofix.onError = 'continueRegularOutput';
+            delete autofix.continueOnFail;
+        }
+        if (responseMode === 'responseNode' && !config.onError && !config.continueOnFail) {
+            errors.push({
+                type: 'invalid_configuration',
+                property: 'responseMode',
+                message: 'responseNode mode requires onError: "continueRegularOutput"',
+                fix: 'Set onError to ensure response is always sent'
+            });
+        }
+        if (!config.alwaysOutputData) {
+            suggestions.push('Enable alwaysOutputData to debug webhook payloads');
+            autofix.alwaysOutputData = true;
+        }
+        suggestions.push('Consider adding webhook validation (HMAC signature verification)');
+        suggestions.push('Implement rate limiting for public webhooks');
+    }
+    static validateCode(context) {
+        const { config, errors, warnings, suggestions, autofix } = context;
+        const language = config.language || 'javaScript';
+        const codeField = language === 'python' ? 'pythonCode' : 'jsCode';
+        const code = config[codeField] || '';
+        if (!code || code.trim() === '') {
+            errors.push({
+                type: 'missing_required',
+                property: codeField,
+                message: 'Code cannot be empty',
+                fix: 'Add your code logic. Start with: return [{json: {result: "success"}}]'
+            });
+            return;
+        }
+        if (language === 'javaScript') {
+            this.validateJavaScriptCode(code, errors, warnings, suggestions);
+        }
+        else if (language === 'python') {
+            this.validatePythonCode(code, errors, warnings, suggestions);
+        }
+        this.validateReturnStatement(code, language, errors, warnings, suggestions);
+        this.validateN8nVariables(code, language, warnings, suggestions, errors);
+        this.validateCodeSecurity(code, language, warnings);
+        if (!config.onError && code.length > 100) {
+            warnings.push({
+                type: 'best_practice',
+                property: 'errorHandling',
+                message: 'Code nodes can throw errors - consider error handling',
+                suggestion: 'Add onError: "continueRegularOutput" to handle errors gracefully'
+            });
+            autofix.onError = 'continueRegularOutput';
+        }
+        if (config.mode === 'runOnceForEachItem' && code.includes('items')) {
+            warnings.push({
+                type: 'best_practice',
+                message: 'In "Run Once for Each Item" mode, use $json instead of items array',
+                suggestion: 'Access current item data with $json.fieldName'
+            });
+        }
+        if (!config.mode && code.includes('$json')) {
+            warnings.push({
+                type: 'best_practice',
+                message: '$json only works in "Run Once for Each Item" mode',
+                suggestion: 'Either set mode: "runOnceForEachItem" or use items[0].json'
+            });
+        }
+    }
+    static validateJavaScriptCode(code, errors, warnings, suggestions) {
+        const syntaxPatterns = [
+            { pattern: /const\s+const/, message: 'Duplicate const declaration' },
+            { pattern: /let\s+let/, message: 'Duplicate let declaration' },
+            { pattern: /\)\s*\)\s*{/, message: 'Extra closing parenthesis before {' },
+            { pattern: /}\s*}$/, message: 'Extra closing brace at end' }
+        ];
+        syntaxPatterns.forEach(({ pattern, message }) => {
+            if (pattern.test(code)) {
+                errors.push({
+                    type: 'invalid_value',
+                    property: 'jsCode',
+                    message: `Syntax error: ${message}`,
+                    fix: 'Check your JavaScript syntax'
+                });
+            }
+        });
+        const functionWithAwait = /function\s+\w*\s*\([^)]*\)\s*{[^}]*await/;
+        const arrowWithAwait = /\([^)]*\)\s*=>\s*{[^}]*await/;
+        if ((functionWithAwait.test(code) || arrowWithAwait.test(code)) && !code.includes('async')) {
+            warnings.push({
+                type: 'best_practice',
+                message: 'Using await inside a non-async function',
+                suggestion: 'Add async keyword to the function, or use top-level await (Code nodes support it)'
+            });
+        }
+        if (code.includes('$helpers.httpRequest')) {
+            suggestions.push('$helpers.httpRequest is async - use: const response = await $helpers.httpRequest(...)');
+        }
+        if (code.includes('DateTime') && !code.includes('DateTime.')) {
+            warnings.push({
+                type: 'best_practice',
+                message: 'DateTime is from Luxon library',
+                suggestion: 'Use DateTime.now() or DateTime.fromISO() for date operations'
+            });
+        }
+    }
+    static validatePythonCode(code, errors, warnings, suggestions) {
+        const lines = code.split('\n');
+        if (code.includes('__name__') && code.includes('__main__')) {
+            warnings.push({
+                type: 'inefficient',
+                message: 'if __name__ == "__main__" is not needed in Code nodes',
+                suggestion: 'Code node Python runs directly - remove the main check'
+            });
+        }
+        const unavailableImports = [
+            { module: 'requests', suggestion: 'Use JavaScript Code node with $helpers.httpRequest for HTTP requests' },
+            { module: 'pandas', suggestion: 'Use built-in list/dict operations or JavaScript for data manipulation' },
+            { module: 'numpy', suggestion: 'Use standard Python math operations' },
+            { module: 'pip', suggestion: 'External packages cannot be installed in Code nodes' }
+        ];
+        unavailableImports.forEach(({ module, suggestion }) => {
+            if (code.includes(`import ${module}`) || code.includes(`from ${module}`)) {
+                errors.push({
+                    type: 'invalid_value',
+                    property: 'pythonCode',
+                    message: `Module '${module}' is not available in Code nodes`,
+                    fix: suggestion
+                });
+            }
+        });
+        lines.forEach((line, i) => {
+            if (line.trim().endsWith(':') && i < lines.length - 1) {
+                const nextLine = lines[i + 1];
+                if (nextLine.trim() && !nextLine.startsWith(' ') && !nextLine.startsWith('\t')) {
+                    errors.push({
+                        type: 'invalid_value',
+                        property: 'pythonCode',
+                        message: `Missing indentation after line ${i + 1}`,
+                        fix: 'Indent the line after the colon'
+                    });
+                }
+            }
+        });
+    }
+    static validateReturnStatement(code, language, errors, warnings, suggestions) {
+        const hasReturn = /return\s+/.test(code);
+        if (!hasReturn) {
+            errors.push({
+                type: 'missing_required',
+                property: language === 'python' ? 'pythonCode' : 'jsCode',
+                message: 'Code must return data for the next node',
+                fix: language === 'python'
+                    ? 'Add: return [{"json": {"result": "success"}}]'
+                    : 'Add: return [{json: {result: "success"}}]'
+            });
+            return;
+        }
+        if (language === 'javaScript') {
+            if (/return\s+{(?!.*\[).*}\s*;?$/s.test(code) && !code.includes('json:')) {
+                errors.push({
+                    type: 'invalid_value',
+                    property: 'jsCode',
+                    message: 'Return value must be an array of objects',
+                    fix: 'Wrap in array: return [{json: yourObject}]'
+                });
+            }
+            if (/return\s+(true|false|null|undefined|\d+|['"`])/m.test(code)) {
+                errors.push({
+                    type: 'invalid_value',
+                    property: 'jsCode',
+                    message: 'Cannot return primitive values directly',
+                    fix: 'Return array of objects: return [{json: {value: yourData}}]'
+                });
+            }
+            if (/return\s+\[[\s\n]*['"`\d]/.test(code)) {
+                errors.push({
+                    type: 'invalid_value',
+                    property: 'jsCode',
+                    message: 'Array items must be objects with json property',
+                    fix: 'Use: return [{json: {value: "data"}}] not return ["data"]'
+                });
+            }
+            if (/return\s+items\s*;?$/.test(code) && !code.includes('map')) {
+                suggestions.push('Returning items directly is fine if they already have {json: ...} structure. ' +
+                    'To modify: return items.map(item => ({json: {...item.json, newField: "value"}}))');
+            }
+        }
+        if (language === 'python') {
+            if (/return\s+{(?!.*\[).*}$/s.test(code)) {
+                errors.push({
+                    type: 'invalid_value',
+                    property: 'pythonCode',
+                    message: 'Return value must be a list of dicts',
+                    fix: 'Wrap in list: return [{"json": your_dict}]'
+                });
+            }
+            if (/return\s+(True|False|None|\d+|['"`])/m.test(code)) {
+                errors.push({
+                    type: 'invalid_value',
+                    property: 'pythonCode',
+                    message: 'Cannot return primitive values directly',
+                    fix: 'Return list of dicts: return [{"json": {"value": your_data}}]'
+                });
+            }
+        }
+    }
+    static validateN8nVariables(code, language, warnings, suggestions, errors) {
+        const inputPatterns = language === 'javaScript'
+            ? ['items', '$input', '$json', '$node', '$prevNode']
+            : ['items', '_input'];
+        const usesInput = inputPatterns.some(pattern => code.includes(pattern));
+        if (!usesInput && code.length > 50) {
+            warnings.push({
+                type: 'missing_common',
+                message: 'Code doesn\'t reference input data',
+                suggestion: language === 'javaScript'
+                    ? 'Access input with: items, $input.all(), or $json (single-item mode)'
+                    : 'Access input with: items variable'
+            });
+        }
+        if (code.includes('{{') && code.includes('}}')) {
+            errors.push({
+                type: 'invalid_value',
+                property: language === 'python' ? 'pythonCode' : 'jsCode',
+                message: 'Expression syntax {{...}} is not valid in Code nodes',
+                fix: 'Use regular JavaScript/Python syntax without double curly braces'
+            });
+        }
+        if (code.includes('$node[')) {
+            warnings.push({
+                type: 'invalid_value',
+                property: language === 'python' ? 'pythonCode' : 'jsCode',
+                message: 'Use $(\'Node Name\') instead of $node[\'Node Name\'] in Code nodes',
+                suggestion: 'Replace $node[\'NodeName\'] with $(\'NodeName\')'
+            });
+        }
+        const expressionOnlyFunctions = ['$now()', '$today()', '$tomorrow()', '.unique()', '.pluck(', '.keys()', '.hash('];
+        expressionOnlyFunctions.forEach(func => {
+            if (code.includes(func)) {
+                warnings.push({
+                    type: 'invalid_value',
+                    property: language === 'python' ? 'pythonCode' : 'jsCode',
+                    message: `${func} is an expression-only function not available in Code nodes`,
+                    suggestion: 'See Code node documentation for alternatives'
+                });
+            }
+        });
+        if (language === 'javaScript') {
+            if (/\$(?![a-zA-Z])/.test(code) && !code.includes('${')) {
+                warnings.push({
+                    type: 'best_practice',
+                    message: 'Invalid $ usage detected',
+                    suggestion: 'n8n variables start with $: $json, $input, $node, $workflow, $execution'
+                });
+            }
+            if (code.includes('helpers.') && !code.includes('$helpers')) {
+                warnings.push({
+                    type: 'invalid_value',
+                    property: 'jsCode',
+                    message: 'Use $helpers not helpers',
+                    suggestion: 'Change helpers. to $helpers.'
+                });
+            }
+            if (code.includes('$helpers') && !code.includes('typeof $helpers')) {
+                warnings.push({
+                    type: 'best_practice',
+                    message: '$helpers availability varies by n8n version',
+                    suggestion: 'Check availability first: if (typeof $helpers !== "undefined" && $helpers.httpRequest) { ... }'
+                });
+            }
+            if (code.includes('$helpers')) {
+                suggestions.push('Common $helpers methods: httpRequest(), prepareBinaryData(). Note: getWorkflowStaticData is a standalone function - use $getWorkflowStaticData() instead');
+            }
+            if (code.includes('$helpers.getWorkflowStaticData')) {
+                errors.push({
+                    type: 'invalid_value',
+                    property: 'jsCode',
+                    message: '$helpers.getWorkflowStaticData() will cause "$helpers is not defined" error',
+                    fix: 'Use $getWorkflowStaticData("global") or $getWorkflowStaticData("node") directly'
+                });
+            }
+            if (code.includes('$jmespath(') && /\$jmespath\s*\(\s*['"`]/.test(code)) {
+                warnings.push({
+                    type: 'invalid_value',
+                    property: 'jsCode',
+                    message: 'Code node $jmespath has reversed parameter order: $jmespath(data, query)',
+                    suggestion: 'Use: $jmespath(dataObject, "query.path") not $jmespath("query.path", dataObject)'
+                });
+            }
+            if (code.includes('items[0].json') && !code.includes('.json.body')) {
+                if (code.includes('Webhook') || code.includes('webhook') ||
+                    code.includes('$("Webhook")') || code.includes("$('Webhook')")) {
+                    warnings.push({
+                        type: 'invalid_value',
+                        property: 'jsCode',
+                        message: 'Webhook data is nested under .body property',
+                        suggestion: 'Use items[0].json.body.fieldName instead of items[0].json.fieldName for webhook data'
+                    });
+                }
+                else if (/items\[0\]\.json\.(payload|data|command|action|event|message)\b/.test(code)) {
+                    warnings.push({
+                        type: 'best_practice',
+                        message: 'If processing webhook data, remember it\'s nested under .body',
+                        suggestion: 'Webhook payloads are at items[0].json.body, not items[0].json'
+                    });
+                }
+            }
+        }
+        const jmespathFunction = language === 'javaScript' ? '$jmespath' : '_jmespath';
+        if (code.includes(jmespathFunction + '(')) {
+            const filterPattern = /\[?\?[^[\]]*(?:>=?|<=?|==|!=)\s*(\d+(?:\.\d+)?)\s*\]/g;
+            let match;
+            while ((match = filterPattern.exec(code)) !== null) {
+                const number = match[1];
+                const beforeNumber = code.substring(match.index, match.index + match[0].indexOf(number));
+                const afterNumber = code.substring(match.index + match[0].indexOf(number) + number.length);
+                if (!beforeNumber.includes('`') || !afterNumber.startsWith('`')) {
+                    errors.push({
+                        type: 'invalid_value',
+                        property: language === 'python' ? 'pythonCode' : 'jsCode',
+                        message: `JMESPath numeric literal ${number} must be wrapped in backticks`,
+                        fix: `Change [?field >= ${number}] to [?field >= \`${number}\`]`
+                    });
+                }
+            }
+            suggestions.push('JMESPath in n8n requires backticks around numeric literals in filters: [?age >= `18`]');
+        }
+    }
+    static validateCodeSecurity(code, language, warnings) {
+        const dangerousPatterns = [
+            { pattern: /eval\s*\(/, message: 'Avoid eval() - it\'s a security risk' },
+            { pattern: /Function\s*\(/, message: 'Avoid Function constructor - use regular functions' },
+            { pattern: language === 'python' ? /exec\s*\(/ : /exec\s*\(/, message: 'Avoid exec() - it\'s a security risk' },
+            { pattern: /process\.env/, message: 'Limited environment access in Code nodes' },
+            { pattern: /import\s+\*/, message: 'Avoid import * - be specific about imports' }
+        ];
+        dangerousPatterns.forEach(({ pattern, message }) => {
+            if (pattern.test(code)) {
+                warnings.push({
+                    type: 'security',
+                    message,
+                    suggestion: 'Use safer alternatives or built-in functions'
+                });
+            }
+        });
+        if (code.includes('require(')) {
+            const builtinModules = ['crypto', 'util', 'querystring', 'url', 'buffer'];
+            const requirePattern = /require\s*\(\s*['"`](\w+)['"`]\s*\)/g;
+            let match;
+            while ((match = requirePattern.exec(code)) !== null) {
+                const moduleName = match[1];
+                if (!builtinModules.includes(moduleName)) {
+                    warnings.push({
+                        type: 'security',
+                        message: `Cannot require('${moduleName}') - only built-in Node.js modules are available`,
+                        suggestion: `Available modules: ${builtinModules.join(', ')}`
+                    });
+                }
+            }
+            if (/require\s*\([^'"`]/.test(code)) {
+                warnings.push({
+                    type: 'security',
+                    message: 'Dynamic require() not supported',
+                    suggestion: 'Use static require with string literals: require("crypto")'
+                });
+            }
+        }
+        if ((code.includes('crypto.') || code.includes('randomBytes') || code.includes('randomUUID')) &&
+            !code.includes('require') && language === 'javaScript') {
+            warnings.push({
+                type: 'invalid_value',
+                message: 'Using crypto without require statement',
+                suggestion: 'Add: const crypto = require("crypto"); at the beginning (ignore editor warnings)'
+            });
+        }
+        if (/\b(fs|path|child_process)\b/.test(code)) {
+            warnings.push({
+                type: 'security',
+                message: 'File system and process access not available in Code nodes',
+                suggestion: 'Use other n8n nodes for file operations (e.g., Read/Write Files node)'
+            });
+        }
+    }
 }
 exports.NodeSpecificValidators = NodeSpecificValidators;
 //# sourceMappingURL=node-specific-validators.js.map