n8n-mcp 2.7.20 → 2.8.1

package/dist/services/workflow-validator.js

@@ -16,8 +16,8 @@ class WorkflowValidator {
             errors: [],
             warnings: [],
             statistics: {
-                totalNodes: workflow.nodes.length,
-                enabledNodes: workflow.nodes.filter(n => !n.disabled).length,
+                totalNodes: 0,
+                enabledNodes: 0,
                 triggerNodes: 0,
                 validConnections: 0,
                 invalidConnections: 0,
@@ -26,18 +26,32 @@ class WorkflowValidator {
             suggestions: []
         };
         try {
-            this.validateWorkflowStructure(workflow, result);
-            if (validateNodes) {
-                await this.validateAllNodes(workflow, result, profile);
-            }
-            if (validateConnections) {
-                this.validateConnections(workflow, result);
+            if (!workflow) {
+                result.errors.push({
+                    type: 'error',
+                    message: 'Invalid workflow structure: workflow is null or undefined'
+                });
+                result.valid = false;
+                return result;
             }
-            if (validateExpressions) {
-                this.validateExpressions(workflow, result);
+            result.statistics.totalNodes = Array.isArray(workflow.nodes) ? workflow.nodes.length : 0;
+            result.statistics.enabledNodes = Array.isArray(workflow.nodes) ? workflow.nodes.filter(n => !n.disabled).length : 0;
+            this.validateWorkflowStructure(workflow, result);
+            if (workflow.nodes && Array.isArray(workflow.nodes) && workflow.connections && typeof workflow.connections === 'object') {
+                if (validateNodes && workflow.nodes.length > 0) {
+                    await this.validateAllNodes(workflow, result, profile);
+                }
+                if (validateConnections) {
+                    this.validateConnections(workflow, result);
+                }
+                if (validateExpressions && workflow.nodes.length > 0) {
+                    this.validateExpressions(workflow, result);
+                }
+                if (workflow.nodes.length > 0) {
+                    this.checkWorkflowPatterns(workflow, result);
+                }
+                this.generateSuggestions(workflow, result);
             }
-            this.checkWorkflowPatterns(workflow, result);
-            this.generateSuggestions(workflow, result);
         }
         catch (error) {
             logger.error('Error validating workflow:', error);
@@ -50,24 +64,38 @@ class WorkflowValidator {
         return result;
     }
     validateWorkflowStructure(workflow, result) {
-        if (!workflow.nodes || !Array.isArray(workflow.nodes)) {
+        if (!workflow.nodes) {
             result.errors.push({
                 type: 'error',
-                message: 'Workflow must have a nodes array'
+                message: workflow.nodes === null ? 'nodes must be an array' : 'Workflow must have a nodes array'
             });
             return;
         }
-        if (!workflow.connections || typeof workflow.connections !== 'object') {
+        if (!Array.isArray(workflow.nodes)) {
             result.errors.push({
                 type: 'error',
-                message: 'Workflow must have a connections object'
+                message: 'nodes must be an array'
             });
             return;
         }
-        if (workflow.nodes.length === 0) {
+        if (!workflow.connections) {
             result.errors.push({
                 type: 'error',
-                message: 'Workflow has no nodes'
+                message: workflow.connections === null ? 'connections must be an object' : 'Workflow must have a connections object'
+            });
+            return;
+        }
+        if (typeof workflow.connections !== 'object' || Array.isArray(workflow.connections)) {
+            result.errors.push({
+                type: 'error',
+                message: 'connections must be an object'
+            });
+            return;
+        }
+        if (workflow.nodes.length === 0) {
+            result.warnings.push({
+                type: 'warning',
+                message: 'Workflow is empty - no nodes defined'
             });
             return;
         }
@@ -141,6 +169,34 @@ class WorkflowValidator {
             if (node.disabled)
                 continue;
             try {
+                if (node.name && node.name.length > 255) {
+                    result.warnings.push({
+                        type: 'warning',
+                        nodeId: node.id,
+                        nodeName: node.name,
+                        message: `Node name is very long (${node.name.length} characters). Consider using a shorter name for better readability.`
+                    });
+                }
+                if (!Array.isArray(node.position) || node.position.length !== 2) {
+                    result.errors.push({
+                        type: 'error',
+                        nodeId: node.id,
+                        nodeName: node.name,
+                        message: 'Node position must be an array with exactly 2 numbers [x, y]'
+                    });
+                }
+                else {
+                    const [x, y] = node.position;
+                    if (typeof x !== 'number' || typeof y !== 'number' ||
+                        !isFinite(x) || !isFinite(y)) {
+                        result.errors.push({
+                            type: 'error',
+                            nodeId: node.id,
+                            nodeName: node.name,
+                            message: 'Node position values must be finite numbers'
+                        });
+                    }
+                }
                 if (node.type.startsWith('nodes-base.')) {
                     const correctType = node.type.replace('nodes-base.', 'n8n-nodes-base.');
                     result.errors.push({
@@ -236,7 +292,7 @@ class WorkflowValidator {
                         type: 'error',
                         nodeId: node.id,
                         nodeName: node.name,
-                        message: error
+                        message: typeof error === 'string' ? error : error.message || String(error)
                     });
                 });
                 nodeValidation.warnings.forEach((warning) => {
@@ -244,7 +300,7 @@ class WorkflowValidator {
                         type: 'warning',
                         nodeId: node.id,
                         nodeName: node.name,
-                        message: warning
+                        message: typeof warning === 'string' ? warning : warning.message || String(warning)
                     });
                 });
             }
@@ -344,6 +400,20 @@ class WorkflowValidator {
             if (!outputConnections)
                 return;
             outputConnections.forEach(connection => {
+                if (connection.index < 0) {
+                    result.errors.push({
+                        type: 'error',
+                        message: `Invalid connection index ${connection.index} from "${sourceName}". Connection indices must be non-negative.`
+                    });
+                    result.statistics.invalidConnections++;
+                    return;
+                }
+                if (connection.node === sourceName) {
+                    result.warnings.push({
+                        type: 'warning',
+                        message: `Node "${sourceName}" has a self-referencing connection. This can cause infinite loops.`
+                    });
+                }
                 const targetNode = nodeMap.get(connection.node);
                 if (!targetNode) {
                     const nodeById = nodeIdMap.get(connection.node);
@@ -460,7 +530,8 @@ class WorkflowValidator {
                 isInLoop: false
             };
             const exprValidation = expression_validator_1.ExpressionValidator.validateNodeExpressions(node.parameters, context);
-            result.statistics.expressionsValidated += exprValidation.usedVariables.size;
+            const expressionCount = this.countExpressionsInObject(node.parameters);
+            result.statistics.expressionsValidated += expressionCount;
             exprValidation.errors.forEach(error => {
                 result.errors.push({
                     type: 'error',
@@ -479,6 +550,26 @@ class WorkflowValidator {
             });
         }
     }
+    countExpressionsInObject(obj) {
+        let count = 0;
+        if (typeof obj === 'string') {
+            const matches = obj.match(/\{\{[\s\S]+?\}\}/g);
+            if (matches) {
+                count += matches.length;
+            }
+        }
+        else if (Array.isArray(obj)) {
+            for (const item of obj) {
+                count += this.countExpressionsInObject(item);
+            }
+        }
+        else if (obj && typeof obj === 'object') {
+            for (const value of Object.values(obj)) {
+                count += this.countExpressionsInObject(value);
+            }
+        }
+        return count;
+    }
     nodeHasInput(nodeName, workflow) {
         for (const [sourceName, outputs] of Object.entries(workflow.connections)) {
             if (outputs.main) {
@@ -499,7 +590,9 @@ class WorkflowValidator {
                 message: 'Consider adding error handling to your workflow'
             });
         }
-        this.checkNodeErrorHandling(workflow, result);
+        for (const node of workflow.nodes) {
+            this.checkNodeErrorHandling(node, workflow, result);
+        }
         const linearChainLength = this.getLongestLinearChain(workflow);
         if (linearChainLength > 10) {
             result.warnings.push({
@@ -507,6 +600,7 @@ class WorkflowValidator {
                 message: `Long linear chain detected (${linearChainLength} nodes). Consider breaking into sub-workflows.`
             });
         }
+        this.generateErrorHandlingSuggestions(workflow, result);
         for (const node of workflow.nodes) {
             if (node.credentials && Object.keys(node.credentials).length > 0) {
                 for (const [credType, credConfig] of Object.entries(node.credentials)) {
@@ -652,11 +746,13 @@ class WorkflowValidator {
             result.suggestions.push('A minimal workflow needs: 1) A trigger node (e.g., Manual Trigger), 2) An action node (e.g., Set, HTTP Request), 3) A connection between them');
         }
     }
-    checkNodeErrorHandling(workflow, result) {
+    checkNodeErrorHandling(node, workflow, result) {
+        if (node.disabled === true)
+            return;
         const errorProneNodeTypes = [
-            'httpRequest',
+            'httprequest',
             'webhook',
-            'emailSend',
+            'emailsend',
             'slack',
             'discord',
             'telegram',
@@ -670,8 +766,8 @@ class WorkflowValidator {
             'salesforce',
             'hubspot',
             'airtable',
-            'googleSheets',
-            'googleDrive',
+            'googlesheets',
+            'googledrive',
             'dropbox',
             's3',
             'ftp',
@@ -683,235 +779,233 @@ class WorkflowValidator {
             'openai',
             'anthropic'
         ];
-        for (const node of workflow.nodes) {
-            if (node.disabled)
-                continue;
-            const normalizedType = node.type.toLowerCase();
-            const isErrorProne = errorProneNodeTypes.some(type => normalizedType.includes(type));
-            const nodeLevelProps = [
-                'onError', 'continueOnFail', 'retryOnFail', 'maxTries', 'waitBetweenTries', 'alwaysOutputData',
-                'executeOnce', 'disabled', 'notes', 'notesInFlow', 'credentials'
-            ];
-            const misplacedProps = [];
-            if (node.parameters) {
-                for (const prop of nodeLevelProps) {
-                    if (node.parameters[prop] !== undefined) {
-                        misplacedProps.push(prop);
-                    }
+        const normalizedType = node.type.toLowerCase();
+        const isErrorProne = errorProneNodeTypes.some(type => normalizedType.includes(type));
+        const nodeLevelProps = [
+            'onError', 'continueOnFail', 'retryOnFail', 'maxTries', 'waitBetweenTries', 'alwaysOutputData',
+            'executeOnce', 'disabled', 'notes', 'notesInFlow', 'credentials'
+        ];
+        const misplacedProps = [];
+        if (node.parameters) {
+            for (const prop of nodeLevelProps) {
+                if (node.parameters[prop] !== undefined) {
+                    misplacedProps.push(prop);
                 }
             }
-            if (misplacedProps.length > 0) {
+        }
+        if (misplacedProps.length > 0) {
+            result.errors.push({
+                type: 'error',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: `Node-level properties ${misplacedProps.join(', ')} are in the wrong location. They must be at the node level, not inside parameters.`,
+                details: {
+                    fix: `Move these properties from node.parameters to the node level. Example:\n` +
+                        `{\n` +
+                        `  "name": "${node.name}",\n` +
+                        `  "type": "${node.type}",\n` +
+                        `  "parameters": { /* operation-specific params */ },\n` +
+                        `  "onError": "continueErrorOutput",  // ✅ Correct location\n` +
+                        `  "retryOnFail": true,               // ✅ Correct location\n` +
+                        `  "executeOnce": true,               // ✅ Correct location\n` +
+                        `  "disabled": false,                 // ✅ Correct location\n` +
+                        `  "credentials": { /* ... */ }       // ✅ Correct location\n` +
+                        `}`
+                }
+            });
+        }
+        if (node.onError !== undefined) {
+            const validOnErrorValues = ['continueRegularOutput', 'continueErrorOutput', 'stopWorkflow'];
+            if (!validOnErrorValues.includes(node.onError)) {
                 result.errors.push({
                     type: 'error',
                     nodeId: node.id,
                     nodeName: node.name,
-                    message: `Node-level properties ${misplacedProps.join(', ')} are in the wrong location. They must be at the node level, not inside parameters.`,
-                    details: {
-                        fix: `Move these properties from node.parameters to the node level. Example:\n` +
-                            `{\n` +
-                            `  "name": "${node.name}",\n` +
-                            `  "type": "${node.type}",\n` +
-                            `  "parameters": { /* operation-specific params */ },\n` +
-                            `  "onError": "continueErrorOutput",  // ✅ Correct location\n` +
-                            `  "retryOnFail": true,               // ✅ Correct location\n` +
-                            `  "executeOnce": true,               // ✅ Correct location\n` +
-                            `  "disabled": false,                 // ✅ Correct location\n` +
-                            `  "credentials": { /* ... */ }       // ✅ Correct location\n` +
-                            `}`
-                    }
+                    message: `Invalid onError value: "${node.onError}". Must be one of: ${validOnErrorValues.join(', ')}`
                 });
             }
-            if (node.onError !== undefined) {
-                const validOnErrorValues = ['continueRegularOutput', 'continueErrorOutput', 'stopWorkflow'];
-                if (!validOnErrorValues.includes(node.onError)) {
-                    result.errors.push({
-                        type: 'error',
-                        nodeId: node.id,
-                        nodeName: node.name,
-                        message: `Invalid onError value: "${node.onError}". Must be one of: ${validOnErrorValues.join(', ')}`
-                    });
-                }
+        }
+        if (node.continueOnFail !== undefined) {
+            if (typeof node.continueOnFail !== 'boolean') {
+                result.errors.push({
+                    type: 'error',
+                    nodeId: node.id,
+                    nodeName: node.name,
+                    message: 'continueOnFail must be a boolean value'
+                });
             }
-            if (node.continueOnFail !== undefined) {
-                if (typeof node.continueOnFail !== 'boolean') {
-                    result.errors.push({
-                        type: 'error',
-                        nodeId: node.id,
-                        nodeName: node.name,
-                        message: 'continueOnFail must be a boolean value'
-                    });
-                }
-                else if (node.continueOnFail === true) {
-                    result.warnings.push({
-                        type: 'warning',
-                        nodeId: node.id,
-                        nodeName: node.name,
-                        message: 'Using deprecated "continueOnFail: true". Use "onError: \'continueRegularOutput\'" instead for better control and UI compatibility.'
-                    });
-                }
+            else if (node.continueOnFail === true) {
+                result.warnings.push({
+                    type: 'warning',
+                    nodeId: node.id,
+                    nodeName: node.name,
+                    message: 'Using deprecated "continueOnFail: true". Use "onError: \'continueRegularOutput\'" instead for better control and UI compatibility.'
+                });
             }
-            if (node.continueOnFail !== undefined && node.onError !== undefined) {
+        }
+        if (node.continueOnFail !== undefined && node.onError !== undefined) {
+            result.errors.push({
+                type: 'error',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: 'Cannot use both "continueOnFail" and "onError" properties. Use only "onError" for modern workflows.'
+            });
+        }
+        if (node.retryOnFail !== undefined) {
+            if (typeof node.retryOnFail !== 'boolean') {
                 result.errors.push({
                     type: 'error',
                     nodeId: node.id,
                     nodeName: node.name,
-                    message: 'Cannot use both "continueOnFail" and "onError" properties. Use only "onError" for modern workflows.'
+                    message: 'retryOnFail must be a boolean value'
                 });
             }
-            if (node.retryOnFail !== undefined) {
-                if (typeof node.retryOnFail !== 'boolean') {
-                    result.errors.push({
-                        type: 'error',
-                        nodeId: node.id,
-                        nodeName: node.name,
-                        message: 'retryOnFail must be a boolean value'
-                    });
-                }
-                if (node.retryOnFail === true) {
-                    if (node.maxTries !== undefined) {
-                        if (typeof node.maxTries !== 'number' || node.maxTries < 1) {
-                            result.errors.push({
-                                type: 'error',
-                                nodeId: node.id,
-                                nodeName: node.name,
-                                message: 'maxTries must be a positive number when retryOnFail is enabled'
-                            });
-                        }
-                        else if (node.maxTries > 10) {
-                            result.warnings.push({
-                                type: 'warning',
-                                nodeId: node.id,
-                                nodeName: node.name,
-                                message: `maxTries is set to ${node.maxTries}. Consider if this many retries is necessary.`
-                            });
-                        }
+            if (node.retryOnFail === true) {
+                if (node.maxTries !== undefined) {
+                    if (typeof node.maxTries !== 'number' || node.maxTries < 1) {
+                        result.errors.push({
+                            type: 'error',
+                            nodeId: node.id,
+                            nodeName: node.name,
+                            message: 'maxTries must be a positive number when retryOnFail is enabled'
+                        });
                     }
-                    else {
+                    else if (node.maxTries > 10) {
                         result.warnings.push({
                             type: 'warning',
                             nodeId: node.id,
                             nodeName: node.name,
-                            message: 'retryOnFail is enabled but maxTries is not specified. Default is 3 attempts.'
+                            message: `maxTries is set to ${node.maxTries}. Consider if this many retries is necessary.`
                         });
                     }
-                    if (node.waitBetweenTries !== undefined) {
-                        if (typeof node.waitBetweenTries !== 'number' || node.waitBetweenTries < 0) {
-                            result.errors.push({
-                                type: 'error',
-                                nodeId: node.id,
-                                nodeName: node.name,
-                                message: 'waitBetweenTries must be a non-negative number (milliseconds)'
-                            });
-                        }
-                        else if (node.waitBetweenTries > 300000) {
-                            result.warnings.push({
-                                type: 'warning',
-                                nodeId: node.id,
-                                nodeName: node.name,
-                                message: `waitBetweenTries is set to ${node.waitBetweenTries}ms (${(node.waitBetweenTries / 1000).toFixed(1)}s). This seems excessive.`
-                            });
-                        }
-                    }
-                }
-            }
-            if (node.alwaysOutputData !== undefined && typeof node.alwaysOutputData !== 'boolean') {
-                result.errors.push({
-                    type: 'error',
-                    nodeId: node.id,
-                    nodeName: node.name,
-                    message: 'alwaysOutputData must be a boolean value'
-                });
-            }
-            const hasErrorHandling = node.onError || node.continueOnFail || node.retryOnFail;
-            if (isErrorProne && !hasErrorHandling) {
-                const nodeTypeSimple = normalizedType.split('.').pop() || normalizedType;
-                if (normalizedType.includes('httprequest')) {
-                    result.warnings.push({
-                        type: 'warning',
-                        nodeId: node.id,
-                        nodeName: node.name,
-                        message: 'HTTP Request node without error handling. Consider adding "onError: \'continueRegularOutput\'" for non-critical requests or "retryOnFail: true" for transient failures.'
-                    });
-                }
-                else if (normalizedType.includes('webhook')) {
-                    result.warnings.push({
-                        type: 'warning',
-                        nodeId: node.id,
-                        nodeName: node.name,
-                        message: 'Webhook node without error handling. Consider adding "onError: \'continueRegularOutput\'" to prevent workflow failures from blocking webhook responses.'
-                    });
-                }
-                else if (errorProneNodeTypes.some(db => normalizedType.includes(db) && ['postgres', 'mysql', 'mongodb'].includes(db))) {
-                    result.warnings.push({
-                        type: 'warning',
-                        nodeId: node.id,
-                        nodeName: node.name,
-                        message: `Database operation without error handling. Consider adding "retryOnFail: true" for connection issues or "onError: \'continueRegularOutput\'" for non-critical queries.`
-                    });
                 }
                 else {
                     result.warnings.push({
                         type: 'warning',
                         nodeId: node.id,
                         nodeName: node.name,
-                        message: `${nodeTypeSimple} node interacts with external services but has no error handling configured. Consider using "onError" property.`
+                        message: 'retryOnFail is enabled but maxTries is not specified. Default is 3 attempts.'
                     });
                 }
+                if (node.waitBetweenTries !== undefined) {
+                    if (typeof node.waitBetweenTries !== 'number' || node.waitBetweenTries < 0) {
+                        result.errors.push({
+                            type: 'error',
+                            nodeId: node.id,
+                            nodeName: node.name,
+                            message: 'waitBetweenTries must be a non-negative number (milliseconds)'
+                        });
+                    }
+                    else if (node.waitBetweenTries > 300000) {
+                        result.warnings.push({
+                            type: 'warning',
+                            nodeId: node.id,
+                            nodeName: node.name,
+                            message: `waitBetweenTries is set to ${node.waitBetweenTries}ms (${(node.waitBetweenTries / 1000).toFixed(1)}s). This seems excessive.`
+                        });
+                    }
+                }
             }
-            if (node.continueOnFail && node.retryOnFail) {
+        }
+        if (node.alwaysOutputData !== undefined && typeof node.alwaysOutputData !== 'boolean') {
+            result.errors.push({
+                type: 'error',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: 'alwaysOutputData must be a boolean value'
+            });
+        }
+        const hasErrorHandling = node.onError || node.continueOnFail || node.retryOnFail;
+        if (isErrorProne && !hasErrorHandling) {
+            const nodeTypeSimple = normalizedType.split('.').pop() || normalizedType;
+            if (normalizedType.includes('httprequest')) {
                 result.warnings.push({
                     type: 'warning',
                     nodeId: node.id,
                     nodeName: node.name,
-                    message: 'Both continueOnFail and retryOnFail are enabled. The node will retry first, then continue on failure.'
-                });
-            }
-            if (node.executeOnce !== undefined && typeof node.executeOnce !== 'boolean') {
-                result.errors.push({
-                    type: 'error',
-                    nodeId: node.id,
-                    nodeName: node.name,
-                    message: 'executeOnce must be a boolean value'
+                    message: 'HTTP Request node without error handling. Consider adding "onError: \'continueRegularOutput\'" for non-critical requests or "retryOnFail: true" for transient failures.'
                 });
             }
-            if (node.disabled !== undefined && typeof node.disabled !== 'boolean') {
-                result.errors.push({
-                    type: 'error',
-                    nodeId: node.id,
-                    nodeName: node.name,
-                    message: 'disabled must be a boolean value'
-                });
-            }
-            if (node.notesInFlow !== undefined && typeof node.notesInFlow !== 'boolean') {
-                result.errors.push({
-                    type: 'error',
+            else if (normalizedType.includes('webhook')) {
+                result.warnings.push({
+                    type: 'warning',
                     nodeId: node.id,
                     nodeName: node.name,
-                    message: 'notesInFlow must be a boolean value'
+                    message: 'Webhook node without error handling. Consider adding "onError: \'continueRegularOutput\'" to prevent workflow failures from blocking webhook responses.'
                 });
             }
-            if (node.notes !== undefined && typeof node.notes !== 'string') {
-                result.errors.push({
-                    type: 'error',
+            else if (errorProneNodeTypes.some(db => normalizedType.includes(db) && ['postgres', 'mysql', 'mongodb'].includes(db))) {
+                result.warnings.push({
+                    type: 'warning',
                     nodeId: node.id,
                     nodeName: node.name,
-                    message: 'notes must be a string value'
+                    message: `Database operation without error handling. Consider adding "retryOnFail: true" for connection issues or "onError: \'continueRegularOutput\'" for non-critical queries.`
                 });
             }
-            if (node.executeOnce === true) {
+            else {
                 result.warnings.push({
                     type: 'warning',
                     nodeId: node.id,
                     nodeName: node.name,
-                    message: 'executeOnce is enabled. This node will execute only once regardless of input items.'
+                    message: `${nodeTypeSimple} node without error handling. Consider using "onError" property for better error management.`
                 });
             }
-            if ((node.continueOnFail || node.retryOnFail) && !node.alwaysOutputData) {
-                if (normalizedType.includes('httprequest') || normalizedType.includes('webhook')) {
-                    result.suggestions.push(`Consider enabling alwaysOutputData on "${node.name}" to capture error responses for debugging`);
-                }
+        }
+        if (node.continueOnFail && node.retryOnFail) {
+            result.warnings.push({
+                type: 'warning',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: 'Both continueOnFail and retryOnFail are enabled. The node will retry first, then continue on failure.'
+            });
+        }
+        if (node.executeOnce !== undefined && typeof node.executeOnce !== 'boolean') {
+            result.errors.push({
+                type: 'error',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: 'executeOnce must be a boolean value'
+            });
+        }
+        if (node.disabled !== undefined && typeof node.disabled !== 'boolean') {
+            result.errors.push({
+                type: 'error',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: 'disabled must be a boolean value'
+            });
+        }
+        if (node.notesInFlow !== undefined && typeof node.notesInFlow !== 'boolean') {
+            result.errors.push({
+                type: 'error',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: 'notesInFlow must be a boolean value'
+            });
+        }
+        if (node.notes !== undefined && typeof node.notes !== 'string') {
+            result.errors.push({
+                type: 'error',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: 'notes must be a string value'
+            });
+        }
+        if (node.executeOnce === true) {
+            result.warnings.push({
+                type: 'warning',
+                nodeId: node.id,
+                nodeName: node.name,
+                message: 'executeOnce is enabled. This node will execute only once regardless of input items.'
+            });
+        }
+        if ((node.continueOnFail || node.retryOnFail) && !node.alwaysOutputData) {
+            if (normalizedType.includes('httprequest') || normalizedType.includes('webhook')) {
+                result.suggestions.push(`Consider enabling alwaysOutputData on "${node.name}" to capture error responses for debugging`);
             }
         }
+    }
+    generateErrorHandlingSuggestions(workflow, result) {
         const nodesWithoutErrorHandling = workflow.nodes.filter(n => !n.disabled && !n.onError && !n.continueOnFail && !n.retryOnFail).length;
         if (nodesWithoutErrorHandling > 5 && workflow.nodes.length > 5) {
             result.suggestions.push('Most nodes lack error handling. Use "onError" property for modern error handling: "continueRegularOutput" (continue on error), "continueErrorOutput" (use error output), or "stopWorkflow" (stop execution).');