n8n-core 1.69.0 → 1.71.0

package/dist/NodeExecuteFunctions.js

@@ -15,19 +15,31 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCheckProcessedHelperFunctions = exports.getBinaryHelperFunctions = exports.getNodeHelperFunctions = exports.getFileSystemHelperFunctions = exports.getSchedulingFunctions = exports.getSSHTunnelFunctions = exports.getRequestHelperFunctions = exports.validateValueAgainstSchema = exports.removeEmptyBody = exports.validateUrl = void 0;
+exports.getCheckProcessedHelperFunctions = exports.getBinaryHelperFunctions = exports.getNodeHelperFunctions = exports.getFileSystemHelperFunctions = exports.getSchedulingFunctions = exports.getSSHTunnelFunctions = exports.getRequestHelperFunctions = exports.addExecutionDataFunctions = exports.removeEmptyBody = exports.validateUrl = void 0;
 exports.parseRequestObject = parseRequestObject;
+exports.parseContentType = parseContentType;
+exports.parseContentDisposition = parseContentDisposition;
 exports.parseIncomingMessage = parseIncomingMessage;
 exports.binaryToString = binaryToString;
 exports.proxyRequestToAxios = proxyRequestToAxios;
@@ -53,12 +65,6 @@ exports.returnJsonArray = returnJsonArray;
 exports.constructExecutionMetaData = constructExecutionMetaData;
 exports.normalizeItems = normalizeItems;
 exports.requestWithAuthentication = requestWithAuthentication;
-exports.getAdditionalKeys = getAdditionalKeys;
-exports.getCredentials = getCredentials;
-exports.cleanupParameterData = cleanupParameterData;
-exports.ensureType = ensureType;
-exports.getNodeParameter = getNodeParameter;
-exports.continueOnFail = continueOnFail;
 exports.getNodeWebhookUrl = getNodeWebhookUrl;
 exports.getWebhookDescription = getWebhookDescription;
 exports.getInputConnectionData = getInputConnectionData;
@@ -67,7 +73,6 @@ exports.copyInputItems = copyInputItems;
 exports.getExecutePollFunctions = getExecutePollFunctions;
 exports.getExecuteTriggerFunctions = getExecuteTriggerFunctions;
 exports.getExecuteFunctions = getExecuteFunctions;
-exports.getSupplyDataFunctions = getSupplyDataFunctions;
 exports.getExecuteSingleFunctions = getExecuteSingleFunctions;
 exports.getCredentialTestFunctions = getCredentialTestFunctions;
 exports.getExecuteHookFunctions = getExecuteHookFunctions;
@@ -81,11 +86,11 @@ const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
 const http_1 = require("http");
 const https_1 = require("https");
+const iconv_lite_1 = __importDefault(require("iconv-lite"));
 const get_1 = __importDefault(require("lodash/get"));
 const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
 const merge_1 = __importDefault(require("lodash/merge"));
 const pick_1 = __importDefault(require("lodash/pick"));
-const luxon_1 = require("luxon");
 const mime_types_1 = require("mime-types");
 const n8n_workflow_1 = require("n8n-workflow");
 const oauth_1_0a_1 = __importDefault(require("oauth-1.0a"));
@@ -94,18 +99,14 @@ const qs_1 = require("qs");
 const stream_1 = require("stream");
 const typedi_1 = __importDefault(require("typedi"));
 const url_1 = __importStar(require("url"));
-const Agent_1 = require("./Agent");
 const BinaryData_service_1 = require("./BinaryData/BinaryData.service");
 const utils_1 = require("./BinaryData/utils");
 const Constants_1 = require("./Constants");
 const CreateNodeAsTool_1 = require("./CreateNodeAsTool");
 const data_deduplication_service_1 = require("./data-deduplication-service");
-const ExecutionMetadata_1 = require("./ExecutionMetadata");
-const ExtractValue_1 = require("./ExtractValue");
 const InstanceSettings_1 = require("./InstanceSettings");
 const node_execution_context_1 = require("./node-execution-context");
 const ScheduledTaskManager_1 = require("./ScheduledTaskManager");
-const Secrets_1 = require("./Secrets");
 const SSHClientsManager_1 = require("./SSHClientsManager");
 axios_1.default.defaults.timeout = 300000;
 axios_1.default.defaults.headers.post = {};
@@ -524,7 +525,11 @@ function digestAuthAxiosConfig(axiosConfig, response, auth) {
 function parseHeaderParameters(parameters) {
     return parameters.reduce((acc, param) => {
         const [key, value] = param.split('=');
-        acc[key.toLowerCase().trim()] = decodeURIComponent(value);
+        let decodedValue = decodeURIComponent(value).trim();
+        if (decodedValue.startsWith('"') && decodedValue.endsWith('"')) {
+            decodedValue = decodedValue.slice(1, -1);
+        }
+        acc[key.toLowerCase().trim()] = decodedValue;
         return acc;
     }, {});
 }
@@ -538,16 +543,6 @@ function parseContentType(contentType) {
         parameters: { charset: 'utf-8', ...parseHeaderParameters(parameters) },
     };
 }
