n8n-core 1.72.1 → 1.74.0

package/dist/WorkflowExecute.js

@@ -37,14 +37,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowExecute = void 0;
+const di_1 = require("@n8n/di");
 const assert = __importStar(require("assert/strict"));
 const events_1 = require("events");
 const lodash_1 = require("lodash");
 const get_1 = __importDefault(require("lodash/get"));
 const n8n_workflow_1 = require("n8n-workflow");
 const p_cancelable_1 = __importDefault(require("p-cancelable"));
+const error_reporter_1 = require("./error-reporter");
+const node_execution_context_1 = require("./node-execution-context");
 const NodeExecuteFunctions = __importStar(require("./NodeExecuteFunctions"));
 const PartialExecutionUtils_1 = require("./PartialExecutionUtils");
+const RoutingNode_1 = require("./RoutingNode");
+const TriggersAndPollers_1 = require("./TriggersAndPollers");
 class WorkflowExecute {
     constructor(additionalData, mode, runExecutionData = {
         startData: {},
@@ -304,18 +309,16 @@ class WorkflowExecute {
         return true;
     }
     prepareWaitingToExecution(nodeName, numberOfConnections, runIndex) {
-        if (!this.runExecutionData.executionData.waitingExecutionSource) {
-            this.runExecutionData.executionData.waitingExecutionSource = {};
-        }
-        this.runExecutionData.executionData.waitingExecution[nodeName][runIndex] = {
-            main: [],
-        };
-        this.runExecutionData.executionData.waitingExecutionSource[nodeName][runIndex] = {
-            main: [],
-        };
+        const executionData = this.runExecutionData.executionData;
+        executionData.waitingExecution ??= {};
+        executionData.waitingExecutionSource ??= {};
+        const nodeWaiting = (executionData.waitingExecution[nodeName] ??= []);
+        const nodeWaitingSource = (executionData.waitingExecutionSource[nodeName] ??= []);
+        nodeWaiting[runIndex] = { main: [] };
+        nodeWaitingSource[runIndex] = { main: [] };
         for (let i = 0; i < numberOfConnections; i++) {
-            this.runExecutionData.executionData.waitingExecution[nodeName][runIndex].main.push(null);
-            this.runExecutionData.executionData.waitingExecutionSource[nodeName][runIndex].main.push(null);
+            nodeWaiting[runIndex].main.push(null);
+            nodeWaitingSource[runIndex].main.push(null);
         }
     }
     addNodeToBeExecuted(workflow, connectionData, outputIndex, parentNodeName, nodeSuccessData, runIndex) {
@@ -536,6 +539,151 @@ class WorkflowExecute {
             });
         }
     }
+    checkReadyForExecution(workflow, inputData = {}) {
+        const workflowIssues = {};
+        let checkNodes = [];
+        if (inputData.destinationNode) {
+            checkNodes = workflow.getParentNodes(inputData.destinationNode);
+            checkNodes.push(inputData.destinationNode);
+        }
+        else if (inputData.startNode) {
+            checkNodes = workflow.getChildNodes(inputData.startNode);
+            checkNodes.push(inputData.startNode);
+        }
+        for (const nodeName of checkNodes) {
+            let nodeIssues = null;
+            const node = workflow.nodes[nodeName];
+            if (node.disabled === true) {
+                continue;
+            }
+            const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+            if (nodeType === undefined) {
+                nodeIssues = {
+                    typeUnknown: true,
+                };
+            }
+            else {
+                nodeIssues = n8n_workflow_1.NodeHelpers.getNodeParametersIssues(nodeType.description.properties, node, inputData.pinDataNodeNames);
+            }
+            if (nodeIssues !== null) {
+                workflowIssues[node.name] = nodeIssues;
+            }
+        }
+        if (Object.keys(workflowIssues).length === 0) {
+            return null;
+        }
+        return workflowIssues;
+    }
+    async runNode(workflow, executionData, runExecutionData, runIndex, additionalData, mode, abortSignal) {
+        const { node } = executionData;
+        let inputData = executionData.data;
+        if (node.disabled === true) {
+            if (inputData.hasOwnProperty('main') && inputData.main.length > 0) {
+                if (inputData.main[0] === null) {
+                    return { data: undefined };
+                }
+                return { data: [inputData.main[0]] };
+            }
+            return { data: undefined };
+        }
+        const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+        let connectionInputData = [];
+        if (nodeType.execute || (!nodeType.poll && !nodeType.trigger && !nodeType.webhook)) {
+            if (inputData.main?.length > 0) {
+                connectionInputData = inputData.main[0];
+            }
+            const forceInputNodeExecution = workflow.settings.executionOrder !== 'v1';
+            if (!forceInputNodeExecution) {
+                for (const mainData of inputData.main) {
+                    if (mainData?.length) {
+                        connectionInputData = mainData;
+                        break;
+                    }
+                }
+            }
+            if (connectionInputData.length === 0) {
+                return { data: undefined };
+            }
+        }
+        if (runExecutionData.resultData.lastNodeExecuted === node.name &&
+            runExecutionData.resultData.error !== undefined) {
+            if (runExecutionData.resultData.error.name === 'NodeOperationError' ||
+                runExecutionData.resultData.error.name === 'NodeApiError') {
+                throw runExecutionData.resultData.error;
+            }
+            const error = new Error(runExecutionData.resultData.error.message);
+            error.stack = runExecutionData.resultData.error.stack;
+            throw error;
+        }
+        if (node.executeOnce === true) {
+            const newInputData = {};
+            for (const connectionType of Object.keys(inputData)) {
+                newInputData[connectionType] = inputData[connectionType].map((input) => {
+                    return input && input.slice(0, 1);
+                });
+            }
+            inputData = newInputData;
+        }
+        if (nodeType.execute) {
+            const closeFunctions = [];
+            const context = new node_execution_context_1.ExecuteContext(workflow, node, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData, closeFunctions, abortSignal);
+            const data = nodeType instanceof n8n_workflow_1.Node
+                ? await nodeType.execute(context)
+                : await nodeType.execute.call(context);
+            const closeFunctionsResults = await Promise.allSettled(closeFunctions.map(async (fn) => await fn()));
+            const closingErrors = closeFunctionsResults
+                .filter((result) => result.status === 'rejected')
+                .map((result) => result.reason);
+            if (closingErrors.length > 0) {
+                if (closingErrors[0] instanceof Error)
+                    throw closingErrors[0];
+                throw new n8n_workflow_1.ApplicationError("Error on execution node's close function(s)", {
+                    extra: { nodeName: node.name },
+                    tags: { nodeType: node.type },
+                    cause: closingErrors,
+                });
+            }
+            return { data };
+        }
+        else if (nodeType.poll) {
+            if (mode === 'manual') {
+                const context = new node_execution_context_1.PollContext(workflow, node, additionalData, mode, 'manual');
+                return { data: await nodeType.poll.call(context) };
+            }
+            return { data: inputData.main };
+        }
+        else if (nodeType.trigger) {
+            if (mode === 'manual') {
+                const triggerResponse = await di_1.Container.get(TriggersAndPollers_1.TriggersAndPollers).runTrigger(workflow, node, NodeExecuteFunctions.getExecuteTriggerFunctions, additionalData, mode, 'manual');
+                if (triggerResponse === undefined) {
+                    return { data: null };
+                }
+                let closeFunction;
+                if (triggerResponse.closeFunction) {
+                    closeFunction = triggerResponse.closeFunction;
+                    abortSignal?.addEventListener('abort', closeFunction);
+                }
+                if (triggerResponse.manualTriggerFunction !== undefined) {
+                    await triggerResponse.manualTriggerFunction();
+                }
+                const response = await triggerResponse.manualTriggerResponse;
+                if (response.length === 0) {
+                    return { data: null, closeFunction };
+                }
+                return { data: response, closeFunction };
+            }
+            return { data: inputData.main };
+        }
+        else if (nodeType.webhook) {
+            return { data: inputData.main };
+        }
+        else {
+            const routingNode = new RoutingNode_1.RoutingNode(workflow, node, connectionInputData, runExecutionData ?? null, additionalData, mode);
+            return {
+                data: await routingNode.runNode(inputData, runIndex, nodeType, executionData, undefined, abortSignal),
+            };
+        }
+    }
     processRunExecutionData(workflow) {
         n8n_workflow_1.LoggerProxy.debug('Workflow execution started', { workflowId: workflow.id });
         const startedAt = new Date();
@@ -547,13 +695,13 @@ class WorkflowExecute {
             destinationNode = this.runExecutionData.startData.destinationNode;
         }
         const pinDataNodeNames = Object.keys(this.runExecutionData.resultData.pinData ?? {});
-        const workflowIssues = workflow.checkReadyForExecution({
+        const workflowIssues = this.checkReadyForExecution(workflow, {
             startNode,
             destinationNode,
             pinDataNodeNames,
         });
         if (workflowIssues !== null) {
-            throw new n8n_workflow_1.WorkflowOperationError('The workflow has issues and can for that reason not be executed. Please fix them first.');
+            throw new n8n_workflow_1.WorkflowOperationError('The workflow has issues and cannot be executed for that reason. Please fix them first.');
         }
         let executionData;
         let executionError;
@@ -721,12 +869,12 @@ class WorkflowExecute {
                                     node: executionNode.name,
                                     workflowId: workflow.id,
                                 });
-                                let runNodeData = await workflow.runNode(executionData, this.runExecutionData, runIndex, this.additionalData, NodeExecuteFunctions, this.mode, this.abortController.signal);
+                                let runNodeData = await this.runNode(workflow, executionData, this.runExecutionData, runIndex, this.additionalData, this.mode, this.abortController.signal);
                                 nodeSuccessData = runNodeData.data;
                                 const didContinueOnFail = nodeSuccessData?.at(0)?.at(0)?.json?.error !== undefined;
                                 while (didContinueOnFail && tryIndex !== maxTries - 1) {
                                     await (0, n8n_workflow_1.sleep)(waitBetweenTries);
-                                    runNodeData = await workflow.runNode(executionData, this.runExecutionData, runIndex, this.additionalData, NodeExecuteFunctions, this.mode, this.abortController.signal);
+                                    runNodeData = await this.runNode(workflow, executionData, this.runExecutionData, runIndex, this.additionalData, this.mode, this.abortController.signal);
                                     tryIndex++;
                                 }
                                 if (nodeSuccessData instanceof n8n_workflow_1.NodeExecutionOutput) {
@@ -734,71 +882,7 @@ class WorkflowExecute {
                                     executionHints.push(...hints);
                                 }
                                 if (nodeSuccessData && executionData.node.onError === 'continueErrorOutput') {
-                                    const nodeType = workflow.nodeTypes.getByNameAndVersion(executionData.node.type, executionData.node.typeVersion);
-                                    const outputs = n8n_workflow_1.NodeHelpers.getNodeOutputs(workflow, executionData.node, nodeType.description);
-                                    const outputTypes = n8n_workflow_1.NodeHelpers.getConnectionTypes(outputs);
-                                    const mainOutputTypes = outputTypes.filter((output) => output === "main");
-                                    const errorItems = [];
-                                    const closeFunctions = [];
-                                    const executeFunctions = NodeExecuteFunctions.getExecuteFunctions(workflow, this.runExecutionData, runIndex, [], executionData.data, executionData.node, this.additionalData, executionData, this.mode, closeFunctions, this.abortController.signal);
-                                    const dataProxy = executeFunctions.getWorkflowDataProxy(0);
-                                    for (let outputIndex = 0; outputIndex < mainOutputTypes.length - 1; outputIndex++) {
-                                        const successItems = [];
-                                        const items = nodeSuccessData[outputIndex]?.length
-                                            ? nodeSuccessData[outputIndex]
-                                            : [];
-                                        while (items.length) {
-                                            const item = items.shift();
-                                            if (item === undefined) {
-                                                continue;
-                                            }
-                                            let errorData;
-                                            if (item.error) {
-                                                errorData = item.error;
-                                                item.error = undefined;
-                                            }
-                                            else if (item.json.error && Object.keys(item.json).length === 1) {
-                                                errorData = item.json.error;
-                                            }
-                                            else if (item.json.error &&
-                                                item.json.message &&
-                                                Object.keys(item.json).length === 2) {
-                                                errorData = item.json.error;
-                                            }
-                                            if (errorData) {
-                                                const pairedItemData = item.pairedItem && typeof item.pairedItem === 'object'
-                                                    ? Array.isArray(item.pairedItem)
-                                                        ? item.pairedItem[0]
-                                                        : item.pairedItem
-                                                    : undefined;
-                                                if (executionData.source === null || pairedItemData === undefined) {
-                                                    errorItems.push(item);
-                                                }
-                                                else {
-                                                    const pairedItemInputIndex = pairedItemData.input || 0;
-                                                    const sourceData = executionData.source["main"][pairedItemInputIndex];
-                                                    const constPairedItem = dataProxy.$getPairedItem(sourceData.previousNode, sourceData, pairedItemData);
-                                                    if (constPairedItem === null) {
-                                                        errorItems.push(item);
-                                                    }
-                                                    else {
-                                                        errorItems.push({
-                                                            ...item,
-                                                            json: {
-                                                                ...constPairedItem.json,
-                                                                ...item.json,
-                                                            },
-                                                        });
-                                                    }
-                                                }
-                                            }
-                                            else {
-                                                successItems.push(item);
-                                            }
-                                        }
-                                        nodeSuccessData[outputIndex] = successItems;
-                                    }
-                                    nodeSuccessData[mainOutputTypes.length - 1] = errorItems;
+                                    this.handleNodeErrorOutput(workflow, executionData, nodeSuccessData, runIndex);
                                 }
                                 if (runNodeData.closeFunction) {
                                     closeFunction = runNodeData.closeFunction();
@@ -808,40 +892,7 @@ class WorkflowExecute {
                                 node: executionNode.name,
                                 workflowId: workflow.id,
                             });
-                            if (nodeSuccessData?.length) {
-                                const isSingleInputAndOutput = executionData.data.main.length === 1 && executionData.data.main[0]?.length === 1;
-                                const isSameNumberOfItems = nodeSuccessData.length === 1 &&
-                                    executionData.data.main.length === 1 &&
-                                    executionData.data.main[0]?.length === nodeSuccessData[0].length;
-                                checkOutputData: for (const outputData of nodeSuccessData) {
-                                    if (outputData === null) {
-                                        continue;
-                                    }
-                                    for (const [index, item] of outputData.entries()) {
-                                        if (item.pairedItem === undefined) {
-                                            if (isSingleInputAndOutput) {
-                                                item.pairedItem = {
-                                                    item: 0,
-                                                };
-                                            }
-                                            else if (isSameNumberOfItems) {
-                                                item.pairedItem = {
-                                                    item: index,
-                                                };
-                                            }
-                                            else {
-                                                break checkOutputData;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            if (nodeSuccessData === undefined) {
-                                nodeSuccessData = null;
-                            }
-                            else {
-                                this.runExecutionData.resultData.lastNodeExecuted = executionData.node.name;
-                            }
+                            nodeSuccessData = this.assignPairedItems(nodeSuccessData, executionData);
                             if (nodeSuccessData === null || nodeSuccessData[0][0] === undefined) {
                                 if (executionData.node.alwaysOutputData === true) {
                                     const pairedItem = [];
@@ -881,7 +932,7 @@ class WorkflowExecute {
                                 toReport = error;
                             }
                             if (toReport) {
-                                n8n_workflow_1.ErrorReporterProxy.error(toReport, {
+                                di_1.Container.get(error_reporter_1.ErrorReporter).error(toReport, {
                                     extra: {
                                         nodeName: executionNode.name,
                                         nodeType: executionNode.type,
@@ -1204,14 +1255,113 @@ class WorkflowExecute {
         return fullRunData;
     }
     getFullRunData(startedAt) {
-        const fullRunData = {
+        return {
             data: this.runExecutionData,
             mode: this.mode,
             startedAt,
             stoppedAt: new Date(),
             status: this.status,
         };
-        return fullRunData;
+    }
+    handleNodeErrorOutput(workflow, executionData, nodeSuccessData, runIndex) {
+        const nodeType = workflow.nodeTypes.getByNameAndVersion(executionData.node.type, executionData.node.typeVersion);
+        const outputs = n8n_workflow_1.NodeHelpers.getNodeOutputs(workflow, executionData.node, nodeType.description);
+        const outputTypes = n8n_workflow_1.NodeHelpers.getConnectionTypes(outputs);
+        const mainOutputTypes = outputTypes.filter((output) => output === "main");
+        const errorItems = [];
+        const closeFunctions = [];
+        const executeFunctions = new node_execution_context_1.ExecuteContext(workflow, executionData.node, this.additionalData, this.mode, this.runExecutionData, runIndex, [], executionData.data, executionData, closeFunctions, this.abortController.signal);
+        const dataProxy = executeFunctions.getWorkflowDataProxy(0);
+        for (let outputIndex = 0; outputIndex < mainOutputTypes.length - 1; outputIndex++) {
+            const successItems = [];
+            const items = nodeSuccessData[outputIndex]?.length ? nodeSuccessData[outputIndex] : [];
+            while (items.length) {
+                const item = items.shift();
+                if (item === undefined) {
+                    continue;
+                }
+                let errorData;
+                if (item.error) {
+                    errorData = item.error;
+                    item.error = undefined;
+                }
+                else if (item.json.error && Object.keys(item.json).length === 1) {
+                    errorData = item.json.error;
+                }
+                else if (item.json.error && item.json.message && Object.keys(item.json).length === 2) {
+                    errorData = item.json.error;
+                }
+                if (errorData) {
+                    const pairedItemData = item.pairedItem && typeof item.pairedItem === 'object'
+                        ? Array.isArray(item.pairedItem)
+                            ? item.pairedItem[0]
+                            : item.pairedItem
+                        : undefined;
+                    if (executionData.source === null || pairedItemData === undefined) {
+                        errorItems.push(item);
+                    }
+                    else {
+                        const pairedItemInputIndex = pairedItemData.input || 0;
+                        const sourceData = executionData.source["main"][pairedItemInputIndex];
+                        const constPairedItem = dataProxy.$getPairedItem(sourceData.previousNode, sourceData, pairedItemData);
+                        if (constPairedItem === null) {
+                            errorItems.push(item);
+                        }
+                        else {
+                            errorItems.push({
+                                ...item,
+                                json: {
+                                    ...constPairedItem.json,
+                                    ...item.json,
+                                },
+                            });
+                        }
+                    }
+                }
+                else {
+                    successItems.push(item);
+                }
+            }
+            nodeSuccessData[outputIndex] = successItems;
+        }
+        nodeSuccessData[mainOutputTypes.length - 1] = errorItems;
+    }
+    assignPairedItems(nodeSuccessData, executionData) {
+        if (nodeSuccessData?.length) {
+            const isSingleInputAndOutput = executionData.data.main.length === 1 && executionData.data.main[0]?.length === 1;
+            const isSameNumberOfItems = nodeSuccessData.length === 1 &&
+                executionData.data.main.length === 1 &&
+                executionData.data.main[0]?.length === nodeSuccessData[0].length;
+            checkOutputData: for (const outputData of nodeSuccessData) {
+                if (outputData === null) {
+                    continue;
+                }
+                for (const [index, item] of outputData.entries()) {
+                    if (item.pairedItem === undefined) {
+                        if (isSingleInputAndOutput) {
+                            item.pairedItem = {
+                                item: 0,
+                            };
+                        }
+                        else if (isSameNumberOfItems) {
+                            item.pairedItem = {
+                                item: index,
+                            };
+                        }
+                        else {
+                            break checkOutputData;
+                        }
+                    }
+                }
+            }
+        }
+        if (nodeSuccessData === undefined) {
+            nodeSuccessData = null;
+        }
+        else {
+            this.runExecutionData.resultData.lastNodeExecuted = executionData.node.name;
+        }
+        return nodeSuccessData;
     }
     get isCancelled() {
         return this.abortController.signal.aborted;