n8n-core 1.9.1 → 1.11.0

package/dist/NodeExecuteFunctions.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExecuteWebhookFunctions = exports.getExecuteHookFunctions = exports.getLoadOptionsFunctions = exports.getCredentialTestFunctions = exports.getExecuteSingleFunctions = exports.getExecuteFunctions = exports.getExecuteTriggerFunctions = exports.getExecutePollFunctions = exports.getWebhookDescription = exports.getTimezone = exports.getNodeWebhookUrl = exports.continueOnFail = exports.getNodeParameter = exports.validateValueAgainstSchema = exports.getCredentials = exports.getAdditionalKeys = exports.requestWithAuthentication = exports.normalizeItems = exports.constructExecutionMetaData = exports.returnJsonArray = exports.httpRequestWithAuthentication = exports.requestOAuth1 = exports.requestOAuth2 = exports.copyBinaryFile = exports.setBinaryDataBuffer = exports.getBinaryDataBuffer = exports.assertBinaryData = exports.getBinaryStream = exports.getBinaryMetadata = exports.getBinaryPath = exports.proxyRequestToAxios = exports.parseIncomingMessage = void 0;
+exports.getExecuteWebhookFunctions = exports.getExecuteHookFunctions = exports.getLoadOptionsFunctions = exports.getCredentialTestFunctions = exports.getExecuteSingleFunctions = exports.getExecuteFunctions = exports.getExecuteTriggerFunctions = exports.getExecutePollFunctions = exports.copyInputItems = exports.getWebhookDescription = exports.getTimezone = exports.getNodeWebhookUrl = exports.continueOnFail = exports.getNodeParameter = exports.validateValueAgainstSchema = exports.getCredentials = exports.getAdditionalKeys = exports.requestWithAuthentication = exports.normalizeItems = exports.constructExecutionMetaData = exports.returnJsonArray = exports.httpRequestWithAuthentication = exports.requestOAuth1 = exports.requestOAuth2 = exports.copyBinaryFile = exports.setBinaryDataBuffer = exports.getBinaryDataBuffer = exports.assertBinaryData = exports.getBinaryStream = exports.getBinaryMetadata = exports.getBinaryPath = exports.proxyRequestToAxios = exports.parseIncomingMessage = void 0;
 const client_oauth2_1 = require("@n8n/client-oauth2");
 const axios_1 = __importDefault(require("axios"));
 const crypto_1 = __importStar(require("crypto"));
