n8n-core 1.107.1 → 1.109.0

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

@@ -119,7 +119,7 @@ class WorkflowExecute {
         };
         return this.processRunExecutionData(workflow);
     }
-    forceInputNodeExecution(workflow) {
+    isLegacyExecutionOrder(workflow) {
         return workflow.settings.executionOrder !== 'v1';
     }
     runPartialWorkflow(workflow, runData, startNodes, destinationNode, pinData) {
@@ -460,14 +460,13 @@ class WorkflowExecute {
             if (!nodeWasWaiting) {
                 const checkOutputNodes = [];
                 for (const outputIndexParent in workflow.connectionsBySourceNode[parentNodeName].main) {
-                    if (!workflow.connectionsBySourceNode[parentNodeName].main.hasOwnProperty(outputIndexParent)) {
+                    if (!Object.hasOwn(workflow.connectionsBySourceNode[parentNodeName].main, outputIndexParent)) {
                         continue;
                     }
                     for (const connectionDataCheck of workflow.connectionsBySourceNode[parentNodeName].main[outputIndexParent] ?? []) {
                         checkOutputNodes.push(connectionDataCheck.node);
                     }
                 }
-                const forceInputNodeExecution = this.forceInputNodeExecution(workflow);
                 for (let inputIndex = 0; inputIndex < workflow.connectionsByDestinationNode[connectionData.node].main.length; inputIndex++) {
                     for (const inputData of workflow.connectionsByDestinationNode[connectionData.node].main[inputIndex] ?? []) {
                         if (inputData.node === parentNodeName) {
@@ -485,7 +484,7 @@ class WorkflowExecute {
                         if (this.runExecutionData.resultData.runData[inputData.node] !== undefined) {
                             continue;
                         }
-                        if (!forceInputNodeExecution) {
+                        if (!this.isLegacyExecutionOrder(workflow)) {
                             continue;
                         }
                         const parentNodes = workflow.getParentNodes(inputData.node, n8n_workflow_1.NodeConnectionTypes.Main, -1);
@@ -644,28 +643,23 @@ class WorkflowExecute {
         const customOperation = customOperations[resource][operation];
         return customOperation;
     }
-    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]] };
+    handleDisabledNode(inputData) {
+        if (Object.hasOwn(inputData, 'main') && inputData.main.length > 0) {
+            if (inputData.main[0] === null) {
+                return { data: undefined };
             }
-            return { data: undefined };
+            return { data: [inputData.main[0]] };
         }
-        const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
-        const isDeclarativeNode = nodeType.description.requestDefaults !== undefined;
-        const customOperation = this.getCustomOperation(node, nodeType);
-        let connectionInputData = [];
+        return { data: undefined };
+    }
+    prepareConnectionInputData(workflow, nodeType, customOperation, inputData) {
         if (nodeType.execute ||
             customOperation ||
             (!nodeType.poll && !nodeType.trigger && !nodeType.webhook)) {
-            if (inputData.main?.length > 0) {
-                connectionInputData = inputData.main[0];
+            if (!inputData.main?.length) {
+                return null;
             }
+            let connectionInputData = inputData.main[0];
             const forceInputNodeExecution = workflow.settings.executionOrder !== 'v1';
             if (!forceInputNodeExecution) {
                 for (const mainData of inputData.main) {
@@ -675,10 +669,14 @@ class WorkflowExecute {
                     }
                 }
             }
-            if (connectionInputData.length === 0) {
-                return { data: undefined };
+            if (!connectionInputData || connectionInputData.length === 0) {
+                return null;
             }
+            return connectionInputData;
         }
+        return [];
+    }
+    rethrowLastNodeError(runExecutionData, node) {
         if (runExecutionData.resultData.lastNodeExecuted === node.name &&
             runExecutionData.resultData.error !== undefined) {
             if (runExecutionData.resultData.error.name === 'NodeOperationError' ||
@@ -689,6 +687,8 @@ class WorkflowExecute {
             error.stack = runExecutionData.resultData.error.stack;
             throw error;
         }
+    }
+    handleExecuteOnce(node, inputData) {
         if (node.executeOnce === true) {
             const newInputData = {};
             for (const connectionType of Object.keys(inputData)) {
@@ -696,109 +696,145 @@ class WorkflowExecute {
                     return input && input.slice(0, 1);
                 });
             }
-            inputData = newInputData;
+            return newInputData;
         }
-        if (nodeType.execute || customOperation) {
-            const closeFunctions = [];
-            const context = new node_execution_context_1.ExecuteContext(workflow, node, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData, closeFunctions, abortSignal);
-            let data;
-            if (customOperation) {
-                data = await customOperation.call(context);
+        return inputData;
+    }
+    reportJsonIncompatibleOutput(data, workflow, node) {
+        if (di_1.Container.get(config_1.GlobalConfig).sentry.backendDsn) {
+            const jsonCompatibleResult = (0, is_json_compatible_1.isJsonCompatible)(data, new Set(['pairedItem']));
+            if (!jsonCompatibleResult.isValid) {
+                di_1.Container.get(error_reporter_1.ErrorReporter).error('node execution returned incorrect output', {
+                    shouldBeLogged: false,
+                    extra: {
+                        nodeName: node.name,
+                        nodeType: node.type,
+                        nodeVersion: node.typeVersion,
+                        workflowId: workflow.id,
+                        workflowName: workflow.name ?? 'Unnamed workflow',
+                        executionId: this.additionalData.executionId ?? 'unsaved-execution',
+                        errorPath: jsonCompatibleResult.errorPath,
+                        errorMessage: jsonCompatibleResult.errorMessage,
+                    },
+                });
             }
-            else if (nodeType.execute) {
-                data =
-                    nodeType instanceof n8n_workflow_1.Node
-                        ? await nodeType.execute(context)
-                        : await nodeType.execute.call(context);
+        }
+    }
+    async executeNode(workflow, node, nodeType, customOperation, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData, abortSignal) {
+        const closeFunctions = [];
+        const context = new node_execution_context_1.ExecuteContext(workflow, node, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData, closeFunctions, abortSignal);
+        let data = null;
+        if (customOperation) {
+            data = await customOperation.call(context);
+        }
+        else if (nodeType.execute) {
+            data =
+                nodeType instanceof n8n_workflow_1.Node
+                    ? await nodeType.execute(context)
+                    : await nodeType.execute.call(context);
+        }
+        this.reportJsonIncompatibleOutput(data, workflow, node);
+        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, hints: context.hints };
+    }
+    async executePollNode(workflow, node, nodeType, additionalData, mode, inputData) {
+        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 };
+    }
+    async executeTriggerNode(workflow, node, additionalData, mode, inputData, abortSignal) {
+        if (mode === 'manual') {
+            const triggerResponse = await di_1.Container.get(triggers_and_pollers_1.TriggersAndPollers).runTrigger(workflow, node, NodeExecuteFunctions.getExecuteTriggerFunctions, additionalData, mode, 'manual');
+            if (triggerResponse === undefined) {
+                return { data: null };
             }
-            if (di_1.Container.get(config_1.GlobalConfig).sentry.backendDsn) {
-                const jsonCompatibleResult = (0, is_json_compatible_1.isJsonCompatible)(data, new Set(['pairedItem']));
-                if (!jsonCompatibleResult.isValid) {
-                    di_1.Container.get(error_reporter_1.ErrorReporter).error('node execution returned incorrect data', {
-                        shouldBeLogged: false,
-                        extra: {
-                            nodeName: node.name,
-                            nodeType: node.type,
-                            nodeVersion: node.typeVersion,
-                            workflowId: workflow.id,
-                            workflowName: workflow.name ?? 'Unnamed workflow',
-                            executionId: this.additionalData.executionId ?? 'unsaved-execution',
-                            errorPath: jsonCompatibleResult.errorPath,
-                            errorMessage: jsonCompatibleResult.errorMessage,
-                        },
-                    });
-                }
+            let closeFunction;
+            if (triggerResponse.closeFunction) {
+                closeFunction = triggerResponse.closeFunction;
+                abortSignal?.addEventListener('abort', closeFunction);
             }
-            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,
-                });
+            if (triggerResponse.manualTriggerFunction !== undefined) {
+                await triggerResponse.manualTriggerFunction();
             }
-            return { data, hints: context.hints };
-        }
-        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) };
+            const response = await triggerResponse.manualTriggerResponse;
+            if (response.length === 0) {
+                return { data: null, closeFunction };
             }
-            return { data: inputData.main };
+            return { data: response, closeFunction };
         }
-        else if (nodeType.trigger) {
-            if (mode === 'manual') {
-                const triggerResponse = await di_1.Container.get(triggers_and_pollers_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 };
+        return { data: inputData.main };
+    }
+    async executeDeclarativeNodeInTest(workflow, node, nodeType, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData) {
+        const context = new node_execution_context_1.ExecuteContext(workflow, node, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData, []);
+        const routingNode = new routing_node_1.RoutingNode(context, nodeType);
+        const data = await routingNode.runNode();
+        return { data };
+    }
+    async runNode(workflow, executionData, runExecutionData, runIndex, additionalData, mode, abortSignal) {
+        const { node } = executionData;
+        let inputData = executionData.data;
+        if (node.disabled === true) {
+            return this.handleDisabledNode(inputData);
         }
-        else if (nodeType.webhook && !isDeclarativeNode) {
-            return { data: inputData.main };
+        const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+        const customOperation = this.getCustomOperation(node, nodeType);
+        const connectionInputData = this.prepareConnectionInputData(workflow, nodeType, customOperation, inputData);
+        if (connectionInputData === null) {
+            return { data: undefined };
         }
-        else {
-            const context = new node_execution_context_1.ExecuteContext(workflow, node, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData, []);
-            const routingNode = new routing_node_1.RoutingNode(context, nodeType);
-            const data = await routingNode.runNode();
-            return { data };
+        this.rethrowLastNodeError(runExecutionData, node);
+        inputData = this.handleExecuteOnce(node, inputData);
+        const isDeclarativeNode = nodeType.description.requestDefaults !== undefined;
+        if (nodeType.execute || customOperation) {
+            return await this.executeNode(workflow, node, nodeType, customOperation, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData, abortSignal);
+        }
+        if (nodeType.poll) {
+            return await this.executePollNode(workflow, node, nodeType, additionalData, mode, inputData);
         }
+        if (nodeType.trigger) {
+            return await this.executeTriggerNode(workflow, node, additionalData, mode, inputData, abortSignal);
+        }
+        if (nodeType.webhook && !isDeclarativeNode) {
+            return { data: inputData.main };
+        }
+        return await this.executeDeclarativeNodeInTest(workflow, node, nodeType, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executionData);
     }
-    processRunExecutionData(workflow) {
-        n8n_workflow_1.LoggerProxy.debug('Workflow execution started', { workflowId: workflow.id });
-        const startedAt = new Date();
-        const forceInputNodeExecution = this.forceInputNodeExecution(workflow);
-        this.status = 'running';
-        const { hooks, executionId } = this.additionalData;
-        assert.ok(hooks, 'Failed to run workflow due to missing execution lifecycle hooks');
-        if (!this.runExecutionData.executionData) {
-            throw new n8n_workflow_1.ApplicationError('Failed to run workflow due to missing execution data', {
+    assertExecutionDataExists(executionData, workflow) {
+        if (!executionData) {
+            throw new n8n_workflow_1.UnexpectedError('Failed to run workflow due to missing execution data', {
                 extra: {
                     workflowId: workflow.id,
-                    executionId,
+                    executionId: this.additionalData.executionId,
                     mode: this.mode,
                 },
             });
         }
+    }
+    handleWaitingState(workflow) {
+        if (this.runExecutionData.waitTill) {
+            this.runExecutionData.waitTill = undefined;
+            this.assertExecutionDataExists(this.runExecutionData.executionData, workflow);
+            this.runExecutionData.executionData.nodeExecutionStack[0].node.disabled = true;
+            const lastNodeExecuted = this.runExecutionData.resultData.lastNodeExecuted;
+            this.runExecutionData.resultData.runData[lastNodeExecuted].pop();
+        }
+    }
+    checkForWorkflowIssues(workflow) {
+        this.assertExecutionDataExists(this.runExecutionData.executionData, workflow);
         const startNode = this.runExecutionData.executionData.nodeExecutionStack.at(0)?.node.name;
         let destinationNode;
         if (this.runExecutionData.startData && this.runExecutionData.startData.destinationNode) {
@@ -813,19 +849,25 @@ class WorkflowExecute {
         if (workflowIssues !== null) {
             throw new workflow_has_issues_error_1.WorkflowHasIssuesError();
         }
+    }
+    setupExecution() {
+        this.status = 'running';
+        const { hooks } = this.additionalData;
+        assert.ok(hooks, 'Failed to run workflow due to missing execution lifecycle hooks');
+        if (this.runExecutionData.startData === undefined) {
+            this.runExecutionData.startData = {};
+        }
+        return { startedAt: new Date(), hooks };
+    }
+    processRunExecutionData(workflow) {
+        n8n_workflow_1.LoggerProxy.debug('Workflow execution started', { workflowId: workflow.id });
+        const { startedAt, hooks } = this.setupExecution();
+        this.checkForWorkflowIssues(workflow);
+        this.handleWaitingState(workflow);
         let executionData;
         let executionError;
         let executionNode;
         let runIndex;
-        if (this.runExecutionData.startData === undefined) {
-            this.runExecutionData.startData = {};
-        }
-        if (this.runExecutionData.waitTill) {
-            const lastNodeExecuted = this.runExecutionData.resultData.lastNodeExecuted;
-            this.runExecutionData.executionData.nodeExecutionStack[0].node.disabled = true;
-            this.runExecutionData.waitTill = undefined;
-            this.runExecutionData.resultData.runData[lastNodeExecuted].pop();
-        }
         let currentExecutionTry = '';
         let lastExecutionTry = '';
         let closeFunction;
@@ -910,7 +952,7 @@ class WorkflowExecute {
                     }
                     executionData.data = newTaskDataConnections;
                     runIndex = 0;
-                    if (this.runExecutionData.resultData.runData.hasOwnProperty(executionNode.name)) {
+                    if (Object.hasOwn(this.runExecutionData.resultData.runData, executionNode.name)) {
                         runIndex = this.runExecutionData.resultData.runData[executionNode.name].length;
                     }
                     currentExecutionTry = `${executionNode.name}:${runIndex}`;
@@ -1042,7 +1084,7 @@ class WorkflowExecute {
                             });
                         }
                     }
-                    if (!this.runExecutionData.resultData.runData.hasOwnProperty(executionNode.name)) {
+                    if (!Object.hasOwn(this.runExecutionData.resultData.runData, executionNode.name)) {
                         this.runExecutionData.resultData.runData[executionNode.name] = [];
                     }
                     const taskData = {
@@ -1068,7 +1110,7 @@ class WorkflowExecute {
                         ]);
                         if (executionData.node.continueOnFail === true ||
                             ['continueRegularOutput', 'continueErrorOutput'].includes(executionData.node.onError || '')) {
-                            if (executionData.data.hasOwnProperty('main') && executionData.data.main.length > 0) {
+                            if (Object.hasOwn(executionData.data, 'main') && executionData.data.main.length > 0) {
                                 if (executionData.data.main[0] !== null) {
                                     nodeSuccessData = [executionData.data.main[0]];
                                 }
@@ -1130,17 +1172,17 @@ class WorkflowExecute {
                         ]);
                         continue;
                     }
-                    if (workflow.connectionsBySourceNode.hasOwnProperty(executionNode.name)) {
-                        if (workflow.connectionsBySourceNode[executionNode.name].hasOwnProperty('main')) {
+                    if (Object.hasOwn(workflow.connectionsBySourceNode, executionNode.name)) {
+                        if (Object.hasOwn(workflow.connectionsBySourceNode[executionNode.name], 'main')) {
                             let outputIndex;
                             let connectionData;
                             const nodesToAdd = [];
                             for (outputIndex in workflow.connectionsBySourceNode[executionNode.name].main) {
-                                if (!workflow.connectionsBySourceNode[executionNode.name].main.hasOwnProperty(outputIndex)) {
+                                if (!Object.hasOwn(workflow.connectionsBySourceNode[executionNode.name].main, outputIndex)) {
                                     continue;
                                 }
                                 for (connectionData of workflow.connectionsBySourceNode[executionNode.name].main[outputIndex] ?? []) {
-                                    if (!workflow.nodes.hasOwnProperty(connectionData.node)) {
+                                    if (!Object.hasOwn(workflow.nodes, connectionData.node)) {
                                         throw new n8n_workflow_1.ApplicationError('Destination node not found', {
                                             extra: {
                                                 sourceNodeName: executionNode.name,
@@ -1150,7 +1192,7 @@ class WorkflowExecute {
                                     }
                                     if (nodeSuccessData[outputIndex] &&
                                         (nodeSuccessData[outputIndex].length !== 0 ||
-                                            (connectionData.index > 0 && forceInputNodeExecution))) {
+                                            (connectionData.index > 0 && this.isLegacyExecutionOrder(workflow)))) {
                                         if (workflow.settings.executionOrder === 'v1') {
                                             const nodeToAdd = workflow.getNode(connectionData.node);
                                             nodesToAdd.push({
@@ -1323,11 +1365,11 @@ class WorkflowExecute {
             if (highestNodes.length === 0) {
                 return true;
             }
-            if (!executionData.data.hasOwnProperty('main')) {
+            if (!Object.hasOwn(executionData.data, 'main')) {
                 this.runExecutionData.executionData.nodeExecutionStack.push(executionData);
                 return false;
             }
-            if (this.forceInputNodeExecution(workflow)) {
+            if (this.isLegacyExecutionOrder(workflow)) {
                 if (executionData.data.main.length < connectionIndex ||
                     executionData.data.main[connectionIndex] === null) {
                     this.runExecutionData.executionData.nodeExecutionStack.push(executionData);