-function parseFileName(filename) {
-    if (filename?.startsWith('"') && filename?.endsWith('"')) {
-        return filename.slice(1, -1);
-    }
-    return filename;
-}
-function parseFileNameStar(filename) {
-    const [_encoding, _locale, content] = parseFileName(filename)?.split("'") ?? [];
-    return content;
-}
 function parseContentDisposition(contentDisposition) {
     if (!contentDisposition) {
         return null;
@@ -557,10 +552,13 @@ function parseContentDisposition(contentDisposition) {
     }
     const [type, ...parameters] = contentDisposition.split(';');
     const parsedParameters = parseHeaderParameters(parameters);
-    return {
-        type,
-        filename: parseFileNameStar(parsedParameters['filename*']) ?? parseFileName(parsedParameters.filename),
-    };
+    let { filename } = parsedParameters;
+    const wildcard = parsedParameters['filename*'];
+    if (wildcard) {
+        const [_encoding, _locale, content] = wildcard?.split("'") ?? [];
+        filename = content;
+    }
+    return { type, filename };
 }
 function parseIncomingMessage(message) {
     const contentType = parseContentType(message.headers['content-type']);
@@ -575,12 +573,12 @@ function parseIncomingMessage(message) {
     }
 }
 async function binaryToString(body, encoding) {
-    const buffer = await (0, utils_1.binaryToBuffer)(body);
     if (!encoding && body instanceof http_1.IncomingMessage) {
         parseIncomingMessage(body);
         encoding = body.encoding;
     }
-    return buffer.toString(encoding);
+    const buffer = await (0, utils_1.binaryToBuffer)(body);
+    return iconv_lite_1.default.decode(buffer, encoding ?? 'utf-8');
 }
 async function proxyRequestToAxios(workflow, additionalData, node, uriOrObject, options) {
     let axiosConfig = {
@@ -1319,375 +1317,6 @@ async function requestWithAuthentication(credentialsType, requestOptions, workfl
         }
     }
 }
-function getAdditionalKeys(additionalData, mode, runExecutionData, options) {
-    const executionId = additionalData.executionId || Constants_1.PLACEHOLDER_EMPTY_EXECUTION_ID;
-    const resumeUrl = `${additionalData.webhookWaitingBaseUrl}/${executionId}`;
-    const resumeFormUrl = `${additionalData.formWaitingBaseUrl}/${executionId}`;
-    return {
-        $execution: {
-            id: executionId,
-            mode: mode === 'manual' ? 'test' : 'production',
-            resumeUrl,
-            resumeFormUrl,
-            customData: runExecutionData
-                ? {
-                    set(key, value) {
-                        try {
-                            (0, ExecutionMetadata_1.setWorkflowExecutionMetadata)(runExecutionData, key, value);
-                        }
-                        catch (e) {
-                            if (mode === 'manual') {
-                                throw e;
-                            }
-                            n8n_workflow_1.LoggerProxy.debug(e.message);
-                        }
-                    },
-                    setAll(obj) {
-                        try {
-                            (0, ExecutionMetadata_1.setAllWorkflowExecutionMetadata)(runExecutionData, obj);
-                        }
-                        catch (e) {
-                            if (mode === 'manual') {
-                                throw e;
-                            }
-                            n8n_workflow_1.LoggerProxy.debug(e.message);
-                        }
-                    },
-                    get(key) {
-                        return (0, ExecutionMetadata_1.getWorkflowExecutionMetadata)(runExecutionData, key);
-                    },
-                    getAll() {
-                        return (0, ExecutionMetadata_1.getAllWorkflowExecutionMetadata)(runExecutionData);
-                    },
-                }
-                : undefined,
-        },
-        $vars: additionalData.variables,
-        $secrets: options?.secretsEnabled ? (0, Secrets_1.getSecretsProxy)(additionalData) : undefined,
-        $executionId: executionId,
-        $resumeWebhookUrl: resumeUrl,
-    };
-}
-async function getCredentials(workflow, node, type, additionalData, mode, executeData, runExecutionData, runIndex, connectionInputData, itemIndex) {
-    const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
-    if (nodeType === undefined) {
-        throw new n8n_workflow_1.NodeOperationError(node, `Node type "${node.type}" is not known so can not get credentials`);
-    }
-    const fullAccess = [Constants_1.HTTP_REQUEST_NODE_TYPE, Constants_1.HTTP_REQUEST_TOOL_NODE_TYPE].includes(node.type);
-    let nodeCredentialDescription;
-    if (!fullAccess) {
-        if (nodeType.description.credentials === undefined) {
-            throw new n8n_workflow_1.NodeOperationError(node, `Node type "${node.type}" does not have any credentials defined`, { level: 'warning' });
-        }
-        nodeCredentialDescription = nodeType.description.credentials.find((credentialTypeDescription) => credentialTypeDescription.name === type);
-        if (nodeCredentialDescription === undefined) {
-            throw new n8n_workflow_1.NodeOperationError(node, `Node type "${node.type}" does not have any credentials of type "${type}" defined`, { level: 'warning' });
-        }
-        if (!n8n_workflow_1.NodeHelpers.displayParameter(additionalData.currentNodeParameters || node.parameters, nodeCredentialDescription, node, node.parameters)) {
-            throw new n8n_workflow_1.NodeOperationError(node, 'Credentials not found');
-        }
-    }
-    if (!fullAccess && !node.credentials?.[type]) {
-        if (nodeCredentialDescription?.required === true) {
-            if (!node.credentials) {
-                throw new n8n_workflow_1.NodeOperationError(node, 'Node does not have any credentials set', {
-                    level: 'warning',
-                });
-            }
-            if (!node.credentials[type]) {
-                throw new n8n_workflow_1.NodeOperationError(node, `Node does not have any credentials set for "${type}"`, {
-                    level: 'warning',
-                });
-            }
-        }
-        else {
-            throw new n8n_workflow_1.NodeOperationError(node, 'Node does not require credentials');
-        }
-    }
-    if (fullAccess && !node.credentials?.[type]) {
-        throw new n8n_workflow_1.NodeOperationError(node, 'Credentials not found');
-    }
-    let expressionResolveValues;
-    if (connectionInputData && runExecutionData && runIndex !== undefined) {
-        expressionResolveValues = {
-            connectionInputData,
-            itemIndex: itemIndex || 0,
-            node,
-            runExecutionData,
-            runIndex,
-            workflow,
-        };
-    }
-    const nodeCredentials = node.credentials
-        ? node.credentials[type]
-        : {};
-    const decryptedDataObject = await additionalData.credentialsHelper.getDecrypted(additionalData, nodeCredentials, type, mode, executeData, false, expressionResolveValues);
-    return decryptedDataObject;
-}
-function cleanupParameterData(inputData) {
-    if (typeof inputData !== 'object' || inputData === null) {
-        return;
-    }
-    if (Array.isArray(inputData)) {
-        inputData.forEach((value) => cleanupParameterData(value));
-        return;
-    }
-    if (typeof inputData === 'object') {
-        Object.keys(inputData).forEach((key) => {
-            const value = inputData[key];
-            if (typeof value === 'object') {
-                if (luxon_1.DateTime.isDateTime(value)) {
-                    inputData[key] = value.toString();
-                }
-                else {
-                    cleanupParameterData(value);
-                }
-            }
-        });
-    }
-}
-const validateResourceMapperValue = (parameterName, paramValues, node, skipRequiredCheck = false) => {
-    const result = { valid: true, newValue: paramValues };
-    const paramNameParts = parameterName.split('.');
-    if (paramNameParts.length !== 2) {
-        return result;
-    }
-    const resourceMapperParamName = paramNameParts[0];
-    const resourceMapperField = node.parameters[resourceMapperParamName];
-    if (!resourceMapperField || !(0, n8n_workflow_1.isResourceMapperValue)(resourceMapperField)) {
-        return result;
-    }
-    const schema = resourceMapperField.schema;
-    const paramValueNames = Object.keys(paramValues);
-    for (let i = 0; i < paramValueNames.length; i++) {
-        const key = paramValueNames[i];
-        const resolvedValue = paramValues[key];
-        const schemaEntry = schema.find((s) => s.id === key);
-        if (!skipRequiredCheck &&
-            schemaEntry?.required === true &&
-            schemaEntry.type !== 'boolean' &&
-            !resolvedValue) {
-            return {
-                valid: false,
-                errorMessage: `The value "${String(key)}" is required but not set`,
-                fieldName: key,
-            };
-        }
-        if (schemaEntry?.type) {
-            const validationResult = (0, n8n_workflow_1.validateFieldType)(key, resolvedValue, schemaEntry.type, {
-                valueOptions: schemaEntry.options,
-            });
-            if (!validationResult.valid) {
-                return { ...validationResult, fieldName: key };
-            }
-            else {
-                paramValues[key] = validationResult.newValue;
-            }
-        }
-    }
-    return result;
-};
-const validateCollection = (node, runIndex, itemIndex, propertyDescription, parameterPath, validationResult) => {
-    let nestedDescriptions;
-    if (propertyDescription.type === 'fixedCollection') {
-        nestedDescriptions = propertyDescription.options.find((entry) => entry.name === parameterPath[1])?.values;
-    }
-    if (propertyDescription.type === 'collection') {
-        nestedDescriptions = propertyDescription.options;
-    }
-    if (!nestedDescriptions) {
-        return validationResult;
-    }
-    const validationMap = {};
-    for (const prop of nestedDescriptions) {
-        if (!prop.validateType || prop.ignoreValidationDuringExecution)
-            continue;
-        validationMap[prop.name] = {
-            type: prop.validateType,
-            displayName: prop.displayName,
-            options: prop.validateType === 'options' ? prop.options : undefined,
-        };
-    }
-    if (!Object.keys(validationMap).length) {
-        return validationResult;
-    }
-    if (validationResult.valid) {
-        for (const value of Array.isArray(validationResult.newValue)
-            ? validationResult.newValue
-            : [validationResult.newValue]) {
-            for (const key of Object.keys(value)) {
-                if (!validationMap[key])
-                    continue;
-                const fieldValidationResult = (0, n8n_workflow_1.validateFieldType)(key, value[key], validationMap[key].type, {
-                    valueOptions: validationMap[key].options,
-                });
-                if (!fieldValidationResult.valid) {
-                    throw new n8n_workflow_1.ExpressionError(`Invalid input for field '${validationMap[key].displayName}' inside '${propertyDescription.displayName}' in [item ${itemIndex}]`, {
-                        description: fieldValidationResult.errorMessage,
-                        runIndex,
-                        itemIndex,
-                        nodeCause: node.name,
-                    });
-                }
-                value[key] = fieldValidationResult.newValue;
-            }
-        }
-    }
-    return validationResult;
-};
-const validateValueAgainstSchema = (node, nodeType, parameterValue, parameterName, runIndex, itemIndex) => {
-    const parameterPath = parameterName.split('.');
-    const propertyDescription = nodeType.description.properties.find((prop) => parameterPath[0] === prop.name && n8n_workflow_1.NodeHelpers.displayParameter(node.parameters, prop, node));
-    if (!propertyDescription) {
-        return parameterValue;
-    }
-    let validationResult = { valid: true, newValue: parameterValue };
-    if (parameterPath.length === 1 &&
-        propertyDescription.validateType &&
-        !propertyDescription.ignoreValidationDuringExecution) {
-        validationResult = (0, n8n_workflow_1.validateFieldType)(parameterName, parameterValue, propertyDescription.validateType);
-    }
-    else if (propertyDescription.type === 'resourceMapper' &&
-        parameterPath[1] === 'value' &&
-        typeof parameterValue === 'object') {
-        validationResult = validateResourceMapperValue(parameterName, parameterValue, node, propertyDescription.typeOptions?.resourceMapper?.mode !== 'add');
-    }
-    else if (['fixedCollection', 'collection'].includes(propertyDescription.type)) {
-        validationResult = validateCollection(node, runIndex, itemIndex, propertyDescription, parameterPath, validationResult);
-    }
-    if (!validationResult.valid) {
-        throw new n8n_workflow_1.ExpressionError(`Invalid input for '${validationResult.fieldName
-            ? String(validationResult.fieldName)
-            : propertyDescription.displayName}' [item ${itemIndex}]`, {
-            description: validationResult.errorMessage,
-            runIndex,
-            itemIndex,
-            nodeCause: node.name,
-        });
-    }
-    return validationResult.newValue;
-};
-exports.validateValueAgainstSchema = validateValueAgainstSchema;
-function ensureType(toType, parameterValue, parameterName, errorOptions) {
-    let returnData = parameterValue;
-    if (returnData === null) {
-        throw new n8n_workflow_1.ExpressionError(`Parameter '${parameterName}' must not be null`, errorOptions);
-    }
-    if (returnData === undefined) {
-        throw new n8n_workflow_1.ExpressionError(`Parameter '${parameterName}' could not be 'undefined'`, errorOptions);
-    }
-    if (['object', 'array', 'json'].includes(toType)) {
-        if (typeof returnData !== 'object') {
-            if (typeof returnData === 'string' && returnData.length) {
-                try {
-                    const parsedValue = JSON.parse(returnData);
-                    returnData = parsedValue;
-                }
-                catch (error) {
-                    throw new n8n_workflow_1.ExpressionError(`Parameter '${parameterName}' could not be parsed`, {
-                        ...errorOptions,
-                        description: error.message,
-                    });
-                }
-            }
-            else {
-                throw new n8n_workflow_1.ExpressionError(`Parameter '${parameterName}' must be an ${toType}, but we got '${String(parameterValue)}'`, errorOptions);
-            }
-        }
-        else if (toType === 'json') {
-            try {
-                JSON.stringify(returnData);
-            }
-            catch (error) {
-                throw new n8n_workflow_1.ExpressionError(`Parameter '${parameterName}' is not valid JSON`, {
-                    ...errorOptions,
-                    description: error.message,
-                });
-            }
-        }
-        if (toType === 'array' && !Array.isArray(returnData)) {
-            throw new n8n_workflow_1.ExpressionError(`Parameter '${parameterName}' must be an array, but we got object`, errorOptions);
-        }
-    }
-    try {
-        if (toType === 'string') {
-            if (typeof returnData === 'object') {
-                returnData = JSON.stringify(returnData);
-            }
-            else {
-                returnData = String(returnData);
-            }
-        }
-        if (toType === 'number') {
-            returnData = Number(returnData);
-            if (Number.isNaN(returnData)) {
-                throw new n8n_workflow_1.ExpressionError(`Parameter '${parameterName}' must be a number, but we got '${parameterValue}'`, errorOptions);
-            }
-        }
-        if (toType === 'boolean') {
-            returnData = Boolean(returnData);
-        }
-    }
-    catch (error) {
-        if (error instanceof n8n_workflow_1.ExpressionError)
-            throw error;
-        throw new n8n_workflow_1.ExpressionError(`Parameter '${parameterName}' could not be converted to ${toType}`, {
-            ...errorOptions,
-            description: error.message,
-        });
-    }
-    return returnData;
-}
-function getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, additionalKeys, executeData, fallbackValue, options) {
-    const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
-    if (nodeType === undefined) {
-        throw new n8n_workflow_1.ApplicationError('Node type is unknown so cannot return parameter value', {
-            tags: { nodeType: node.type },
-        });
-    }
-    const value = (0, get_1.default)(node.parameters, parameterName, fallbackValue);
-    if (value === undefined) {
-        throw new n8n_workflow_1.ApplicationError('Could not get parameter', { extra: { parameterName } });
-    }
-    if (options?.rawExpressions) {
-        return value;
-    }
-    let returnData;
-    try {
-        returnData = workflow.expression.getParameterValue(value, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, additionalKeys, executeData, false, {}, options?.contextNode?.name);
-        cleanupParameterData(returnData);
-    }
-    catch (e) {
-        if (e instanceof n8n_workflow_1.ExpressionError && node.continueOnFail && node.type === 'n8n-nodes-base.set') {
-            returnData = [{ name: undefined, value: undefined }];
-        }
-        else {
-            if (e.context)
-                e.context.parameter = parameterName;
-            e.cause = value;
-            throw e;
-        }
-    }
-    if (options?.extractValue) {
-        returnData = (0, ExtractValue_1.extractValue)(returnData, parameterName, node, nodeType, itemIndex);
-    }
-    if (options?.ensureType) {
-        returnData = ensureType(options.ensureType, returnData, parameterName, {
-            itemIndex,
-            runIndex,
-            nodeCause: node.name,
-        });
-    }
-    returnData = (0, exports.validateValueAgainstSchema)(node, nodeType, returnData, parameterName, runIndex, itemIndex);
-    return returnData;
-}
-function continueOnFail(node) {
-    const onError = (0, get_1.default)(node, 'onError', undefined);
-    if (onError === undefined) {
-        return (0, get_1.default)(node, 'continueOnFail', false);
-    }
-    return ['continueRegularOutput', 'continueErrorOutput'].includes(onError);
-}
 function getNodeWebhookUrl(name, workflow, node, additionalData, mode, additionalKeys, isTest) {
     let baseUrl = additionalData.webhookBaseUrl;
     if (isTest === true) {
@@ -1796,6 +1425,7 @@ const addExecutionDataFunctions = async (type, nodeName, data, runExecutionData,
         });
     }
 };
