n8n-core 1.65.0 → 1.67.0

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 } from 'n8n-workflow';
+import type { CloseFunction, 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, NodeParameterValueType, PaginationOptions, Workflow, WorkflowActivateMode, WorkflowExecuteMode, EnsureTypeOptions, IDeduplicationOutput, IDeduplicationOutputItems, ICheckProcessedOptions, DeduplicationScope, DeduplicationItemTypes, ICheckProcessedContextData, ISupplyDataFunctions, WebhookType } 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,15 +47,16 @@ 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 function isFilePathBlocked(filePath: string): boolean;
 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;
 export declare function getExecuteFunctions(workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, additionalData: IWorkflowExecuteAdditionalData, executeData: IExecuteData, mode: WorkflowExecuteMode, closeFunctions: CloseFunction[], abortSignal?: AbortSignal): IExecuteFunctions;
+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.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,14 +61,15 @@ exports.getNodeParameter = getNodeParameter;
 exports.continueOnFail = continueOnFail;
 exports.getNodeWebhookUrl = getNodeWebhookUrl;
 exports.getWebhookDescription = getWebhookDescription;
+exports.getInputConnectionData = getInputConnectionData;
 exports.isFilePathBlocked = isFilePathBlocked;
 exports.copyInputItems = copyInputItems;
 exports.getExecutePollFunctions = getExecutePollFunctions;
 exports.getExecuteTriggerFunctions = getExecuteTriggerFunctions;
 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");
@@ -98,7 +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 ScheduledTaskManager_1 = require("./ScheduledTaskManager");
+const node_execution_context_1 = require("./node-execution-context");
 const Secrets_1 = require("./Secrets");
 const SSHClientsManager_1 = require("./SSHClientsManager");
 axios_1.default.defaults.timeout = 300000;
@@ -152,6 +157,7 @@ const validateUrl = (url) => {
         return false;
     }
 };
+exports.validateUrl = validateUrl;
 function searchForHeader(config, headerName) {
     if (config.headers === undefined) {
         return undefined;
@@ -1782,7 +1788,7 @@ const addExecutionDataFunctions = async (type, nodeName, data, runExecutionData,
         });
     }
 };
-async function getInputConnectionData(workflow, runExecutionData, runIndex, connectionInputData, additionalData, executeData, mode, closeFunctions, inputName, itemIndex) {
+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);
     const inputs = n8n_workflow_1.NodeHelpers.getNodeInputs(workflow, node, nodeType.description);
@@ -1816,26 +1822,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 = Object.assign({}, this);
-        context.getNodeParameter = (parameterName, itemIndex, fallbackValue, options) => {
-            return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, connectedNode, parameterName, itemIndex, mode, 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, executeData, 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;
-            }
-        };
+        const context = getSupplyDataFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, connectedNode, additionalData, executeData, mode, closeFunctions, abortSignal);
         if (!nodeType.supplyData) {
             if (nodeType.description.outputs.includes("ai_tool")) {
                 nodeType.supplyData = async function () {
@@ -1982,7 +1969,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,
@@ -2105,12 +2092,6 @@ const getRequestHelperFunctions = (workflow, node, additionalData, runExecutionD
 const getSSHTunnelFunctions = () => ({
     getSSHClient: async (credentials) => await typedi_1.default.get(SSHClientsManager_1.SSHClientsManager).getClient(credentials),
 });
-const getSchedulingFunctions = (workflow) => {
-    const scheduledTaskManager = typedi_1.default.get(ScheduledTaskManager_1.ScheduledTaskManager);
-    return {
-        registerCron: (cronExpression, onTick) => scheduledTaskManager.registerCron(workflow, cronExpression, onTick),
-    };
-};
 const getAllowedPaths = () => {
     const restrictFileAccessTo = process.env[Constants_1.RESTRICT_FILE_ACCESS_TO];
     if (!restrictFileAccessTo) {
@@ -2242,65 +2223,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) => {
@@ -2313,7 +2239,7 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
             continueOnFail: () => {
                 return continueOnFail(node);
             },
-            evaluateExpression: (expression, itemIndex) => {
+            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) {
@@ -2331,7 +2257,7 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
                 return n8n_workflow_1.NodeHelpers.getContext(runExecutionData, type, node);
             },
             async getInputConnectionData(inputName, itemIndex) {
-                return await getInputConnectionData.call(this, workflow, runExecutionData, runIndex, connectionInputData, additionalData, executeData, mode, closeFunctions, 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);
@@ -2458,7 +2384,7 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
                 constructExecutionMetaData,
             },
             nodeHelpers: getNodeHelperFunctions(additionalData, workflow.id),
-            logAiEvent: async (eventName, msg) => {
+            logAiEvent: (eventName, msg) => {
                 return additionalData.logAiEvent(eventName, {
                     executionId: additionalData.executionId ?? 'unsaved-execution',
                     nodeName: node.name,
@@ -2473,77 +2399,122 @@ function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInp
         };
     })(workflow, runExecutionData, connectionInputData, inputData, node);
 }
-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 },
-                    });
+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) => await additionalData
+            .executeWorkflow(workflowInfo, additionalData, {
+            parentWorkflowId: workflow.id?.toString(),
+            inputData,
+            parentWorkflowSettings: workflow.settings,
+            node,
+            parentCallbackManager,
+        })
+            .then(async (result) => await typedi_1.default.get(BinaryData_service_1.BinaryDataService).duplicateBinaryData(workflow.id, additionalData.executionId, result)),
+        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,
+                    };
                 }
-                const allItems = inputData[inputName][inputIndex];
-                if (allItems === null) {
-                    throw new n8n_workflow_1.ApplicationError('Input index was not set', {
-                        extra: { inputIndex, inputName },
+                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;
                     });
-                }
-                if (allItems[itemIndex] === null) {
-                    throw new n8n_workflow_1.ApplicationError('Value of input with given index was not set', {
-                        extra: { inputIndex, inputName, itemIndex },
+                    additionalData.sendDataToUI('sendConsoleMessage', {
+                        source: `[Node: "${node.name}"]`,
+                        messages: args,
                     });
                 }
-                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: async (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);
+            }
+            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) {
+            addExecutionDataFunctions('output', this.getNode().name, data, runExecutionData, connectionType, additionalData, node.name, runIndex, currentNodeRunIndex).catch((error) => {
+                n8n_workflow_1.LoggerProxy.warn(`There was a problem logging output data of node "${this.getNode().name}": ${error.message}`);
+            });
+        },
+        helpers: {
+            createDeferredPromise: n8n_workflow_1.createDeferredPromise,
+            copyInputItems,
+            ...getRequestHelperFunctions(workflow, node, additionalData, runExecutionData, connectionInputData),
+            ...getSSHTunnelFunctions(),
+            ...getFileSystemHelperFunctions(node),
+            ...getBinaryHelperFunctions(additionalData, workflow.id),
+            ...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,
+        },
+    };
+}
+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);
 }
 function getCredentialTestFunctions() {
     return {
@@ -2555,171 +2526,10 @@ function getCredentialTestFunctions() {
         },
     };
 }
-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