n8n-core 1.8.1 → 1.10.0

package/dist/NodeExecuteFunctions.js

@@ -45,14 +45,14 @@ const path_1 = __importDefault(require("path"));
 const qs_1 = require("qs");
 const stream_1 = require("stream");
 const url_1 = __importStar(require("url"));
-const BinaryDataManager_1 = require("./BinaryDataManager");
-const utils_1 = require("./BinaryDataManager/utils");
+const BinaryData_service_1 = require("./BinaryData/BinaryData.service");
 const Constants_1 = require("./Constants");
 const ExtractValue_1 = require("./ExtractValue");
 const OAuth2Helper_1 = require("./OAuth2Helper");
+const WorkflowExecutionMetadata_1 = require("./WorkflowExecutionMetadata");
 const Secrets_1 = require("./Secrets");
 const UserSettings_1 = require("./UserSettings");
-const WorkflowExecutionMetadata_1 = require("./WorkflowExecutionMetadata");
+const typedi_1 = __importDefault(require("typedi"));
 axios_1.default.defaults.timeout = 300000;
 axios_1.default.defaults.headers.post = {};
 axios_1.default.defaults.headers.put = {};
@@ -540,7 +540,9 @@ async function proxyRequestToAxios(workflow, additionalData, node, uriOrObject,
                 n8n_workflow_1.LoggerProxy.debug('Request proxied to Axios failed', { status: response.status });
                 let responseData = response.data;
                 if (Buffer.isBuffer(responseData) || responseData instanceof stream_1.Readable) {
-                    responseData = await (0, utils_1.binaryToBuffer)(responseData).then((buffer) => buffer.toString('utf-8'));
+                    responseData = await typedi_1.default.get(BinaryData_service_1.BinaryDataService)
+                        .toBuffer(responseData)
+                        .then((buffer) => buffer.toString('utf-8'));
                 }
                 if (configObject.simple === false) {
                     if (configObject.resolveWithFullResponse) {
@@ -674,15 +676,15 @@ async function httpRequest(requestOptions) {
     return result.data;
 }
 function getBinaryPath(binaryDataId) {
-    return BinaryDataManager_1.BinaryDataManager.getInstance().getBinaryPath(binaryDataId);
+    return typedi_1.default.get(BinaryData_service_1.BinaryDataService).getPath(binaryDataId);
 }
 exports.getBinaryPath = getBinaryPath;
 async function getBinaryMetadata(binaryDataId) {
-    return BinaryDataManager_1.BinaryDataManager.getInstance().getBinaryMetadata(binaryDataId);
+    return typedi_1.default.get(BinaryData_service_1.BinaryDataService).getMetadata(binaryDataId);
 }
 exports.getBinaryMetadata = getBinaryMetadata;
-function getBinaryStream(binaryDataId, chunkSize) {
-    return BinaryDataManager_1.BinaryDataManager.getInstance().getBinaryStream(binaryDataId, chunkSize);
+async function getBinaryStream(binaryDataId, chunkSize) {
+    return typedi_1.default.get(BinaryData_service_1.BinaryDataService).getAsStream(binaryDataId, chunkSize);
 }
 exports.getBinaryStream = getBinaryStream;
 function assertBinaryData(inputData, node, itemIndex, propertyName, inputIndex) {
@@ -703,14 +705,14 @@ function assertBinaryData(inputData, node, itemIndex, propertyName, inputIndex)
 exports.assertBinaryData = assertBinaryData;
 async function getBinaryDataBuffer(inputData, itemIndex, propertyName, inputIndex) {
     const binaryData = inputData.main[inputIndex][itemIndex].binary[propertyName];
-    return BinaryDataManager_1.BinaryDataManager.getInstance().getBinaryDataBuffer(binaryData);
+    return typedi_1.default.get(BinaryData_service_1.BinaryDataService).getAsBuffer(binaryData);
 }
 exports.getBinaryDataBuffer = getBinaryDataBuffer;
-async function setBinaryDataBuffer(data, binaryData, executionId) {
-    return BinaryDataManager_1.BinaryDataManager.getInstance().storeBinaryData(data, binaryData, executionId);
+async function setBinaryDataBuffer(binaryData, bufferOrStream, workflowId, executionId) {
+    return typedi_1.default.get(BinaryData_service_1.BinaryDataService).store(workflowId, executionId, bufferOrStream, binaryData);
 }
 exports.setBinaryDataBuffer = setBinaryDataBuffer;
-async function copyBinaryFile(executionId, filePath, fileName, mimeType) {
+async function copyBinaryFile(workflowId, executionId, filePath, fileName, mimeType) {
     let fileExtension;
     if (!mimeType) {
         if (filePath) {
@@ -745,10 +747,10 @@ async function copyBinaryFile(executionId, filePath, fileName, mimeType) {
     else if (filePath) {
         returnData.fileName = path_1.default.parse(filePath).base;
     }
-    return BinaryDataManager_1.BinaryDataManager.getInstance().copyBinaryFile(returnData, filePath, executionId);
+    return typedi_1.default.get(BinaryData_service_1.BinaryDataService).copyBinaryFile(workflowId, executionId, returnData, filePath);
 }
 exports.copyBinaryFile = copyBinaryFile;
-async function prepareBinaryData(binaryData, executionId, filePath, mimeType) {
+async function prepareBinaryData(binaryData, executionId, workflowId, filePath, mimeType) {
     var _a, _b, _c, _d, _e;
     let fileExtension;
     if (binaryData instanceof http_1.IncomingMessage) {
@@ -812,7 +814,7 @@ async function prepareBinaryData(binaryData, executionId, filePath, mimeType) {
             returnData.fileExtension = fileExtension;
         }
     }
-    return setBinaryDataBuffer(returnData, binaryData, executionId);
+    return setBinaryDataBuffer(returnData, binaryData, workflowId, executionId);
 }
 async function requestOAuth2(credentialsType, requestOptions, node, additionalData, oAuth2Options, isN8nRequest = false) {
     var _a, _b;
@@ -1401,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!`);
@@ -1414,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) {
@@ -1476,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,
@@ -1488,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],
 });
@@ -1591,16 +1669,16 @@ const getFileSystemHelperFunctions = (node) => ({
         return (0, promises_1.writeFile)(filePath, content, { encoding: 'binary', flag });
     },
 });
-const getNodeHelperFunctions = ({ executionId, }) => ({
-    copyBinaryFile: async (filePath, fileName, mimeType) => copyBinaryFile(executionId, filePath, fileName, mimeType),
+const getNodeHelperFunctions = ({ executionId }, workflowId) => ({
+    copyBinaryFile: async (filePath, fileName, mimeType) => copyBinaryFile(workflowId, executionId, filePath, fileName, mimeType),
 });
-const getBinaryHelperFunctions = ({ executionId, }) => ({
+const getBinaryHelperFunctions = ({ executionId }, workflowId) => ({
     getBinaryPath,
     getBinaryStream,
     getBinaryMetadata,
-    binaryToBuffer: utils_1.binaryToBuffer,
-    prepareBinaryData: async (binaryData, filePath, mimeType) => prepareBinaryData(binaryData, executionId, filePath, mimeType),
-    setBinaryDataBuffer: async (data, binaryData) => setBinaryDataBuffer(data, binaryData, executionId),
+    binaryToBuffer: async (body) => typedi_1.default.get(BinaryData_service_1.BinaryDataService).toBuffer(body),
+    prepareBinaryData: async (binaryData, filePath, mimeType) => prepareBinaryData(binaryData, executionId, workflowId, filePath, mimeType),
+    setBinaryDataBuffer: async (data, binaryData) => setBinaryDataBuffer(data, binaryData, workflowId, executionId),
     copyBinaryFile: async () => {
         throw new Error('copyBinaryFile has been removed. Please upgrade this node');
     },
@@ -1628,7 +1706,7 @@ function getExecutePollFunctions(workflow, node, additionalData, mode, activatio
             helpers: {
                 createDeferredPromise: n8n_workflow_1.createDeferredPromise,
                 ...getRequestHelperFunctions(workflow, node, additionalData),
-                ...getBinaryHelperFunctions(additionalData),
+                ...getBinaryHelperFunctions(additionalData, workflow.id),
                 returnJsonArray,
             },
         };
@@ -1658,7 +1736,7 @@ function getExecuteTriggerFunctions(workflow, node, additionalData, mode, activa
             helpers: {
                 createDeferredPromise: n8n_workflow_1.createDeferredPromise,
                 ...getRequestHelperFunctions(workflow, node, additionalData),
-                ...getBinaryHelperFunctions(additionalData),
+                ...getBinaryHelperFunctions(additionalData, workflow.id),
                 returnJsonArray,
             },
         };
@@ -1684,11 +1762,106 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
                     inputData,
                     parentWorkflowSettings: workflow.settings,
                 })
-                    .then(async (result) => BinaryDataManager_1.BinaryDataManager.getInstance().duplicateBinaryData(result, additionalData.executionId));
+                    .then(async (result) => typedi_1.default.get(BinaryData_service_1.BinaryDataService).duplicateBinaryData(workflow.id, additionalData.executionId, result));
             },
             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 [];
@@ -1714,7 +1887,7 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
                 const dataProxy = new n8n_workflow_1.WorkflowDataProxy(workflow, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, {}, mode, additionalData.timezone, getAdditionalKeys(additionalData, mode, runExecutionData), executeData);
                 return dataProxy.getDataProxy();
             },
-            binaryToBuffer: utils_1.binaryToBuffer,
+            binaryToBuffer: async (body) => typedi_1.default.get(BinaryData_service_1.BinaryDataService).toBuffer(body),
             async putExecutionToWait(waitTill) {
                 runExecutionData.waitTill = waitTill;
                 if (additionalData.setExecutionStatus) {
@@ -1726,7 +1899,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 };
@@ -1736,7 +1909,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) {
@@ -1747,18 +1923,34 @@ 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,
                 ...getRequestHelperFunctions(workflow, node, additionalData),
                 ...getFileSystemHelperFunctions(node),
-                ...getBinaryHelperFunctions(additionalData),
+                ...getBinaryHelperFunctions(additionalData, workflow.id),
                 assertBinaryData: (itemIndex, propertyName) => assertBinaryData(inputData, node, itemIndex, propertyName, 0),
                 getBinaryDataBuffer: async (itemIndex, propertyName) => getBinaryDataBuffer(inputData, itemIndex, propertyName, 0),
                 returnJsonArray,
                 normalizeItems,
                 constructExecutionMetaData,
             },
-            nodeHelpers: getNodeHelperFunctions(additionalData),
+            nodeHelpers: getNodeHelperFunctions(additionalData, workflow.id),
         };
     })(workflow, runExecutionData, connectionInputData, inputData, node);
 }
@@ -1811,7 +2003,7 @@ function getExecuteSingleFunctions(workflow, runExecutionData, runIndex, connect
             helpers: {
                 createDeferredPromise: n8n_workflow_1.createDeferredPromise,
                 ...getRequestHelperFunctions(workflow, node, additionalData),
-                ...getBinaryHelperFunctions(additionalData),
+                ...getBinaryHelperFunctions(additionalData, workflow.id),
                 assertBinaryData: (propertyName, inputIndex = 0) => assertBinaryData(inputData, node, itemIndex, propertyName, inputIndex),
                 getBinaryDataBuffer: async (propertyName, inputIndex = 0) => getBinaryDataBuffer(inputData, itemIndex, propertyName, inputIndex),
             },
@@ -1946,10 +2138,10 @@ function getExecuteWebhookFunctions(workflow, node, additionalData, mode, webhoo
             helpers: {
                 createDeferredPromise: n8n_workflow_1.createDeferredPromise,
                 ...getRequestHelperFunctions(workflow, node, additionalData),
-                ...getBinaryHelperFunctions(additionalData),
+                ...getBinaryHelperFunctions(additionalData, workflow.id),
                 returnJsonArray,
             },
-            nodeHelpers: getNodeHelperFunctions(additionalData),
+            nodeHelpers: getNodeHelperFunctions(additionalData, workflow.id),
         };
     })(workflow, node);
 }