@@ -1403,6 +1403,7 @@ const validateValueAgainstSchema = (node, nodeType, parameterValue, parameterNam
 };
 exports.validateValueAgainstSchema = validateValueAgainstSchema;
 function getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, timezone, additionalKeys, executeData, fallbackValue, options) {
+    var _a;
     const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
     if (nodeType === undefined) {
         throw new Error(`Node type "${node.type}" is not known so can not return parameter value!`);
@@ -1416,7 +1417,7 @@ function getNodeParameter(workflow, runExecutionData, runIndex, connectionInputD
     }
     let returnData;
     try {
-        returnData = workflow.expression.getParameterValue(value, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, timezone, additionalKeys, executeData);
+        returnData = workflow.expression.getParameterValue(value, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, timezone, additionalKeys, executeData, false, {}, (_a = options === null || options === void 0 ? void 0 : options.contextNode) === null || _a === void 0 ? void 0 : _a.name);
         cleanupParameterData(returnData);
     }
     catch (e) {
@@ -1478,6 +1479,80 @@ function getWebhookDescription(name, workflow, node) {
     return undefined;
 }
 exports.getWebhookDescription = getWebhookDescription;
+const addExecutionDataFunctions = async (type, nodeName, data, runExecutionData, connectionType, additionalData, sourceNodeName, sourceNodeRunIndex, currentNodeRunIndex) => {
+    if (connectionType === 'main') {
+        throw new Error(`Setting the ${type} is not supported for the main connection!`);
+    }
+    let taskData;
+    if (type === 'input') {
+        taskData = {
+            startTime: new Date().getTime(),
+            executionTime: 0,
+            executionStatus: 'running',
+            source: [null],
+        };
+    }
+    else {
+        taskData = (0, get_1.default)(runExecutionData, ['resultData', 'runData', nodeName, currentNodeRunIndex], undefined);
+        if (taskData === undefined) {
+            return;
+        }
+    }
+    taskData = taskData;
+    if (data instanceof Error) {
+        taskData.executionStatus = 'error';
+        taskData.error = data;
+    }
+    else {
+        if (type === 'output') {
+            taskData.executionStatus = 'success';
+        }
+        taskData.data = {
+            [connectionType]: data,
+        };
+    }
+    if (type === 'input') {
+        if (!(data instanceof Error)) {
+            taskData.inputOverride = {
+                [connectionType]: data,
+            };
+        }
+        if (!runExecutionData.resultData.runData.hasOwnProperty(nodeName)) {
+            runExecutionData.resultData.runData[nodeName] = [];
+        }
+        runExecutionData.resultData.runData[nodeName][currentNodeRunIndex] = taskData;
+        if (additionalData.sendDataToUI) {
+            additionalData.sendDataToUI('nodeExecuteBefore', {
+                executionId: additionalData.executionId,
+                nodeName,
+            });
+        }
+    }
+    else {
+        taskData.executionTime = new Date().getTime() - taskData.startTime;
+        if (additionalData.sendDataToUI) {
+            additionalData.sendDataToUI('nodeExecuteAfter', {
+                executionId: additionalData.executionId,
+                nodeName,
+                data: taskData,
+            });
+        }
+        let sourceTaskData = (0, get_1.default)(runExecutionData, `executionData.metadata[${sourceNodeName}]`);
+        if (!sourceTaskData) {
+            runExecutionData.executionData.metadata[sourceNodeName] = [];
+            sourceTaskData = runExecutionData.executionData.metadata[sourceNodeName];
+        }
+        if (!sourceTaskData[sourceNodeRunIndex]) {
+            sourceTaskData[sourceNodeRunIndex] = {
+                subRun: [],
+            };
+        }
+        sourceTaskData[sourceNodeRunIndex].subRun.push({
+            node: nodeName,
+            runIndex: currentNodeRunIndex,
+        });
+    }
+};
 const getCommonWorkflowFunctions = (workflow, node, additionalData) => ({
     logger: n8n_workflow_1.LoggerProxy,
     getExecutionId: () => additionalData.executionId,
@@ -1490,6 +1565,7 @@ const getCommonWorkflowFunctions = (workflow, node, additionalData) => ({
     getWorkflowStaticData: (type) => workflow.getStaticData(type, node),
     getRestApiUrl: () => additionalData.restApiUrl,
     getInstanceBaseUrl: () => additionalData.instanceBaseUrl,
+    getInstanceId: async () => (0, UserSettings_1.getInstanceId)(),
     getTimezone: () => getTimezone(workflow, additionalData),
     prepareOutputData: async (outputData) => [outputData],
 });
@@ -1607,6 +1683,21 @@ const getBinaryHelperFunctions = ({ executionId }, workflowId) => ({
         throw new Error('copyBinaryFile has been removed. Please upgrade this node');
     },
 });
+function copyInputItems(items, properties) {
+    return items.map((item) => {
+        const newItem = {};
+        for (const property of properties) {
+            if (item.json[property] === undefined) {
+                newItem[property] = null;
+            }
+            else {
+                newItem[property] = (0, n8n_workflow_1.deepCopy)(item.json[property]);
+            }
+        }
+        return newItem;
+    });
+}
+exports.copyInputItems = copyInputItems;
 function getExecutePollFunctions(workflow, node, additionalData, mode, activation) {
     return ((workflow, node) => {
         return {
@@ -1691,6 +1782,101 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
             getContext(type) {
                 return n8n_workflow_1.NodeHelpers.getContext(runExecutionData, type, node);
             },
+            async getInputConnectionData(inputName, itemIndex, inputIndex) {
+                var _a;
+                const node = this.getNode();
+                const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+                const inputs = n8n_workflow_1.NodeHelpers.getNodeInputs(workflow, node, nodeType.description);
+                let inputConfiguration = inputs.find((input) => {
+                    if (typeof input === 'string') {
+                        return input === inputName;
+                    }
+                    return input.type === inputName;
+                });
+                if (inputConfiguration === undefined) {
+                    throw new Error(`The node "${node.name}" does not have an input of type "${inputName}"`);
+                }
+                if (typeof inputConfiguration === 'string') {
+                    inputConfiguration = {
+                        type: inputConfiguration,
+                    };
+                }
+                const parentNodes = workflow.getParentNodes(node.name, inputName, 1);
+                if (parentNodes.length === 0) {
+                    return inputConfiguration.maxConnections === 1 ? undefined : [];
+                }
+                const constParentNodes = parentNodes
+                    .map((nodeName) => {
+                    return workflow.getNode(nodeName);
+                })
+                    .filter((connectedNode) => connectedNode.disabled !== true)
+                    .map(async (connectedNode) => {
+                    const nodeType = workflow.nodeTypes.getByNameAndVersion(connectedNode.type, connectedNode.typeVersion);
+                    if (!nodeType.supplyData) {
+                        throw new Error(`The node "${connectedNode.name}" does not have a "supplyData" method defined!`);
+                    }
+                    const context = Object.assign({}, this);
+                    context.getNodeParameter = (parameterName, itemIndex, fallbackValue, options) => {
+                        return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, connectedNode, parameterName, itemIndex, mode, additionalData.timezone, getAdditionalKeys(additionalData, mode, runExecutionData), executeData, fallbackValue, { ...(options || {}), contextNode: node });
+                    };
+                    context.getNode = () => {
+                        return (0, n8n_workflow_1.deepCopy)(connectedNode);
+                    };
+                    context.getCredentials = async (key) => {
+                        try {
+                            return await getCredentials(workflow, connectedNode, key, additionalData, mode, runExecutionData, runIndex, connectionInputData, itemIndex);
+                        }
+                        catch (error) {
+                            let currentNodeRunIndex = 0;
+                            if (runExecutionData.resultData.runData.hasOwnProperty(node.name)) {
+                                currentNodeRunIndex = runExecutionData.resultData.runData[node.name].length;
+                            }
+                            await addExecutionDataFunctions('input', connectedNode.name, error, runExecutionData, inputName, additionalData, node.name, runIndex, currentNodeRunIndex);
+                            throw error;
+                        }
+                    };
+                    try {
+                        return await nodeType.supplyData.call(context);
+                    }
+                    catch (error) {
+                        if (!(error instanceof n8n_workflow_1.ExecutionBaseError)) {
+                            error = new n8n_workflow_1.NodeOperationError(connectedNode, error, {
+                                itemIndex,
+                            });
+                        }
+                        let currentNodeRunIndex = 0;
+                        if (runExecutionData.resultData.runData.hasOwnProperty(node.name)) {
+                            currentNodeRunIndex = runExecutionData.resultData.runData[node.name].length;
+                        }
+                        await addExecutionDataFunctions('input', connectedNode.name, error, runExecutionData, inputName, additionalData, node.name, runIndex, currentNodeRunIndex);
+                        throw new n8n_workflow_1.NodeOperationError(connectedNode, `Error on node "${connectedNode.name}" which is connected via input "${inputName}"`, {
+                            itemIndex,
+                        });
+                    }
+                });
+                const nodes = await Promise.all(constParentNodes);
+                if (inputConfiguration.required && nodes.length === 0) {
+                    throw new n8n_workflow_1.NodeOperationError(node, `A ${inputName} processor node must be connected!`);
+                }
+                if (inputConfiguration.maxConnections !== undefined &&
+                    nodes.length > inputConfiguration.maxConnections) {
+                    throw new n8n_workflow_1.NodeOperationError(node, `Only ${inputConfiguration.maxConnections} ${inputName} processor nodes are/is allowed to be connected!`);
+                }
+                return inputConfiguration.maxConnections === 1
+                    ? (_a = (nodes || [])[0]) === null || _a === void 0 ? void 0 : _a.response
+                    : nodes.map((node) => node.response);
+            },
+            getNodeOutputs() {
+                const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+                return n8n_workflow_1.NodeHelpers.getNodeOutputs(workflow, node, nodeType.description).map((output) => {
+                    if (typeof output === 'string') {
+                        return {
+                            type: output,
+                        };
+                    }
+                    return output;
+                });
+            },
             getInputData: (inputIndex = 0, inputName = 'main') => {
                 if (!inputData.hasOwnProperty(inputName)) {
                     return [];
@@ -1728,7 +1914,7 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
                     return;
                 }
                 try {
-                    if (additionalData.sendMessageToUI) {
+                    if (additionalData.sendDataToUI) {
                         args = args.map((arg) => {
                             if (arg.isLuxonDateTime && arg.invalidReason)
                                 return { ...arg };
@@ -1738,7 +1924,10 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
                                 return arg.toString();
                             return arg;
                         });
-                        additionalData.sendMessageToUI(node.name, args);
+                        additionalData.sendDataToUI('sendConsoleMessage', {
+                            source: `[Node: "${node.name}"]`,
+                            messages: args,
+                        });
                     }
                 }
                 catch (error) {
@@ -1749,8 +1938,25 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
                 var _a;
                 await ((_a = additionalData.hooks) === null || _a === void 0 ? void 0 : _a.executeHookFunctions('sendResponse', [response]));
             },
+            addInputData(connectionType, data) {
+                const nodeName = this.getNode().name;
+                let currentNodeRunIndex = 0;
+                if (runExecutionData.resultData.runData.hasOwnProperty(nodeName)) {
+                    currentNodeRunIndex = runExecutionData.resultData.runData[nodeName].length;
+                }
+                addExecutionDataFunctions('input', this.getNode().name, data, runExecutionData, connectionType, additionalData, node.name, runIndex, currentNodeRunIndex).catch((error) => {
+                    n8n_workflow_1.LoggerProxy.warn(`There was a problem logging input data of node "${this.getNode().name}": ${error.message}`);
+                });
+                return { index: currentNodeRunIndex };
+            },
+            addOutputData(connectionType, currentNodeRunIndex, data) {
+                addExecutionDataFunctions('output', this.getNode().name, data, runExecutionData, connectionType, additionalData, node.name, runIndex, currentNodeRunIndex).catch((error) => {
+                    n8n_workflow_1.LoggerProxy.warn(`There was a problem logging output data of node "${this.getNode().name}": ${error.message}`);
+                });
+            },
             helpers: {
                 createDeferredPromise: n8n_workflow_1.createDeferredPromise,
+                copyInputItems,
                 ...getRequestHelperFunctions(workflow, node, additionalData),
                 ...getFileSystemHelperFunctions(node),
                 ...getBinaryHelperFunctions(additionalData, workflow.id),