n8n-core 2.37.2 → 2.38.0

package/dist/execution-engine/workflow-execute.js

@@ -204,7 +204,7 @@ class WorkflowExecute {
                         taskData.metadata = { ...taskData.metadata, ...metaRunData };
                     }
                     else {
-                        di_1.Container.get(error_reporter_1.ErrorReporter).error(new n8n_workflow_1.UnexpectedError('Taskdata missing at the end of an execution'), { extra: { nodeName, index } });
+                        di_1.Container.get(error_reporter_1.ErrorReporter).error(new n8n_workflow_1.UnexpectedError('Task data missing at the end of an execution'), { extra: { nodeName, index } });
                     }
                 }
             }
@@ -799,6 +799,343 @@ class WorkflowExecute {
             this.addNodeToBeExecuted(workflow, nodeData.inputConnectionData, nodeData.parentOutputIndex, nodeData.parentNode, nodeData.parentOutputData, nodeData.runIndex, nodeData.nodeRunIndex, nodeData.metadata);
         }
     }
+    setupCancellation(onCancel, hooks, startedAt) {
+        (0, events_1.setMaxListeners)(Infinity, this.abortController.signal);
+        onCancel.shouldReject = false;
+        onCancel(() => {
+            this.status = 'canceled';
+            this.updateTaskStatusesToCancelled();
+            this.abortController.abort();
+            const fullRunData = this.getFullRunData(startedAt);
+            void hooks.runHook('workflowExecuteAfter', [fullRunData]);
+        });
+    }
+    async initializeExecution(workflow, hooks) {
+        try {
+            await workflow.expression.acquireIsolate();
+            await (0, execution_context_1.establishExecutionContext)(workflow, this.runExecutionData, this.additionalData, this.mode);
+            if (!this.additionalData.restartExecutionId) {
+                await hooks.runHook('workflowExecuteBefore', [workflow, this.runExecutionData]);
+            }
+            else {
+                await hooks.runHook('workflowExecuteResume', [workflow, this.runExecutionData]);
+            }
+        }
+        catch (error) {
+            const e = error;
+            const executionError = {
+                ...e,
+                message: e.message,
+                stack: e.stack,
+            };
+            const startItem = this.runExecutionData.executionData.nodeExecutionStack.at(0);
+            if (startItem) {
+                const taskData = {
+                    startTime: Date.now(),
+                    executionIndex: 0,
+                    executionTime: 0,
+                    data: {
+                        main: startItem.data.main,
+                    },
+                    source: [],
+                    executionStatus: 'error',
+                    hints: [],
+                };
+                this.runExecutionData.resultData = {
+                    runData: {
+                        [startItem.node.name]: [taskData],
+                    },
+                    lastNodeExecuted: startItem.node.name,
+                    error: executionError,
+                };
+            }
+            else {
+                this.runExecutionData.resultData.error = executionError;
+            }
+            throw error;
+        }
+    }
+    resetDynamicCredentialsUsage(executionData) {
+        this.additionalData.currentNodeUsedDynamicCredentials = false;
+        this.additionalData.currentNodeAttemptedDynamicCredentials = false;
+        const reportedUsage = executionData.metadata?.dynamicCredentialsUsage;
+        if (reportedUsage) {
+            (0, n8n_workflow_1.applyDynamicCredentialsUsage)(this.additionalData, reportedUsage);
+            delete executionData.metadata?.dynamicCredentialsUsage;
+        }
+    }
+    createTaskStartedData(executionData) {
+        return {
+            startTime: Date.now(),
+            executionIndex: this.additionalData.currentNodeExecutionIndex++,
+            source: !executionData.source ? [] : executionData.source.main,
+            hints: [],
+        };
+    }
+    addPairedItemLineage(executionData) {
+        const newTaskDataConnections = {};
+        for (const connectionType of Object.keys(executionData.data)) {
+            newTaskDataConnections[connectionType] = executionData.data[connectionType].map((input, inputIndex) => {
+                if (input === null) {
+                    return input;
+                }
+                return input.map((item, itemIndex) => {
+                    const sourceOverwrite = (0, node_execution_context_1.resolveSourceOverwrite)(item, executionData);
+                    if (sourceOverwrite) {
+                        return {
+                            ...item,
+                            pairedItem: {
+                                item: itemIndex,
+                                input: inputIndex || undefined,
+                                sourceOverwrite,
+                            },
+                        };
+                    }
+                    return {
+                        ...item,
+                        pairedItem: {
+                            item: itemIndex,
+                            input: inputIndex || undefined,
+                        },
+                    };
+                });
+            });
+        }
+        return newTaskDataConnections;
+    }
+    computeRunIndex(executionData) {
+        if (executionData.runIndex !== undefined) {
+            return executionData.runIndex;
+        }
+        const { runData } = this.runExecutionData.resultData;
+        const nodeName = executionData.node.name;
+        return Object.hasOwn(runData, nodeName) ? runData[nodeName].length : 0;
+    }
+    getRetryParams(executionData) {
+        const isResumedError = executionData.metadata?.resumeError !== undefined;
+        if (executionData.node.retryOnFail !== true || isResumedError) {
+            return [1, 0];
+        }
+        return [
+            Math.min(5, Math.max(2, executionData.node.maxTries || 3)),
+            Math.min(5000, Math.max(0, executionData.node.waitBetweenTries || 1000)),
+        ];
+    }
+    getPinnedOutput(node) {
+        const { pinData } = this.runExecutionData.resultData;
+        if (!pinData || node.disabled || pinData[node.name] === undefined) {
+            return undefined;
+        }
+        return [pinData[node.name]];
+    }
+    collectSubNodeResults(executionData, subNodeExecutionResults) {
+        const { subNodeExecutionData } = executionData.metadata ?? {};
+        if (!subNodeExecutionData)
+            return;
+        subNodeExecutionResults.metadata = subNodeExecutionData.metadata;
+        for (const subNode of subNodeExecutionData.actions) {
+            const nodeRunData = this.runExecutionData.resultData.runData[subNode.nodeName];
+            if (nodeRunData?.[subNode.runIndex]) {
+                subNodeExecutionResults.actionResponses.push({
+                    data: nodeRunData[subNode.runIndex],
+                    action: subNode.action,
+                });
+            }
+        }
+    }
+    async processNodeOutput(runNodeData, workflow, executionData, taskStartedData, runIndex) {
+        const converted = await (0, convert_binary_data_1.convertBinaryData)(workflow.id, this.additionalData.executionId, runNodeData, workflow.settings.binaryMode);
+        const nodeSuccessData = converted.data;
+        if (converted.hints?.length) {
+            taskStartedData.hints.push(...converted.hints);
+        }
+        if (nodeSuccessData && executionData.node.onError === 'continueErrorOutput') {
+            this.handleNodeErrorOutput(workflow, executionData, nodeSuccessData, runIndex);
+        }
+        const closeFunction = converted.closeFunction?.();
+        return { nodeSuccessData, closeFunction };
+    }
+    buildErrorReport(error) {
+        if (error instanceof n8n_workflow_1.ApplicationError) {
+            return error.cause instanceof Error ? error.cause : undefined;
+        }
+        if (error instanceof n8n_workflow_1.BaseError) {
+            return error;
+        }
+        if (!(error instanceof Error) || (0, backend_network_1.isAxiosError)(error)) {
+            return undefined;
+        }
+        const errorClass = error.name || 'Error';
+        const sanitized = new Error(errorClass);
+        sanitized.name = errorClass;
+        const frames = (error.stack ?? '').split('\n').filter((line) => /^\s+at\s/.test(line));
+        sanitized.stack = [errorClass, ...frames].join('\n');
+        return sanitized;
+    }
+    reportNodeExecutionError(error, executionNode, workflow) {
+        this.runExecutionData.resultData.lastNodeExecuted = executionNode.name;
+        const toReport = this.buildErrorReport(error);
+        if (toReport) {
+            const { executionId, instanceBaseUrl } = this.additionalData;
+            di_1.Container.get(error_reporter_1.ErrorReporter).error(toReport, {
+                extra: {
+                    nodeName: executionNode.name,
+                    nodeType: executionNode.type,
+                    nodeVersion: executionNode.typeVersion,
+                    workflowId: workflow.id,
+                    executionId,
+                    executionUrl: instanceBaseUrl && executionId
+                        ? `${instanceBaseUrl}workflow/${workflow.id}/executions/${executionId}`
+                        : undefined,
+                },
+            });
+        }
+        n8n_workflow_1.LoggerProxy.debug(`Running node "${executionNode.name}" finished with error`, {
+            node: executionNode.name,
+            workflowId: workflow.id,
+        });
+        const e = normalizeUnhandledAxiosError(error, executionNode);
+        return { ...e, message: e.message, stack: e.stack };
+    }
+    ensureAlwaysOutputData(nodeSuccessData, executionData) {
+        if (nodeSuccessData?.[0]?.[0])
+            return nodeSuccessData;
+        if (executionData.node.alwaysOutputData !== true)
+            return nodeSuccessData;
+        const pairedItem = [];
+        executionData.data.main.forEach((inputData, inputIndex) => {
+            if (!inputData) {
+                return;
+            }
+            inputData.forEach((_item, itemIndex) => {
+                pairedItem.push({ item: itemIndex, input: inputIndex });
+            });
+        });
+        nodeSuccessData ??= [];
+        nodeSuccessData[0] = [{ json: {}, pairedItem }];
+        return nodeSuccessData;
+    }
+    createTaskData(taskStartedData, executionData) {
+        return {
+            ...taskStartedData,
+            executionTime: Date.now() - taskStartedData.startTime,
+            metadata: executionData.metadata,
+            executionStatus: this.runExecutionData.waitTill ? 'waiting' : 'success',
+            usedDynamicCredentials: this.additionalData.currentNodeUsedDynamicCredentials || undefined,
+            attemptedDynamicCredentials: this.additionalData.currentNodeAttemptedDynamicCredentials || undefined,
+        };
+    }
+    recordDynamicCredentialsUser() {
+        if (this.additionalData.currentNodeUsedDynamicCredentials &&
+            this.additionalData.dynamicCredentialsResolvedUserId &&
+            this.runExecutionData.executionData?.runtimeData) {
+            this.runExecutionData.executionData.runtimeData.executedByUserId =
+                this.additionalData.dynamicCredentialsResolvedUserId;
+        }
+    }
+    async handleNodeExecutionError({ executionNode, executionData, taskData, executionError, nodeSuccessData, runIndex, hooks, }) {
+        taskData.error = executionError;
+        taskData.executionStatus = 'error';
+        await hooks?.runHook('sendChunk', [
+            {
+                type: 'error',
+                content: executionError.description,
+                metadata: {
+                    nodeId: executionNode.id,
+                    nodeName: executionNode.name,
+                    runIndex,
+                    itemIndex: 0,
+                },
+            },
+        ]);
+        const isAiToolExecution = executionNode.rewireOutputLogTo === n8n_workflow_1.NodeConnectionTypes.AiTool;
+        const aiToolDefaultsToContinue = isAiToolExecution && executionData.node.onError !== 'stopWorkflow';
+        if (this.continuesOnError(executionData.node) || aiToolDefaultsToContinue) {
+            if (isAiToolExecution) {
+                nodeSuccessData = [[{ json: { error: executionError.message } }]];
+            }
+            else if (Object.hasOwn(executionData.data, 'main') && executionData.data.main.length > 0) {
+                if (executionData.data.main[0] !== null) {
+                    nodeSuccessData = [executionData.data.main[0]];
+                }
+            }
+            return { continueExecution: true, nodeSuccessData };
+        }
+        if (executionNode.rewireOutputLogTo) {
+            taskData.inputOverride =
+                this.runExecutionData.resultData.runData[executionNode.name][runIndex]?.inputOverride || {};
+            taskData.data = {
+                [executionNode.rewireOutputLogTo]: [[{ json: { error: executionError.message } }]],
+            };
+        }
+        this.upsertTaskData(executionNode.name, runIndex, taskData);
+        this.pushExecutionStack(executionData);
+        if (!this.isCancelled) {
+            await hooks.runHook('nodeExecuteAfter', [
+                executionNode.name,
+                taskData,
+                this.runExecutionData,
+            ]);
+        }
+        return { continueExecution: false, nodeSuccessData };
+    }
+    upsertTaskData(nodeName, runIndex, taskData) {
+        const nodeRunData = this.runExecutionData.resultData.runData[nodeName];
+        if (nodeRunData[runIndex]) {
+            Object.assign(nodeRunData[runIndex], taskData);
+        }
+        else {
+            nodeRunData.push(taskData);
+        }
+    }
+    normalizeNodeErrors(nodeSuccessData) {
+        for (const execution of nodeSuccessData) {
+            for (const lineResult of execution) {
+                if (lineResult.json !== undefined &&
+                    lineResult.json.$error !== undefined &&
+                    lineResult.json.$json !== undefined) {
+                    lineResult.error = lineResult.json.$error;
+                    lineResult.json = { error: lineResult.error.message };
+                }
+                else if (lineResult.error !== undefined) {
+                    lineResult.json = { error: lineResult.error.message };
+                }
+            }
+        }
+    }
+    rewireOutputLog(executionNode, taskData, nodeSuccessData, runIndex) {
+        if (!executionNode.rewireOutputLogTo)
+            return;
+        taskData.inputOverride =
+            this.runExecutionData.resultData.runData[executionNode.name]?.[runIndex]?.inputOverride || {};
+        taskData.data = {
+            [executionNode.rewireOutputLogTo]: nodeSuccessData,
+        };
+    }
+    isExecutionStackNotEmpty() {
+        return this.runExecutionData.executionData.nodeExecutionStack.length !== 0;
+    }
+    popExecutionStack() {
+        return this.runExecutionData.executionData.nodeExecutionStack.shift();
+    }
+    pushExecutionStack(executionData) {
+        this.runExecutionData.executionData.nodeExecutionStack.unshift(executionData);
+    }
+    hasExecutionTimedOut() {
+        return (this.additionalData.executionTimeoutTimestamp !== undefined &&
+            Date.now() >= this.additionalData.executionTimeoutTimestamp);
+    }
+    shouldStopExecuting() {
+        if (this.hasExecutionTimedOut()) {
+            this.status = 'canceled';
+            this.timedOut = true;
+        }
+        return this.status === 'canceled';
+    }
+    isNodeFilteredOut(nodeName) {
+        const { runNodeFilter } = this.runExecutionData.startData;
+        return runNodeFilter !== undefined && !runNodeFilter.includes(nodeName);
+    }
     processRunExecutionData(workflow) {
         n8n_workflow_1.LoggerProxy.debug('Workflow execution started', { workflowId: workflow.id });
         const { startedAt, hooks } = this.setupExecution();
@@ -813,124 +1150,27 @@ class WorkflowExecute {
         let lastExecutionTry = '';
         let closeFunction;
         return new p_cancelable_1.default(async (resolve, _reject, onCancel) => {
-            (0, events_1.setMaxListeners)(Infinity, this.abortController.signal);
-            onCancel.shouldReject = false;
-            onCancel(() => {
-                this.status = 'canceled';
-                this.updateTaskStatusesToCancelled();
-                this.abortController.abort();
-                const fullRunData = this.getFullRunData(startedAt);
-                void hooks.runHook('workflowExecuteAfter', [fullRunData]);
-            });
+            this.setupCancellation(onCancel, hooks, startedAt);
             const returnPromise = (async () => {
-                try {
-                    await workflow.expression.acquireIsolate();
-                    await (0, execution_context_1.establishExecutionContext)(workflow, this.runExecutionData, this.additionalData, this.mode);
-                    if (!this.additionalData.restartExecutionId) {
-                        await hooks.runHook('workflowExecuteBefore', [workflow, this.runExecutionData]);
-                    }
-                    else {
-                        await hooks.runHook('workflowExecuteResume', [workflow, this.runExecutionData]);
-                    }
-                }
-                catch (error) {
-                    const e = error;
-                    executionError = {
-                        ...e,
-                        message: e.message,
-                        stack: e.stack,
-                    };
-                    executionData = this.runExecutionData.executionData.nodeExecutionStack[0];
-                    const taskData = {
-                        startTime: Date.now(),
-                        executionIndex: 0,
-                        executionTime: 0,
-                        data: {
-                            main: executionData.data.main,
-                        },
-                        source: [],
-                        executionStatus: 'error',
-                        hints: [],
-                    };
-                    this.runExecutionData.resultData = {
-                        runData: {
-                            [executionData.node.name]: [taskData],
-                        },
-                        lastNodeExecuted: executionData.node.name,
-                        error: executionError,
-                    };
-                    throw error;
-                }
-                executionLoop: while (this.runExecutionData.executionData.nodeExecutionStack.length !== 0) {
-                    if (this.additionalData.executionTimeoutTimestamp !== undefined &&
-                        Date.now() >= this.additionalData.executionTimeoutTimestamp) {
-                        this.status = 'canceled';
-                        this.timedOut = true;
-                    }
-                    if (this.status === 'canceled') {
+                await this.initializeExecution(workflow, hooks);
+                executionLoop: while (this.isExecutionStackNotEmpty()) {
+                    if (this.shouldStopExecuting()) {
                         return;
                     }
                     subNodeExecutionResults = (0, requests_response_1.makeEngineResponse)();
                     let nodeSuccessData = null;
                     executionError = undefined;
-                    executionData =
-                        this.runExecutionData.executionData.nodeExecutionStack.shift();
+                    executionData = this.popExecutionStack();
                     executionNode = executionData.node;
-                    this.additionalData.currentNodeUsedDynamicCredentials = false;
-                    this.additionalData.currentNodeAttemptedDynamicCredentials = false;
-                    const reportedUsage = executionData.metadata?.dynamicCredentialsUsage;
-                    if (reportedUsage) {
-                        (0, n8n_workflow_1.applyDynamicCredentialsUsage)(this.additionalData, reportedUsage);
-                        delete executionData.metadata?.dynamicCredentialsUsage;
-                    }
-                    const taskStartedData = {
-                        startTime: Date.now(),
-                        executionIndex: this.additionalData.currentNodeExecutionIndex++,
-                        source: !executionData.source ? [] : executionData.source.main,
-                        hints: [],
-                    };
-                    const newTaskDataConnections = {};
-                    for (const connectionType of Object.keys(executionData.data)) {
-                        newTaskDataConnections[connectionType] = executionData.data[connectionType].map((input, inputIndex) => {
-                            if (input === null) {
-                                return input;
-                            }
-                            return input.map((item, itemIndex) => {
-                                const sourceOverwrite = (0, node_execution_context_1.resolveSourceOverwrite)(item, executionData);
-                                if (sourceOverwrite) {
-                                    return {
-                                        ...item,
-                                        pairedItem: {
-                                            item: itemIndex,
-                                            input: inputIndex || undefined,
-                                            sourceOverwrite,
-                                        },
-                                    };
-                                }
-                                return {
-                                    ...item,
-                                    pairedItem: {
-                                        item: itemIndex,
-                                        input: inputIndex || undefined,
-                                    },
-                                };
-                            });
-                        });
-                    }
-                    executionData.data = newTaskDataConnections;
-                    runIndex = 0;
-                    if (executionData.runIndex !== undefined) {
-                        runIndex = executionData.runIndex;
-                    }
-                    else if (Object.hasOwn(this.runExecutionData.resultData.runData, executionNode.name)) {
-                        runIndex = this.runExecutionData.resultData.runData[executionNode.name].length;
-                    }
+                    this.resetDynamicCredentialsUsage(executionData);
+                    const taskStartedData = this.createTaskStartedData(executionData);
+                    executionData.data = this.addPairedItemLineage(executionData);
+                    runIndex = this.computeRunIndex(executionData);
                     currentExecutionTry = `${executionNode.name}:${runIndex}`;
                     if (currentExecutionTry === lastExecutionTry) {
                         throw new n8n_workflow_1.UserError('Stopped execution because it seems to be in an endless loop');
                     }
-                    if (this.runExecutionData.startData.runNodeFilter !== undefined &&
-                        this.runExecutionData.startData.runNodeFilter.indexOf(executionNode.name) === -1) {
+                    if (this.isNodeFilteredOut(executionNode.name)) {
                         continue;
                     }
                     const hasInputData = this.ensureInputData(workflow, executionNode, executionData);
@@ -945,17 +1185,9 @@ class WorkflowExecute {
                     if (!executionData.metadata?.nodeWasResumed) {
                         await hooks.runHook('nodeExecuteBefore', [executionNode.name, taskStartedData]);
                     }
-                    let maxTries = 1;
                     const isErrorValue = (v) => v !== undefined && v !== null && v !== false;
                     const checkFailure = (data) => !(0, requests_response_1.isEngineRequest)(data) && isErrorValue(data.data?.[0]?.[0]?.json?.error);
-                    const isResumedError = executionData.metadata?.resumeError !== undefined;
-                    if (executionData.node.retryOnFail === true && !isResumedError) {
-                        maxTries = Math.min(5, Math.max(2, executionData.node.maxTries || 3));
-                    }
-                    let waitBetweenTries = 0;
-                    if (executionData.node.retryOnFail === true && !isResumedError) {
-                        waitBetweenTries = Math.min(5000, Math.max(0, executionData.node.waitBetweenTries || 1000));
-                    }
+                    const [maxTries, waitBetweenTries] = this.getRetryParams(executionData);
                     for (let tryIndex = 0; tryIndex < maxTries; tryIndex++) {
                         try {
                             if (tryIndex !== 0) {
@@ -968,26 +1200,12 @@ class WorkflowExecute {
                                     });
                                 }
                             }
-                            const { pinData } = this.runExecutionData.resultData;
-                            if (pinData && !executionNode.disabled && pinData[executionNode.name] !== undefined) {
-                                const nodePinData = pinData[executionNode.name];
-                                nodeSuccessData = [nodePinData];
+                            const pinnedOutput = this.getPinnedOutput(executionNode);
+                            if (pinnedOutput) {
+                                nodeSuccessData = pinnedOutput;
                             }
                             else {
-                                if (executionData.metadata?.subNodeExecutionData) {
-                                    subNodeExecutionResults.metadata =
-                                        executionData.metadata.subNodeExecutionData.metadata;
-                                    for (const subNode of executionData.metadata.subNodeExecutionData.actions) {
-                                        const nodeRunData = this.runExecutionData.resultData.runData[subNode.nodeName];
-                                        if (nodeRunData && nodeRunData[subNode.runIndex]) {
-                                            const data = nodeRunData[subNode.runIndex];
-                                            subNodeExecutionResults.actionResponses.push({
-                                                data,
-                                                action: subNode.action,
-                                            });
-                                        }
-                                    }
-                                }
+                                this.collectSubNodeResults(executionData, subNodeExecutionResults);
                                 n8n_workflow_1.LoggerProxy.debug(`Running node "${executionNode.name}" started`, {
                                     node: executionNode.name,
                                     workflowId: workflow.id,
@@ -1011,17 +1229,9 @@ class WorkflowExecute {
                                     });
                                     continue executionLoop;
                                 }
-                                runNodeData = await (0, convert_binary_data_1.convertBinaryData)(workflow.id, this.additionalData.executionId, runNodeData, workflow.settings.binaryMode);
-                                nodeSuccessData = runNodeData.data;
-                                if (runNodeData.hints?.length) {
-                                    taskStartedData.hints.push.apply(taskStartedData.hints, runNodeData.hints);
-                                }
-                                if (nodeSuccessData && executionData.node.onError === 'continueErrorOutput') {
-                                    this.handleNodeErrorOutput(workflow, executionData, nodeSuccessData, runIndex);
-                                }
-                                if (runNodeData.closeFunction) {
-                                    closeFunction = runNodeData.closeFunction();
-                                }
+                                const nodeOutput = await this.processNodeOutput(runNodeData, workflow, executionData, taskStartedData, runIndex);
+                                nodeSuccessData = nodeOutput.nodeSuccessData;
+                                closeFunction = nodeOutput.closeFunction ?? closeFunction;
                             }
                             n8n_workflow_1.LoggerProxy.debug(`Running node "${executionNode.name}" finished successfully`, {
                                 node: executionNode.name,
@@ -1031,193 +1241,49 @@ class WorkflowExecute {
                             if (nodeSuccessData) {
                                 this.runExecutionData.resultData.lastNodeExecuted = executionData.node.name;
                             }
-                            if (!nodeSuccessData?.[0]?.[0]) {
-                                if (executionData.node.alwaysOutputData === true) {
-                                    const pairedItem = [];
-                                    executionData.data.main.forEach((inputData, inputIndex) => {
-                                        if (!inputData) {
-                                            return;
-                                        }
-                                        inputData.forEach((_item, itemIndex) => {
-                                            pairedItem.push({
-                                                item: itemIndex,
-                                                input: inputIndex,
-                                            });
-                                        });
-                                    });
-                                    nodeSuccessData ??= [];
-                                    nodeSuccessData[0] = [
-                                        {
-                                            json: {},
-                                            pairedItem,
-                                        },
-                                    ];
-                                }
-                            }
+                            nodeSuccessData = this.ensureAlwaysOutputData(nodeSuccessData, executionData);
                             if (nodeSuccessData === null && !this.runExecutionData.waitTill) {
                                 continue executionLoop;
                             }
                             break;
                         }
                         catch (error) {
-                            this.runExecutionData.resultData.lastNodeExecuted = executionData.node.name;
-                            let toReport;
-                            if (error instanceof n8n_workflow_1.ApplicationError) {
-                                if (error.cause instanceof Error)
-                                    toReport = error.cause;
-                            }
-                            else if (error instanceof n8n_workflow_1.BaseError) {
-                                toReport = error;
-                            }
-                            else if (error instanceof Error && !(0, backend_network_1.isAxiosError)(error)) {
-                                const errorClass = error.name || 'Error';
-                                const sanitized = new Error(errorClass);
-                                sanitized.name = errorClass;
-                                const frames = (error.stack ?? '')
-                                    .split('\n')
-                                    .filter((line) => /^\s+at\s/.test(line));
-                                sanitized.stack = [errorClass, ...frames].join('\n');
-                                toReport = sanitized;
-                            }
-                            if (toReport) {
-                                const { executionId, instanceBaseUrl } = this.additionalData;
-                                di_1.Container.get(error_reporter_1.ErrorReporter).error(toReport, {
-                                    extra: {
-                                        nodeName: executionNode.name,
-                                        nodeType: executionNode.type,
-                                        nodeVersion: executionNode.typeVersion,
-                                        workflowId: workflow.id,
-                                        executionId,
-                                        executionUrl: instanceBaseUrl && executionId
-                                            ? `${instanceBaseUrl}workflow/${workflow.id}/executions/${executionId}`
-                                            : undefined,
-                                    },
-                                });
-                            }
-                            const e = normalizeUnhandledAxiosError(error, executionNode);
-                            executionError = { ...e, message: e.message, stack: e.stack };
-                            n8n_workflow_1.LoggerProxy.debug(`Running node "${executionNode.name}" finished with error`, {
-                                node: executionNode.name,
-                                workflowId: workflow.id,
-                            });
+                            executionError = this.reportNodeExecutionError(error, executionNode, workflow);
                         }
                     }
                     if (!Object.hasOwn(this.runExecutionData.resultData.runData, executionNode.name)) {
                         this.runExecutionData.resultData.runData[executionNode.name] = [];
                     }
-                    const taskData = {
-                        ...taskStartedData,
-                        executionTime: Date.now() - taskStartedData.startTime,
-                        metadata: executionData.metadata,
-                        executionStatus: this.runExecutionData.waitTill ? 'waiting' : 'success',
-                        usedDynamicCredentials: this.additionalData.currentNodeUsedDynamicCredentials || undefined,
-                        attemptedDynamicCredentials: this.additionalData.currentNodeAttemptedDynamicCredentials || undefined,
-                    };
-                    if (this.additionalData.currentNodeUsedDynamicCredentials &&
-                        this.additionalData.dynamicCredentialsResolvedUserId &&
-                        this.runExecutionData.executionData?.runtimeData) {
-                        this.runExecutionData.executionData.runtimeData.executedByUserId =
-                            this.additionalData.dynamicCredentialsResolvedUserId;
-                    }
+                    const taskData = this.createTaskData(taskStartedData, executionData);
+                    this.recordDynamicCredentialsUser();
                     if (executionError !== undefined) {
-                        taskData.error = executionError;
-                        taskData.executionStatus = 'error';
-                        await hooks?.runHook('sendChunk', [
-                            {
-                                type: 'error',
-                                content: executionError.description,
-                                metadata: {
-                                    nodeId: executionNode.id,
-                                    nodeName: executionNode.name,
-                                    runIndex,
-                                    itemIndex: 0,
-                                },
-                            },
-                        ]);
-                        const isAiToolExecution = executionNode.rewireOutputLogTo === n8n_workflow_1.NodeConnectionTypes.AiTool;
-                        const aiToolDefaultsToContinue = isAiToolExecution && executionData.node.onError !== 'stopWorkflow';
-                        if (this.continuesOnError(executionData.node) || aiToolDefaultsToContinue) {
-                            if (isAiToolExecution) {
-                                nodeSuccessData = [[{ json: { error: executionError.message } }]];
-                            }
-                            else if (Object.hasOwn(executionData.data, 'main') &&
-                                executionData.data.main.length > 0) {
-                                if (executionData.data.main[0] !== null) {
-                                    nodeSuccessData = [executionData.data.main[0]];
-                                }
-                            }
-                        }
-                        else {
-                            if (executionNode.rewireOutputLogTo) {
-                                taskData.inputOverride =
-                                    this.runExecutionData.resultData.runData[executionNode.name][runIndex]
-                                        ?.inputOverride || {};
-                                taskData.data = {
-                                    [executionNode.rewireOutputLogTo]: [
-                                        [{ json: { error: executionError.message } }],
-                                    ],
-                                };
-                            }
-                            const errorRunDataExists = !!this.runExecutionData.resultData.runData[executionNode.name][runIndex];
-                            if (errorRunDataExists) {
-                                const currentTaskData = this.runExecutionData.resultData.runData[executionNode.name][runIndex];
-                                Object.assign(currentTaskData, taskData);
-                            }
-                            else {
-                                this.runExecutionData.resultData.runData[executionNode.name].push(taskData);
-                            }
-                            this.runExecutionData.executionData.nodeExecutionStack.unshift(executionData);
-                            if (!this.isCancelled) {
-                                await hooks.runHook('nodeExecuteAfter', [
-                                    executionNode.name,
-                                    taskData,
-                                    this.runExecutionData,
-                                ]);
-                            }
+                        const outcome = await this.handleNodeExecutionError({
+                            executionNode,
+                            executionData,
+                            taskData,
+                            executionError,
+                            nodeSuccessData,
+                            runIndex,
+                            hooks,
+                        });
+                        nodeSuccessData = outcome.nodeSuccessData;
+                        if (!outcome.continueExecution) {
                             break;
                         }
                     }
-                    for (const execution of nodeSuccessData) {
-                        for (const lineResult of execution) {
-                            if (lineResult.json !== undefined &&
-                                lineResult.json.$error !== undefined &&
-                                lineResult.json.$json !== undefined) {
-                                lineResult.error = lineResult.json.$error;
-                                lineResult.json = {
-                                    error: lineResult.json.$error.message,
-                                };
-                            }
-                            else if (lineResult.error !== undefined) {
-                                lineResult.json = { error: lineResult.error.message };
-                            }
-                        }
-                    }
+                    this.normalizeNodeErrors(nodeSuccessData);
                     taskData.data = {
                         main: nodeSuccessData,
                     };
-                    if (executionNode.rewireOutputLogTo) {
-                        taskData.inputOverride =
-                            this.runExecutionData.resultData.runData[executionNode.name]?.[runIndex]
-                                ?.inputOverride || {};
-                        taskData.data = {
-                            [executionNode.rewireOutputLogTo]: nodeSuccessData,
-                        };
-                    }
-                    const runDataAlreadyExists = !!this.runExecutionData.resultData.runData[executionNode.name][runIndex];
-                    if (runDataAlreadyExists) {
-                        const currentTaskData = this.runExecutionData.resultData.runData[executionNode.name][runIndex];
-                        Object.assign(currentTaskData, taskData);
-                    }
-                    else {
-                        this.runExecutionData.resultData.runData[executionNode.name].push(taskData);
-                    }
+                    this.rewireOutputLog(executionNode, taskData, nodeSuccessData, runIndex);
+                    this.upsertTaskData(executionNode.name, runIndex, taskData);
                     if (this.runExecutionData.waitTill) {
                         await hooks.runHook('nodeExecuteAfter', [
                             executionNode.name,
                             taskData,
                             this.runExecutionData,
                         ]);
-                        this.runExecutionData.executionData.nodeExecutionStack.unshift(executionData);
+                        this.pushExecutionStack(executionData);
                         break;
                     }
                     if (this.runExecutionData?.startData?.destinationNode?.nodeName === executionNode.name) {