n8n-core 1.66.0 → 1.67.1

package/dist/NodeExecuteFunctions.d.ts

@@ -1,12 +1,16 @@
 import type { AxiosRequestConfig } from 'axios';
 import { IncomingMessage } from 'http';
-import type { CloseFunction, IAdditionalCredentialOptions, IAllExecuteFunctions, IBinaryData, ICredentialDataDecryptedObject, ICredentialTestFunctions, IDataObject, IExecuteData, IExecuteFunctions, IExecuteSingleFunctions, IGetNodeParameterOptions, IHookFunctions, IHttpRequestOptions, ILoadOptionsFunctions, INode, INodeExecutionData, INodeType, IOAuth2Options, IPairedItemData, IPollFunctions, IRequestOptions, IRunExecutionData, ITaskDataConnections, ITriggerFunctions, IWebhookData, IWebhookDescription, IWebhookFunctions, IWorkflowDataProxyAdditionalKeys, IWorkflowExecuteAdditionalData, NodeExecutionWithMetadata, NodeParameterValueType, Workflow, WorkflowActivateMode, WorkflowExecuteMode, EnsureTypeOptions, IDeduplicationOutput, IDeduplicationOutputItems, ICheckProcessedOptions, DeduplicationScope, DeduplicationItemTypes, ICheckProcessedContextData, ISupplyDataFunctions } from 'n8n-workflow';
+import type { BinaryHelperFunctions, CloseFunction, FileSystemHelperFunctions, IAdditionalCredentialOptions, IAllExecuteFunctions, IBinaryData, ICredentialDataDecryptedObject, ICredentialTestFunctions, IDataObject, IExecuteData, IExecuteFunctions, IExecuteSingleFunctions, IGetNodeParameterOptions, IHookFunctions, IHttpRequestOptions, IN8nHttpFullResponse, IN8nHttpResponse, INode, INodeExecutionData, INodeType, IOAuth2Options, IPairedItemData, IPollFunctions, IRequestOptions, IRunExecutionData, ITaskDataConnections, ITriggerFunctions, IWebhookData, IWebhookDescription, IWebhookFunctions, IWorkflowDataProxyAdditionalKeys, IWorkflowExecuteAdditionalData, NodeExecutionWithMetadata, NodeHelperFunctions, NodeParameterValueType, PaginationOptions, RequestHelperFunctions, Workflow, WorkflowActivateMode, WorkflowExecuteMode, EnsureTypeOptions, SSHTunnelFunctions, DeduplicationHelperFunctions, IDeduplicationOutput, IDeduplicationOutputItems, ICheckProcessedOptions, DeduplicationScope, DeduplicationItemTypes, ICheckProcessedContextData, ISupplyDataFunctions, WebhookType, SchedulingFunctions } from 'n8n-workflow';
+import { NodeConnectionType } from 'n8n-workflow';
 import { Readable } from 'stream';
 import type { BinaryData } from './BinaryData/types';
+export declare const validateUrl: (url?: string) => boolean;
 export declare function parseRequestObject(requestObject: IRequestOptions): Promise<AxiosRequestConfig<any>>;
 export declare function parseIncomingMessage(message: IncomingMessage): void;
+export declare function binaryToString(body: Buffer | Readable, encoding?: BufferEncoding): Promise<string>;
 export declare function proxyRequestToAxios(workflow: Workflow | undefined, additionalData: IWorkflowExecuteAdditionalData | undefined, node: INode | undefined, uriOrObject: string | IRequestOptions, options?: IRequestOptions): Promise<any>;
 export declare const removeEmptyBody: (requestOptions: IHttpRequestOptions | IRequestOptions) => void;
+export declare function httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
 export declare function getBinaryPath(binaryDataId: string): string;
 export declare function getBinaryMetadata(binaryDataId: string): Promise<BinaryData.Metadata>;
 export declare function getBinaryStream(binaryDataId: string, chunkSize?: number): Promise<Readable>;