+exports.addExecutionDataFunctions = addExecutionDataFunctions;
 async function getInputConnectionData(workflow, runExecutionData, runIndex, connectionInputData, inputData, additionalData, executeData, mode, closeFunctions, inputName, itemIndex, abortSignal) {
     const node = this.getNode();
     const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
@@ -1830,7 +1460,7 @@ async function getInputConnectionData(workflow, runExecutionData, runIndex, conn
         .filter((connectedNode) => connectedNode.disabled !== true)
         .map(async (connectedNode) => {
         const nodeType = workflow.nodeTypes.getByNameAndVersion(connectedNode.type, connectedNode.typeVersion);
-        const context = getSupplyDataFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, connectedNode, additionalData, executeData, mode, closeFunctions, abortSignal);
+        const context = new node_execution_context_1.SupplyDataContext(workflow, connectedNode, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executeData, closeFunctions, abortSignal);
         if (!nodeType.supplyData) {
             if (nodeType.description.outputs.includes("ai_tool")) {
                 nodeType.supplyData = async function () {
@@ -1862,7 +1492,7 @@ async function getInputConnectionData(workflow, runExecutionData, runIndex, conn
             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);
+            await (0, exports.addExecutionDataFunctions)('input', connectedNode.name, error, runExecutionData, inputName, additionalData, node.name, runIndex, currentNodeRunIndex);
             throw new n8n_workflow_1.NodeOperationError(connectedNode, `Error in sub-node ${connectedNode.name}`, {
                 itemIndex,
                 functionality: 'configuration-node',
@@ -1882,60 +1512,6 @@ async function getInputConnectionData(workflow, runExecutionData, runIndex, conn
         ? (nodes || [])[0]?.response
         : nodes.map((node) => node.response);
 }
-const getCommonWorkflowFunctions = (workflow, node, additionalData) => ({
-    logger: n8n_workflow_1.LoggerProxy,
-    getExecutionId: () => additionalData.executionId,
-    getNode: () => (0, n8n_workflow_1.deepCopy)(node),
-    getWorkflow: () => ({
-        id: workflow.id,
-        name: workflow.name,
-        active: workflow.active,
-    }),
-    getWorkflowStaticData: (type) => workflow.getStaticData(type, node),
-    getChildNodes: (nodeName) => {
-        const output = [];
-        const nodes = workflow.getChildNodes(nodeName);
-        for (const nodeName of nodes) {
-            const node = workflow.nodes[nodeName];
-            output.push({
-                name: node.name,
-                type: node.type,
-                typeVersion: node.typeVersion,
-            });
-        }
-        return output;
-    },
-    getParentNodes: (nodeName) => {
-        const output = [];
-        const nodes = workflow.getParentNodes(nodeName);
-        for (const nodeName of nodes) {
-            const node = workflow.nodes[nodeName];
-            output.push({
-                name: node.name,
-                type: node.type,
-                typeVersion: node.typeVersion,
-            });
-        }
-        return output;
-    },
-    getKnownNodeTypes: () => workflow.nodeTypes.getKnownTypes(),
-    getRestApiUrl: () => additionalData.restApiUrl,
-    getInstanceBaseUrl: () => additionalData.instanceBaseUrl,
-    getInstanceId: () => typedi_1.default.get(InstanceSettings_1.InstanceSettings).instanceId,
-    getTimezone: () => workflow.timezone,
-    getCredentialsProperties: (type) => additionalData.credentialsHelper.getCredentialsProperties(type),
-    prepareOutputData: async (outputData) => [outputData],
-});
-const executionCancellationFunctions = (abortSignal) => ({
-    getExecutionCancelSignal: () => abortSignal,
-    onExecutionCancellation: (handler) => {
-        const fn = () => {
-            abortSignal?.removeEventListener('abort', fn);
-            handler();
-        };
-        abortSignal?.addEventListener('abort', fn);
-    },
-});
 const getRequestHelperFunctions = (workflow, node, additionalData, runExecutionData = null, connectionInputData = []) => {
     const getResolvedValue = (parameterValue, itemIndex, runIndex, executeData, additionalKeys, returnObjectAsString = false) => {
         const mode = 'internal';
@@ -2250,303 +1826,7 @@ function getExecuteTriggerFunctions(workflow, node, additionalData, mode, activa
     return new node_execution_context_1.TriggerContext(workflow, node, additionalData, mode, activation);
 }
 function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, node, additionalData, executeData, mode, closeFunctions, abortSignal) {
-    return ((workflow, runExecutionData, connectionInputData, inputData, node) => {
-        return {
-            ...getCommonWorkflowFunctions(workflow, node, additionalData),
-            ...executionCancellationFunctions(abortSignal),
-            getMode: () => mode,
-            getCredentials: async (type, itemIndex) => await getCredentials(workflow, node, type, additionalData, mode, executeData, runExecutionData, runIndex, connectionInputData, itemIndex),
-            getExecuteData: () => executeData,
-            setMetadata: (metadata) => {
-                executeData.metadata = {
-                    ...(executeData.metadata ?? {}),
-                    ...metadata,
-                };
-            },
-            continueOnFail: () => {
-                return continueOnFail(node);
-            },
-            evaluateExpression(expression, itemIndex) {
-                return workflow.expression.resolveSimpleParameterValue(`=${expression}`, {}, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData);
-            },
-            async executeWorkflow(workflowInfo, inputData, parentCallbackManager, options) {
-                return await additionalData
-                    .executeWorkflow(workflowInfo, additionalData, {
-                    ...options,
-                    parentWorkflowId: workflow.id?.toString(),
-                    inputData,
-                    parentWorkflowSettings: workflow.settings,
-                    node,
-                    parentCallbackManager,
-                })
-                    .then(async (result) => {
-                    const data = await typedi_1.default.get(BinaryData_service_1.BinaryDataService).duplicateBinaryData(workflow.id, additionalData.executionId, result.data);
-                    return { ...result, data };
-                });
-            },
-            getContext(type) {
-                return n8n_workflow_1.NodeHelpers.getContext(runExecutionData, type, node);
-            },
-            async getInputConnectionData(inputName, itemIndex) {
-                return await getInputConnectionData.call(this, workflow, runExecutionData, runIndex, connectionInputData, inputData, additionalData, executeData, mode, closeFunctions, inputName, itemIndex, abortSignal);
-            },
-            getNodeInputs() {
-                const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
-                return n8n_workflow_1.NodeHelpers.getNodeInputs(workflow, node, nodeType.description).map((output) => {
-                    if (typeof output === 'string') {
-                        return {
-                            type: output,
-                        };
-                    }
-                    return output;
-                });
-            },
-            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 [];
-                }
-                if (inputData[inputName].length < inputIndex) {
-                    throw new n8n_workflow_1.ApplicationError('Could not get input with given index', {
-                        extra: { inputIndex, inputName },
-                    });
-                }
-                if (inputData[inputName][inputIndex] === null) {
-                    throw new n8n_workflow_1.ApplicationError('Value of input was not set', {
-                        extra: { inputIndex, inputName },
-                    });
-                }
-                return inputData[inputName][inputIndex];
-            },
-            getInputSourceData: (inputIndex = 0, inputName = 'main') => {
-                if (executeData?.source === null) {
-                    throw new n8n_workflow_1.ApplicationError('Source data is missing');
-                }
-                return executeData.source[inputName][inputIndex];
-            },
-            getNodeParameter: (parameterName, itemIndex, fallbackValue, options) => {
-                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData, fallbackValue, options);
-            },
-            getWorkflowDataProxy: (itemIndex) => {
-                const dataProxy = new n8n_workflow_1.WorkflowDataProxy(workflow, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, {}, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData);
-                return dataProxy.getDataProxy();
-            },
-            async putExecutionToWait(waitTill) {
-                runExecutionData.waitTill = waitTill;
-                if (additionalData.setExecutionStatus) {
-                    additionalData.setExecutionStatus('waiting');
-                }
-            },
-            logNodeOutput(...args) {
-                if (mode === 'manual') {
-                    this.sendMessageToUI(...args);
-                    return;
-                }
-                if (process.env.CODE_ENABLE_STDOUT === 'true') {
-                    console.log(`[Workflow "${this.getWorkflow().id}"][Node "${node.name}"]`, ...args);
-                }
-            },
-            sendMessageToUI(...args) {
-                if (mode !== 'manual') {
-                    return;
-                }
-                try {
-                    if (additionalData.sendDataToUI) {
-                        args = args.map((arg) => {
-                            if (arg.isLuxonDateTime && arg.invalidReason)
-                                return { ...arg };
-                            if (arg.isLuxonDateTime)
-                                return new Date(arg.ts).toString();
-                            if (arg instanceof Date)
-                                return arg.toString();
-                            return arg;
-                        });
-                        additionalData.sendDataToUI('sendConsoleMessage', {
-                            source: `[Node: "${node.name}"]`,
-                            messages: args,
-                        });
-                    }
-                }
-                catch (error) {
-                    n8n_workflow_1.LoggerProxy.warn(`There was a problem sending message to UI: ${error.message}`);
-                }
-            },
-            async sendResponse(response) {
-                await additionalData.hooks?.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, metadata) {
-                addExecutionDataFunctions('output', this.getNode().name, data, runExecutionData, connectionType, additionalData, node.name, runIndex, currentNodeRunIndex, metadata).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,
-                ...(0, exports.getRequestHelperFunctions)(workflow, node, additionalData, runExecutionData, connectionInputData),
-                ...(0, exports.getSSHTunnelFunctions)(),
-                ...(0, exports.getFileSystemHelperFunctions)(node),
-                ...(0, exports.getBinaryHelperFunctions)(additionalData, workflow.id),
-                ...(0, exports.getCheckProcessedHelperFunctions)(workflow, node),
-                assertBinaryData: (itemIndex, propertyName) => assertBinaryData(inputData, node, itemIndex, propertyName, 0),
-                getBinaryDataBuffer: async (itemIndex, propertyName) => await getBinaryDataBuffer(inputData, itemIndex, propertyName, 0),
-                returnJsonArray,
-                normalizeItems,
-                constructExecutionMetaData,
-            },
-            nodeHelpers: (0, exports.getNodeHelperFunctions)(additionalData, workflow.id),
-            logAiEvent: (eventName, msg) => {
-                return additionalData.logAiEvent(eventName, {
-                    executionId: additionalData.executionId ?? 'unsaved-execution',
-                    nodeName: node.name,
-                    workflowName: workflow.name ?? 'Unnamed workflow',
-                    nodeType: node.type,
-                    workflowId: workflow.id ?? 'unsaved-workflow',
-                    msg,
-                });
-            },
-            getParentCallbackManager: () => additionalData.parentCallbackManager,
-            startJob: (0, Agent_1.createAgentStartJob)(additionalData, inputData, node, workflow, runExecutionData, runIndex, node.name, connectionInputData, {}, mode, executeData),
-        };
-    })(workflow, runExecutionData, connectionInputData, inputData, node);
-}
-function getSupplyDataFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, node, additionalData, executeData, mode, closeFunctions, abortSignal) {
-    return {
-        ...getCommonWorkflowFunctions(workflow, node, additionalData),
-        ...executionCancellationFunctions(abortSignal),
-        getMode: () => mode,
-        getCredentials: async (type, itemIndex) => await getCredentials(workflow, node, type, additionalData, mode, executeData, runExecutionData, runIndex, connectionInputData, itemIndex),
-        continueOnFail: () => continueOnFail(node),
-        evaluateExpression: (expression, itemIndex) => workflow.expression.resolveSimpleParameterValue(`=${expression}`, {}, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData),
-        executeWorkflow: async (workflowInfo, inputData, parentCallbackManager, options) => await additionalData
-            .executeWorkflow(workflowInfo, additionalData, {
-            parentWorkflowId: workflow.id?.toString(),
-            inputData,
-            parentWorkflowSettings: workflow.settings,
-            node,
-            parentCallbackManager,
-            ...options,
-        })
-            .then(async (result) => {
-            const data = await typedi_1.default.get(BinaryData_service_1.BinaryDataService).duplicateBinaryData(workflow.id, additionalData.executionId, result.data);
-            return { ...result, data };
-        }),
-        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;
-            });
-        },
-        async getInputConnectionData(inputName, itemIndex) {
-            return await getInputConnectionData.call(this, workflow, runExecutionData, runIndex, connectionInputData, inputData, additionalData, executeData, mode, closeFunctions, inputName, itemIndex, abortSignal);
-        },
-        getInputData: (inputIndex = 0, inputName = 'main') => {
-            if (!inputData.hasOwnProperty(inputName)) {
-                return [];
-            }
-            if (inputData[inputName].length < inputIndex) {
-                throw new n8n_workflow_1.ApplicationError('Could not get input with given index', {
-                    extra: { inputIndex, inputName },
-                });
-            }
-            if (inputData[inputName][inputIndex] === null) {
-                throw new n8n_workflow_1.ApplicationError('Value of input was not set', {
-                    extra: { inputIndex, inputName },
-                });
-            }
-            return inputData[inputName][inputIndex];
-        },
-        getNodeParameter: ((parameterName, itemIndex, fallbackValue, options) => getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData, fallbackValue, options)),
-        getWorkflowDataProxy: (itemIndex) => new n8n_workflow_1.WorkflowDataProxy(workflow, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, {}, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData).getDataProxy(),
-        sendMessageToUI(...args) {
-            if (mode !== 'manual') {
-                return;
-            }
-            try {
-                if (additionalData.sendDataToUI) {
-                    args = args.map((arg) => {
-                        if (arg.isLuxonDateTime && arg.invalidReason)
-                            return { ...arg };
-                        if (arg.isLuxonDateTime)
-                            return new Date(arg.ts).toString();
-                        if (arg instanceof Date)
-                            return arg.toString();
-                        return arg;
-                    });
-                    additionalData.sendDataToUI('sendConsoleMessage', {
-                        source: `[Node: "${node.name}"]`,
-                        messages: args,
-                    });
-                }
-            }
-            catch (error) {
-                n8n_workflow_1.LoggerProxy.warn(`There was a problem sending message to UI: ${error.message}`);
-            }
-        },
-        logAiEvent: (eventName, msg) => additionalData.logAiEvent(eventName, {
-            executionId: additionalData.executionId ?? 'unsaved-execution',
-            nodeName: node.name,
-            workflowName: workflow.name ?? 'Unnamed workflow',
-            nodeType: node.type,
-            workflowId: workflow.id ?? 'unsaved-workflow',
-            msg,
-        }),
-        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, metadata) {
-            addExecutionDataFunctions('output', this.getNode().name, data, runExecutionData, connectionType, additionalData, node.name, runIndex, currentNodeRunIndex, metadata).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,
-            ...(0, exports.getRequestHelperFunctions)(workflow, node, additionalData, runExecutionData, connectionInputData),
-            ...(0, exports.getSSHTunnelFunctions)(),
-            ...(0, exports.getFileSystemHelperFunctions)(node),
-            ...(0, exports.getBinaryHelperFunctions)(additionalData, workflow.id),
-            ...(0, exports.getCheckProcessedHelperFunctions)(workflow, node),
-            assertBinaryData: (itemIndex, propertyName) => assertBinaryData(inputData, node, itemIndex, propertyName, 0),
-            getBinaryDataBuffer: async (itemIndex, propertyName) => await getBinaryDataBuffer(inputData, itemIndex, propertyName, 0),
-            returnJsonArray,
-            normalizeItems,
-            constructExecutionMetaData,
-        },
-    };
+    return new node_execution_context_1.ExecuteContext(workflow, node, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, executeData, closeFunctions, abortSignal);
 }
 function getExecuteSingleFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, node, itemIndex, additionalData, executeData, mode, abortSignal) {
     return new node_execution_context_1.ExecuteSingleContext(workflow, node, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, itemIndex, executeData, abortSignal);