@@ -14,11 +18,13 @@ export declare function assertBinaryData(inputData: ITaskDataConnections, node:
 export declare function getBinaryDataBuffer(inputData: ITaskDataConnections, itemIndex: number, propertyName: string, inputIndex: number): Promise<Buffer>;
 export declare function setBinaryDataBuffer(binaryData: IBinaryData, bufferOrStream: Buffer | Readable, workflowId: string, executionId: string): Promise<IBinaryData>;
 export declare function copyBinaryFile(workflowId: string, executionId: string, filePath: string, fileName: string, mimeType?: string): Promise<IBinaryData>;
+export declare function prepareBinaryData(binaryData: Buffer | Readable, executionId: string, workflowId: string, filePath?: string, mimeType?: string): Promise<IBinaryData>;
 export declare function checkProcessedAndRecord(items: DeduplicationItemTypes[], scope: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<IDeduplicationOutput>;
 export declare function checkProcessedItemsAndRecord(key: string, items: IDataObject[], scope: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<IDeduplicationOutputItems>;
 export declare function removeProcessed(items: DeduplicationItemTypes[], scope: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<void>;
 export declare function clearAllProcessedItems(scope: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<void>;
 export declare function getProcessedDataCount(scope: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<number>;
+export declare function applyPaginationRequestData(requestData: IRequestOptions, paginationRequestData: PaginationOptions['request']): IRequestOptions;
 export declare function requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions | IRequestOptions, node: INode, additionalData: IWorkflowExecuteAdditionalData, oAuth2Options?: IOAuth2Options, isN8nRequest?: boolean): Promise<any>;
 export declare function requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions | IRequestOptions, isN8nRequest?: boolean): Promise<any>;
 export declare function httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<any>;
@@ -41,9 +47,17 @@ export declare function ensureType(toType: EnsureTypeOptions, parameterValue: an
 }): string | number | boolean | object;
 export declare function getNodeParameter(workflow: Workflow, runExecutionData: IRunExecutionData | null, runIndex: number, connectionInputData: INodeExecutionData[], node: INode, parameterName: string, itemIndex: number, mode: WorkflowExecuteMode, additionalKeys: IWorkflowDataProxyAdditionalKeys, executeData?: IExecuteData, fallbackValue?: any, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
 export declare function continueOnFail(node: INode): boolean;
-export declare function getNodeWebhookUrl(name: string, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, additionalKeys: IWorkflowDataProxyAdditionalKeys, isTest?: boolean): string | undefined;
-export declare function getWebhookDescription(name: string, workflow: Workflow, node: INode): IWebhookDescription | undefined;
+export declare function getNodeWebhookUrl(name: WebhookType, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, additionalKeys: IWorkflowDataProxyAdditionalKeys, isTest?: boolean): string | undefined;
+export declare function getWebhookDescription(name: WebhookType, workflow: Workflow, node: INode): IWebhookDescription | undefined;
+export declare function getInputConnectionData(this: IAllExecuteFunctions, workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, additionalData: IWorkflowExecuteAdditionalData, executeData: IExecuteData, mode: WorkflowExecuteMode, closeFunctions: CloseFunction[], inputName: NodeConnectionType, itemIndex: number, abortSignal?: AbortSignal): Promise<unknown>;
+export declare const getRequestHelperFunctions: (workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, runExecutionData?: IRunExecutionData | null, connectionInputData?: INodeExecutionData[]) => RequestHelperFunctions;
+export declare const getSSHTunnelFunctions: () => SSHTunnelFunctions;
+export declare const getSchedulingFunctions: (workflow: Workflow) => SchedulingFunctions;
 export declare function isFilePathBlocked(filePath: string): boolean;
+export declare const getFileSystemHelperFunctions: (node: INode) => FileSystemHelperFunctions;
+export declare const getNodeHelperFunctions: ({ executionId }: IWorkflowExecuteAdditionalData, workflowId: string) => NodeHelperFunctions;
+export declare const getBinaryHelperFunctions: ({ executionId }: IWorkflowExecuteAdditionalData, workflowId: string) => BinaryHelperFunctions;
+export declare const getCheckProcessedHelperFunctions: (workflow: Workflow, node: INode) => DeduplicationHelperFunctions;
 export declare function copyInputItems(items: INodeExecutionData[], properties: string[]): IDataObject[];
 export declare function getExecutePollFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): IPollFunctions;
 export declare function getExecuteTriggerFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): ITriggerFunctions;
@@ -51,6 +65,5 @@ export declare function getExecuteFunctions(workflow: Workflow, runExecutionData
 export declare function getSupplyDataFunctions(workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, additionalData: IWorkflowExecuteAdditionalData, executeData: IExecuteData, mode: WorkflowExecuteMode, closeFunctions: CloseFunction[], abortSignal?: AbortSignal): ISupplyDataFunctions;
 export declare function getExecuteSingleFunctions(workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, itemIndex: number, additionalData: IWorkflowExecuteAdditionalData, executeData: IExecuteData, mode: WorkflowExecuteMode, abortSignal?: AbortSignal): IExecuteSingleFunctions;
 export declare function getCredentialTestFunctions(): ICredentialTestFunctions;
-export declare function getLoadOptionsFunctions(workflow: Workflow, node: INode, path: string, additionalData: IWorkflowExecuteAdditionalData): ILoadOptionsFunctions;
 export declare function getExecuteHookFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode, webhookData?: IWebhookData): IHookFunctions;
 export declare function getExecuteWebhookFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, webhookData: IWebhookData, closeFunctions: CloseFunction[], runExecutionData: IRunExecutionData | null): IWebhookFunctions;

package/dist/NodeExecuteFunctions.js

@@ -26,10 +26,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateValueAgainstSchema = exports.removeEmptyBody = void 0;
+exports.getCheckProcessedHelperFunctions = exports.getBinaryHelperFunctions = exports.getNodeHelperFunctions = exports.getFileSystemHelperFunctions = exports.getSchedulingFunctions = exports.getSSHTunnelFunctions = exports.getRequestHelperFunctions = exports.validateValueAgainstSchema = exports.removeEmptyBody = exports.validateUrl = void 0;
 exports.parseRequestObject = parseRequestObject;
 exports.parseIncomingMessage = parseIncomingMessage;
+exports.binaryToString = binaryToString;
 exports.proxyRequestToAxios = proxyRequestToAxios;
+exports.httpRequest = httpRequest;
 exports.getBinaryPath = getBinaryPath;
 exports.getBinaryMetadata = getBinaryMetadata;
 exports.getBinaryStream = getBinaryStream;
@@ -37,11 +39,13 @@ exports.assertBinaryData = assertBinaryData;
 exports.getBinaryDataBuffer = getBinaryDataBuffer;
 exports.setBinaryDataBuffer = setBinaryDataBuffer;
 exports.copyBinaryFile = copyBinaryFile;
+exports.prepareBinaryData = prepareBinaryData;
 exports.checkProcessedAndRecord = checkProcessedAndRecord;
 exports.checkProcessedItemsAndRecord = checkProcessedItemsAndRecord;
 exports.removeProcessed = removeProcessed;
 exports.clearAllProcessedItems = clearAllProcessedItems;
 exports.getProcessedDataCount = getProcessedDataCount;
+exports.applyPaginationRequestData = applyPaginationRequestData;
 exports.requestOAuth2 = requestOAuth2;
 exports.requestOAuth1 = requestOAuth1;
 exports.httpRequestWithAuthentication = httpRequestWithAuthentication;
@@ -57,6 +61,7 @@ exports.getNodeParameter = getNodeParameter;
 exports.continueOnFail = continueOnFail;
 exports.getNodeWebhookUrl = getNodeWebhookUrl;
 exports.getWebhookDescription = getWebhookDescription;
+exports.getInputConnectionData = getInputConnectionData;
 exports.isFilePathBlocked = isFilePathBlocked;
 exports.copyInputItems = copyInputItems;
 exports.getExecutePollFunctions = getExecutePollFunctions;
@@ -65,7 +70,6 @@ exports.getExecuteFunctions = getExecuteFunctions;
 exports.getSupplyDataFunctions = getSupplyDataFunctions;
 exports.getExecuteSingleFunctions = getExecuteSingleFunctions;
 exports.getCredentialTestFunctions = getCredentialTestFunctions;
-exports.getLoadOptionsFunctions = getLoadOptionsFunctions;
 exports.getExecuteHookFunctions = getExecuteHookFunctions;
 exports.getExecuteWebhookFunctions = getExecuteWebhookFunctions;
 const client_oauth2_1 = require("@n8n/client-oauth2");
@@ -99,6 +103,7 @@ 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");
@@ -153,6 +158,7 @@ const validateUrl = (url) => {
         return false;
     }
 };
+exports.validateUrl = validateUrl;
 function searchForHeader(config, headerName) {
     if (config.headers === undefined) {
         return undefined;
@@ -1964,7 +1970,7 @@ const getRequestHelperFunctions = (workflow, node, additionalData, runExecutionD
             do {
                 paginateRequestData = getResolvedValue(paginationOptions.request, itemIndex, runIndex, executeData, additionalKeys, false);
                 const tempRequestOptions = applyPaginationRequestData(requestOptions, paginateRequestData);
-                if (!validateUrl(tempRequestOptions.uri)) {
+                if (!(0, exports.validateUrl)(tempRequestOptions.uri)) {
                     throw new n8n_workflow_1.NodeOperationError(node, `'${paginateRequestData.url}' is not a valid URL.`, {
                         itemIndex,
                         runIndex,
@@ -2084,15 +2090,18 @@ const getRequestHelperFunctions = (workflow, node, additionalData, runExecutionD
         },
     };
 };
+exports.getRequestHelperFunctions = getRequestHelperFunctions;
 const getSSHTunnelFunctions = () => ({
     getSSHClient: async (credentials) => await typedi_1.default.get(SSHClientsManager_1.SSHClientsManager).getClient(credentials),
 });
+exports.getSSHTunnelFunctions = getSSHTunnelFunctions;
 const getSchedulingFunctions = (workflow) => {
     const scheduledTaskManager = typedi_1.default.get(ScheduledTaskManager_1.ScheduledTaskManager);
     return {
         registerCron: (cronExpression, onTick) => scheduledTaskManager.registerCron(workflow, cronExpression, onTick),
     };
 };
+exports.getSchedulingFunctions = getSchedulingFunctions;
 const getAllowedPaths = () => {
     const restrictFileAccessTo = process.env[Constants_1.RESTRICT_FILE_ACCESS_TO];
     if (!restrictFileAccessTo) {
@@ -2177,9 +2186,11 @@ const getFileSystemHelperFunctions = (node) => ({
         return await (0, promises_1.writeFile)(filePath, content, { encoding: 'binary', flag });
     },
 });
+exports.getFileSystemHelperFunctions = getFileSystemHelperFunctions;
 const getNodeHelperFunctions = ({ executionId }, workflowId) => ({
     copyBinaryFile: async (filePath, fileName, mimeType) => await copyBinaryFile(workflowId, executionId, filePath, fileName, mimeType),
 });
+exports.getNodeHelperFunctions = getNodeHelperFunctions;
 const getBinaryHelperFunctions = ({ executionId }, workflowId) => ({
     getBinaryPath,
     getBinaryStream,
@@ -2192,6 +2203,7 @@ const getBinaryHelperFunctions = ({ executionId }, workflowId) => ({
         throw new n8n_workflow_1.ApplicationError('`copyBinaryFile` has been removed. Please upgrade this node.');
     },
 });
+exports.getBinaryHelperFunctions = getBinaryHelperFunctions;
 const getCheckProcessedHelperFunctions = (workflow, node) => ({
     async checkProcessedAndRecord(items, scope, options) {
         return await checkProcessedAndRecord(items, scope, { node, workflow }, options);
@@ -2209,6 +2221,7 @@ const getCheckProcessedHelperFunctions = (workflow, node) => ({
         return await getProcessedDataCount(scope, { node, workflow }, options);
     },
 });
+exports.getCheckProcessedHelperFunctions = getCheckProcessedHelperFunctions;
 function copyInputItems(items, properties) {
     return items.map((item) => {
         const newItem = {};
@@ -2224,65 +2237,10 @@ function copyInputItems(items, properties) {
     });
 }
 function getExecutePollFunctions(workflow, node, additionalData, mode, activation) {
-    return ((workflow, node) => {
-        return {
-            ...getCommonWorkflowFunctions(workflow, node, additionalData),
-            __emit: () => {
-                throw new n8n_workflow_1.ApplicationError('Overwrite NodeExecuteFunctions.getExecutePollFunctions.__emit function');
-            },
-            __emitError() {
-                throw new n8n_workflow_1.ApplicationError('Overwrite NodeExecuteFunctions.getExecutePollFunctions.__emitError function');
-            },
-            getMode: () => mode,
-            getActivationMode: () => activation,
-            getCredentials: async (type) => await getCredentials(workflow, node, type, additionalData, mode),
-            getNodeParameter: (parameterName, fallbackValue, options) => {
-                const runExecutionData = null;
-                const itemIndex = 0;
-                const runIndex = 0;
-                const connectionInputData = [];
-                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData, mode, runExecutionData), undefined, fallbackValue, options);
-            },
-            helpers: {
-                createDeferredPromise: n8n_workflow_1.createDeferredPromise,
-                ...getRequestHelperFunctions(workflow, node, additionalData),
-                ...getBinaryHelperFunctions(additionalData, workflow.id),
-                ...getSchedulingFunctions(workflow),
-                returnJsonArray,
-            },
-        };
-    })(workflow, node);
+    return new node_execution_context_1.PollContext(workflow, node, additionalData, mode, activation);
 }
 function getExecuteTriggerFunctions(workflow, node, additionalData, mode, activation) {
-    return ((workflow, node) => {
-        return {
-            ...getCommonWorkflowFunctions(workflow, node, additionalData),
-            emit: () => {
-                throw new n8n_workflow_1.ApplicationError('Overwrite NodeExecuteFunctions.getExecuteTriggerFunctions.emit function');
-            },
-            emitError: () => {
-                throw new n8n_workflow_1.ApplicationError('Overwrite NodeExecuteFunctions.getExecuteTriggerFunctions.emit function');
-            },
-            getMode: () => mode,
-            getActivationMode: () => activation,
-            getCredentials: async (type) => await getCredentials(workflow, node, type, additionalData, mode),
-            getNodeParameter: (parameterName, fallbackValue, options) => {
-                const runExecutionData = null;
-                const itemIndex = 0;
-                const runIndex = 0;
-                const connectionInputData = [];
-                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData, mode, runExecutionData), undefined, fallbackValue, options);
-            },
-            helpers: {
-                createDeferredPromise: n8n_workflow_1.createDeferredPromise,
-                ...getSSHTunnelFunctions(),
-                ...getRequestHelperFunctions(workflow, node, additionalData),
-                ...getBinaryHelperFunctions(additionalData, workflow.id),
-                ...getSchedulingFunctions(workflow),
-                returnJsonArray,
-            },
-        };
-    })(workflow, node);
+    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) => {
@@ -2428,18 +2386,18 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
             helpers: {
                 createDeferredPromise: n8n_workflow_1.createDeferredPromise,
                 copyInputItems,
-                ...getRequestHelperFunctions(workflow, node, additionalData, runExecutionData, connectionInputData),
-                ...getSSHTunnelFunctions(),
-                ...getFileSystemHelperFunctions(node),
-                ...getBinaryHelperFunctions(additionalData, workflow.id),
-                ...getCheckProcessedHelperFunctions(workflow, node),
+                ...(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: getNodeHelperFunctions(additionalData, workflow.id),
+            nodeHelpers: (0, exports.getNodeHelperFunctions)(additionalData, workflow.id),
             logAiEvent: (eventName, msg) => {
                 return additionalData.logAiEvent(eventName, {
                     executionId: additionalData.executionId ?? 'unsaved-execution',
@@ -2556,11 +2514,11 @@ function getSupplyDataFunctions(workflow, runExecutionData, runIndex, connection
         helpers: {
             createDeferredPromise: n8n_workflow_1.createDeferredPromise,
             copyInputItems,
-            ...getRequestHelperFunctions(workflow, node, additionalData, runExecutionData, connectionInputData),
-            ...getSSHTunnelFunctions(),
-            ...getFileSystemHelperFunctions(node),
-            ...getBinaryHelperFunctions(additionalData, workflow.id),
-            ...getCheckProcessedHelperFunctions(workflow, node),
+            ...(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,
@@ -2570,252 +2528,22 @@ function getSupplyDataFunctions(workflow, runExecutionData, runIndex, connection
     };
 }
 function getExecuteSingleFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, node, itemIndex, additionalData, executeData, mode, abortSignal) {
-    return ((workflow, runExecutionData, connectionInputData, inputData, node, itemIndex) => {
-        return {
-            ...getCommonWorkflowFunctions(workflow, node, additionalData),
-            ...executionCancellationFunctions(abortSignal),
-            continueOnFail: () => continueOnFail(node),
-            evaluateExpression: (expression, evaluateItemIndex) => {
-                evaluateItemIndex = evaluateItemIndex === undefined ? itemIndex : evaluateItemIndex;
-                return workflow.expression.resolveSimpleParameterValue(`=${expression}`, {}, runExecutionData, runIndex, evaluateItemIndex, node.name, connectionInputData, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData);
-            },
-            getContext(type) {
-                return n8n_workflow_1.NodeHelpers.getContext(runExecutionData, type, node);
-            },
-            getCredentials: async (type) => await getCredentials(workflow, node, type, additionalData, mode, executeData, runExecutionData, runIndex, connectionInputData, itemIndex),
-            getInputData: (inputIndex = 0, inputName = 'main') => {
-                if (!inputData.hasOwnProperty(inputName)) {
-                    return { json: {} };
-                }
-                if (inputData[inputName].length < inputIndex) {
-                    throw new n8n_workflow_1.ApplicationError('Could not get input index', {
-                        extra: { inputIndex, inputName },
-                    });
-                }
-                const allItems = inputData[inputName][inputIndex];
-                if (allItems === null) {
-                    throw new n8n_workflow_1.ApplicationError('Input index was not set', {
-                        extra: { inputIndex, inputName },
-                    });
-                }
-                if (allItems[itemIndex] === null) {
-                    throw new n8n_workflow_1.ApplicationError('Value of input with given index was not set', {
-                        extra: { inputIndex, inputName, itemIndex },
-                    });
-                }
-                return allItems[itemIndex];
-            },
-            getInputSourceData: (inputIndex = 0, inputName = 'main') => {
-                if (executeData?.source === null) {
-                    throw new n8n_workflow_1.ApplicationError('Source data is missing');
-                }
-                return executeData.source[inputName][inputIndex];
-            },
-            getItemIndex: () => itemIndex,
-            getMode: () => mode,
-            getExecuteData: () => executeData,
-            getNodeParameter: (parameterName, fallbackValue, options) => {
-                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData, fallbackValue, options);
-            },
-            getWorkflowDataProxy: () => {
-                const dataProxy = new n8n_workflow_1.WorkflowDataProxy(workflow, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, {}, mode, getAdditionalKeys(additionalData, mode, runExecutionData), executeData);
-                return dataProxy.getDataProxy();
-            },
-            helpers: {
-                createDeferredPromise: n8n_workflow_1.createDeferredPromise,
-                ...getRequestHelperFunctions(workflow, node, additionalData, runExecutionData, connectionInputData),
-                ...getBinaryHelperFunctions(additionalData, workflow.id),
-                assertBinaryData: (propertyName, inputIndex = 0) => assertBinaryData(inputData, node, itemIndex, propertyName, inputIndex),
-                getBinaryDataBuffer: async (propertyName, inputIndex = 0) => await getBinaryDataBuffer(inputData, itemIndex, propertyName, inputIndex),
-            },
-            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,
-                });
-            },
-        };
-    })(workflow, runExecutionData, connectionInputData, inputData, node, itemIndex);
+    return new node_execution_context_1.ExecuteSingleContext(workflow, node, additionalData, mode, runExecutionData, runIndex, connectionInputData, inputData, itemIndex, executeData, abortSignal);
 }
 function getCredentialTestFunctions() {
     return {
         helpers: {
-            ...getSSHTunnelFunctions(),
+            ...(0, exports.getSSHTunnelFunctions)(),
             request: async (uriOrObject, options) => {
                 return await proxyRequestToAxios(undefined, undefined, undefined, uriOrObject, options);
             },
         },
     };
 }
-function getLoadOptionsFunctions(workflow, node, path, additionalData) {
-    return ((workflow, node, path) => {
-        return {
-            ...getCommonWorkflowFunctions(workflow, node, additionalData),
-            getCredentials: async (type) => await getCredentials(workflow, node, type, additionalData, 'internal'),
-            getCurrentNodeParameter: (parameterPath, options) => {
-                const nodeParameters = additionalData.currentNodeParameters;
-                if (parameterPath.charAt(0) === '&') {
-                    parameterPath = `${path.split('.').slice(1, -1).join('.')}.${parameterPath.slice(1)}`;
-                }
-                let returnData = (0, get_1.default)(nodeParameters, parameterPath);
-                if (options?.extractValue) {
-                    const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
-                    if (nodeType === undefined) {
-                        throw new n8n_workflow_1.ApplicationError('Node type is not known so cannot return parameter value', {
-                            tags: { nodeType: node.type },
-                        });
-                    }
-                    returnData = (0, ExtractValue_1.extractValue)(returnData, parameterPath, node, nodeType);
-                }
-                return returnData;
-            },
-            getCurrentNodeParameters: () => additionalData.currentNodeParameters,
-            getNodeParameter: (parameterName, fallbackValue, options) => {
-                const runExecutionData = null;
-                const itemIndex = 0;
-                const runIndex = 0;
-                const mode = 'internal';
-                const connectionInputData = [];
-                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData, mode, runExecutionData), undefined, fallbackValue, options);
-            },
-            helpers: {
-                ...getSSHTunnelFunctions(),
-                ...getRequestHelperFunctions(workflow, node, additionalData),
-            },
-        };
-    })(workflow, node, path);
-}
 function getExecuteHookFunctions(workflow, node, additionalData, mode, activation, webhookData) {
-    return ((workflow, node) => {
-        return {
-            ...getCommonWorkflowFunctions(workflow, node, additionalData),
-            getCredentials: async (type) => await getCredentials(workflow, node, type, additionalData, mode),
-            getMode: () => mode,
-            getActivationMode: () => activation,
-            getNodeParameter: (parameterName, fallbackValue, options) => {
-                const runExecutionData = null;
-                const itemIndex = 0;
-                const runIndex = 0;
-                const connectionInputData = [];
-                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData, mode, runExecutionData), undefined, fallbackValue, options);
-            },
-            getNodeWebhookUrl: (name) => {
-                return getNodeWebhookUrl(name, workflow, node, additionalData, mode, getAdditionalKeys(additionalData, mode, null), webhookData?.isTest);
-            },
-            getWebhookName() {
-                if (webhookData === undefined) {
-                    throw new n8n_workflow_1.ApplicationError('Only supported in webhook functions');
-                }
-                return webhookData.webhookDescription.name;
-            },
-            getWebhookDescription: (name) => getWebhookDescription(name, workflow, node),
-            helpers: getRequestHelperFunctions(workflow, node, additionalData),
-        };
-    })(workflow, node);
+    return new node_execution_context_1.HookContext(workflow, node, additionalData, mode, activation, webhookData);
 }
 function getExecuteWebhookFunctions(workflow, node, additionalData, mode, webhookData, closeFunctions, runExecutionData) {
-    return ((workflow, node, runExecutionData) => {
-        return {
-            ...getCommonWorkflowFunctions(workflow, node, additionalData),
-            getBodyData() {
-                if (additionalData.httpRequest === undefined) {
-                    throw new n8n_workflow_1.ApplicationError('Request is missing');
-                }
-                return additionalData.httpRequest.body;
-            },
-            getCredentials: async (type) => await getCredentials(workflow, node, type, additionalData, mode),
-            getHeaderData() {
-                if (additionalData.httpRequest === undefined) {
-                    throw new n8n_workflow_1.ApplicationError('Request is missing');
-                }
-                return additionalData.httpRequest.headers;
-            },
-            async getInputConnectionData(inputName, itemIndex) {
-                const connectionInputData = [
-                    { json: additionalData.httpRequest?.body || {} },
-                ];
-                const runExecutionData = {
-                    resultData: {
-                        runData: {},
-                    },
-                };
-                const executeData = {
-                    data: {
-                        main: [connectionInputData],
-                    },
-                    node,
-                    source: null,
-                };
-                const runIndex = 0;
-                return await getInputConnectionData.call(this, workflow, runExecutionData, runIndex, connectionInputData, {}, additionalData, executeData, mode, closeFunctions, inputName, itemIndex);
-            },
-            getMode: () => mode,
-            evaluateExpression: (expression, evaluateItemIndex) => {
-                const itemIndex = evaluateItemIndex === undefined ? 0 : evaluateItemIndex;
-                const runIndex = 0;
-                let connectionInputData = [];
-                let executionData;
-                if (runExecutionData?.executionData !== undefined) {
-                    executionData = runExecutionData.executionData.nodeExecutionStack[0];
-                    if (executionData !== undefined) {
-                        connectionInputData = executionData.data.main[0];
-                    }
-                }
-                const additionalKeys = getAdditionalKeys(additionalData, mode, runExecutionData);
-                return workflow.expression.resolveSimpleParameterValue(`=${expression}`, {}, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, additionalKeys, executionData);
-            },
-            getNodeParameter: (parameterName, fallbackValue, options) => {
-                const itemIndex = 0;
-                const runIndex = 0;
-                let connectionInputData = [];
-                let executionData;
-                if (runExecutionData?.executionData !== undefined) {
-                    executionData = runExecutionData.executionData.nodeExecutionStack[0];
-                    if (executionData !== undefined) {
-                        connectionInputData = executionData.data.main[0];
-                    }
-                }
-                const additionalKeys = getAdditionalKeys(additionalData, mode, runExecutionData);
-                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, additionalKeys, executionData, fallbackValue, options);
-            },
-            getParamsData() {
-                if (additionalData.httpRequest === undefined) {
-                    throw new n8n_workflow_1.ApplicationError('Request is missing');
-                }
-                return additionalData.httpRequest.params;
-            },
-            getQueryData() {
-                if (additionalData.httpRequest === undefined) {
-                    throw new n8n_workflow_1.ApplicationError('Request is missing');
-                }
-                return additionalData.httpRequest.query;
-            },
-            getRequestObject() {
-                if (additionalData.httpRequest === undefined) {
-                    throw new n8n_workflow_1.ApplicationError('Request is missing');
-                }
-                return additionalData.httpRequest;
-            },
-            getResponseObject() {
-                if (additionalData.httpResponse === undefined) {
-                    throw new n8n_workflow_1.ApplicationError('Response is missing');
-                }
-                return additionalData.httpResponse;
-            },
-            getNodeWebhookUrl: (name) => getNodeWebhookUrl(name, workflow, node, additionalData, mode, getAdditionalKeys(additionalData, mode, null)),
-            getWebhookName: () => webhookData.webhookDescription.name,
-            helpers: {
-                createDeferredPromise: n8n_workflow_1.createDeferredPromise,
-                ...getRequestHelperFunctions(workflow, node, additionalData),
-                ...getBinaryHelperFunctions(additionalData, workflow.id),
-                returnJsonArray,
-            },
-            nodeHelpers: getNodeHelperFunctions(additionalData, workflow.id),
-        };
-    })(workflow, node, runExecutionData);
+    return new node_execution_context_1.WebhookContext(workflow, node, additionalData, mode, webhookData, closeFunctions, runExecutionData);
 }
 //# sourceMappingURL=NodeExecuteFunctions.js.map