@fsai-flow/core 0.0.1

package/src/lib/NodeExecuteFunctions.ts

@@ -0,0 +1,3704 @@
+import {
+	GenericValue,
+	IAdditionalCredentialOptions,
+	IAllExecuteFunctions,
+	IBinaryData,
+	IContextObject,
+	ICredentialDataDecryptedObject,
+	ICredentialsExpressionResolveValues,
+	IDataObject,
+	IExecuteFunctions,
+	IExecuteResponsePromiseData,
+	IExecuteSingleFunctions,
+	IExecuteWorkflowInfo,
+	IHttpRequestOptions,
+	IN8nHttpFullResponse,
+	IN8nHttpResponse,
+	INode,
+	INodeCredentialDescription,
+	INodeCredentialsDetails,
+	INodeExecutionData,
+	INodeParameters,
+	INodeType,
+	IOAuth2Options,
+	IPollFunctions,
+	IRunExecutionData,
+	ITaskDataConnections,
+	ITriggerFunctions,
+	IWebhookData,
+	IWebhookDescription,
+	IWebhookFunctions,
+	IWorkflowDataProxyAdditionalKeys,
+	IWorkflowDataProxyData,
+	IWorkflowExecuteAdditionalData,
+	IWorkflowMetadata,
+	NodeApiError,
+	NodeHelpers,
+	NodeOperationError,
+	NodeParameterValue,
+	Workflow,
+	WorkflowActivateMode,
+	WorkflowDataProxy,
+	WorkflowExecuteMode,
+	LoggerProxy as Logger,
+	JsonObject,
+	NodeParameterValueType,
+	IGetNodeParameterOptions,
+	NodeTypeAndVersion,
+	IExecuteData,
+	ISupplyDataFunctions,
+	NodeConnectionType,
+	ExecutionError,
+	ITaskMetadata,
+	INodeInputConfiguration,
+	INodeTypeDescription,
+	SupplyData,
+	CloseFunction,
+	AiEvent,
+	AINodeConnectionType,
+	ITaskData,
+} from '@fsai-flow/workflow';
+
+import { Agent } from 'https';
+import { stringify } from 'qs';
+const clientOAuth1 = require('oauth-1.0a');
+import { Token } from 'oauth-1.0a';
+
+import ClientOAuth2, { Data, RequestObject } from 'client-oauth2';
+import { AuthorizationCode, ClientCredentials, AccessToken, ModuleOptions } from 'simple-oauth2';
+
+import * as crypto from 'crypto';
+import * as url from 'url';
+import { get } from 'lodash';
+import { Request, Response } from 'express';
+const FormData = require('form-data');
+import * as path from 'path';
+import { OptionsWithUri, OptionsWithUrl } from 'request';
+import * as requestPromise from 'request-promise-native';
+import { createHmac } from 'crypto';
+import { fromBuffer } from 'file-type';
+import { lookup } from 'mime-types';
+
+
+import axios, {
+	AxiosPromise,
+	AxiosProxyConfig,
+	AxiosRequestConfig,
+	AxiosResponse,
+	Method,
+} from 'axios';
+import { URL, URLSearchParams } from 'url';
+import { BinaryDataManager } from './BinaryDataManager';
+import {
+	ICredentialTestFunctions,
+	IHookFunctions,
+	ILoadOptionsFunctions,
+	IResponseError,
+	IWorkflowSettings,
+	PLACEHOLDER_EMPTY_EXECUTION_ID,
+} from '../../src';
+import { arrayBuffer } from 'stream/consumers';
+import { promises as fs } from 'fs';
+
+axios.defaults.timeout = 900000;
+// Prevent axios from adding x-form-www-urlencoded headers by default
+axios.defaults.headers.post = {};
+axios.defaults.headers.put = {};
+axios.defaults.headers.patch = {};
+axios.defaults.paramsSerializer = (params) => {
+	if (params instanceof URLSearchParams) {
+		return params.toString();
+	}
+	return stringify(params, { arrayFormat: 'indices' });
+};
+
+const pushFormDataValue = (form: FormData, key: string, value: any) => {
+	// eslint-disable-next-line no-prototype-builtins
+	if (value?.hasOwnProperty('value') && Object.prototype.hasOwnProperty.call(value, 'options')) {
+		// @ts-ignore
+		form.append(key, value.value, value.options);
+	} else {
+		form.append(key, value);
+	}
+};
+
+const createFormDataObject = (data: object) => {
+	const formData = new FormData();
+	const keys = Object.keys(data);
+	keys.forEach((key) => {
+		// @ts-ignore
+		const formField = data[key];
+
+		if (formField instanceof Array) {
+			formField.forEach((item) => {
+				pushFormDataValue(formData, key, item);
+			});
+		} else {
+			pushFormDataValue(formData, key, formField);
+		}
+	});
+	return formData;
+};
+
+function searchForHeader(headers: IDataObject, headerName: string) {
+	if (headers === undefined) {
+		return undefined;
+	}
+
+	const headerNames = Object.keys(headers);
+	headerName = headerName.toLowerCase();
+	return headerNames.find((thisHeader) => thisHeader.toLowerCase() === headerName);
+}
+
+async function generateContentLengthHeader(formData: any, headers: IDataObject) {
+	if (!formData || !formData.getLength) {
+		return;
+	}
+	try {
+		const length = await new Promise((res, rej) => {
+			formData.getLength((error: Error | null, length: number) => {
+				if (error) {
+					rej(error);
+					return;
+				}
+				res(length);
+			});
+		});
+		headers = Object.assign(headers, {
+			'content-length': length,
+		});
+	} catch (error) {
+		Logger.error('Unable to calculate form data length', { error });
+	}
+}
+
+async function parseRequestObject(requestObject: IDataObject) {
+	// This function is a temporary implementation
+	// That translates all http requests done via
+	// the request library to axios directly
+	// We are not using n8n's interface as it would
+	// an unnecessary step, considering the `request`
+	// helper can be deprecated and removed.
+	const axiosConfig: AxiosRequestConfig = {};
+
+	if (typeof requestObject['headers'] === 'object' && requestObject['headers'] !== null) {
+		axiosConfig.headers = requestObject['headers'] as any;
+	}
+
+	// Let's start parsing the hardest part, which is the request body.
+	// The process here is as following?
+	// - Check if we have a `content-type` header. If this was set,
+	//   we will follow
+	// - Check if the `form` property was set. If yes, then it's x-www-form-urlencoded
+	// - Check if the `formData` property exists. If yes, then it's multipart/form-data
+	// - Lastly, we should have a regular `body` that is probably a JSON.
+
+	const contentTypeHeaderKeyName =
+		axiosConfig.headers &&
+		Object.keys(axiosConfig.headers).find(
+			(headerName) => headerName.toLowerCase() === 'content-type',
+		);
+	const contentType =
+		contentTypeHeaderKeyName &&
+		axiosConfig.headers &&
+		(axiosConfig.headers[contentTypeHeaderKeyName] as unknown as string | undefined);
+
+	if (contentType === 'application/x-www-form-urlencoded' && requestObject['formData'] === undefined) {
+		// there are nodes incorrectly created, informing the content type header
+		// and also using formData. Request lib takes precedence for the formData.
+		// We will do the same.
+		// Merge body and form properties.
+		if (typeof requestObject['body'] === 'string') {
+			axiosConfig.data = requestObject['body'];
+		} else {
+			const allData = Object.assign(requestObject['body'] || {}, requestObject['form'] || {}) as Record<
+				string,
+				string
+			>;
+			if (requestObject['useQuerystring'] === true) {
+				axiosConfig.data = stringify(allData, { arrayFormat: 'repeat' });
+			} else {
+				axiosConfig.data = stringify(allData);
+			}
+		}
+	} else if (contentType && contentType.includes('multipart/form-data') !== false) {
+		if (requestObject['formData'] !== undefined && requestObject['formData'] instanceof FormData) {
+			axiosConfig.data = requestObject['formData'];
+		} else {
+			const allData = {
+				...(requestObject['body'] as object | undefined),
+				...(requestObject['formData'] as object | undefined),
+			};
+
+			axiosConfig.data = createFormDataObject(allData);
+		}
+		// replace the existing header with a new one that
+		// contains the boundary property.
+		// @ts-ignore
+		delete axiosConfig.headers[contentTypeHeaderKeyName];
+		const headers = axiosConfig.data.getHeaders();
+		axiosConfig.headers = Object.assign(axiosConfig.headers || {}, headers);
+		if (!axiosConfig.headers) {
+			axiosConfig.headers = {};
+		}
+		await generateContentLengthHeader(axiosConfig.data, axiosConfig.headers as IDataObject);
+	} else {
+		// When using the `form` property it means the content should be x-www-form-urlencoded.
+		if (requestObject['form'] !== undefined && requestObject['body'] === undefined) {
+			// If we have only form
+			axiosConfig.data =
+				typeof requestObject['form'] === 'string'
+					? stringify(requestObject['form'], { format: 'RFC3986' })
+					: stringify(requestObject['form']).toString();
+
+			if (axiosConfig.headers !== undefined) {
+				const headerName = searchForHeader(axiosConfig.headers, 'content-type');
+				if (headerName) {
+					delete axiosConfig.headers[headerName];
+				}
+				axiosConfig.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+			} else {
+				axiosConfig.headers = {
+					'Content-Type': 'application/x-www-form-urlencoded',
+				};
+			}
+		} else if (requestObject['formData'] !== undefined) {
+			// remove any "content-type" that might exist.
+			if (axiosConfig.headers !== undefined) {
+				const headers = Object.keys(axiosConfig.headers);
+				headers.forEach((header) =>
+					header.toLowerCase() === 'content-type' && axiosConfig.headers ? delete axiosConfig.headers[header] : null,
+				);
+			}
+
+			if (requestObject['formData'] instanceof FormData) {
+				axiosConfig.data = requestObject['formData'];
+			} else {
+				axiosConfig.data = createFormDataObject(requestObject['formData'] as object);
+			}
+			// Mix in headers as FormData creates the boundary.
+			const headers = axiosConfig.data.getHeaders();
+			axiosConfig.headers = Object.assign(axiosConfig.headers || {}, headers);
+			await generateContentLengthHeader(axiosConfig.data, axiosConfig.headers as IDataObject);
+		} else if (requestObject['body'] !== undefined) {
+			// If we have body and possibly form
+			if (requestObject['form'] !== undefined) {
+				// merge both objects when exist.
+				if (requestObject['body'] && requestObject['form']) {
+					requestObject['body'] = Object.assign(requestObject['body'], requestObject['form']);
+				}
+			}
+			axiosConfig.data = requestObject['body'] as FormData | GenericValue | GenericValue[];
+		}
+	}
+
+	if (requestObject['uri'] !== undefined) {
+		axiosConfig.url = requestObject['uri']?.toString() as string;
+	}
+
+	if (requestObject['url'] !== undefined) {
+		axiosConfig.url = requestObject['url']?.toString() as string;
+	}
+
+	if (requestObject['baseURL'] !== undefined) {
+		axiosConfig.baseURL = requestObject['baseURL']?.toString() as string;
+	}
+
+	if (requestObject['method'] !== undefined) {
+		axiosConfig.method = requestObject['method'] as Method;
+	}
+
+	if (requestObject['qs'] !== undefined && Object.keys(requestObject['qs'] as object).length > 0) {
+		axiosConfig.params = requestObject['qs'] as IDataObject;
+	}
+
+	if (
+		requestObject['useQuerystring'] === true ||
+		// @ts-ignore
+		requestObject.qsStringifyOptions?.arrayFormat === 'repeat'
+	) {
+		axiosConfig.paramsSerializer = (params) => {
+			return stringify(params, { arrayFormat: 'repeat' });
+		};
+	} else if (requestObject['useQuerystring'] === false) {
+		axiosConfig.paramsSerializer = (params) => {
+			return stringify(params, { arrayFormat: 'indices' });
+		};
+	}
+
+	// @ts-ignore
+	if (requestObject.qsStringifyOptions?.arrayFormat === 'brackets') {
+		axiosConfig.paramsSerializer = (params) => {
+			return stringify(params, { arrayFormat: 'brackets' });
+		};
+	}
+
+	if (requestObject['auth'] !== undefined) {
+		// Check support for sendImmediately
+		if ((requestObject['auth'] as IDataObject)['bearer'] !== undefined) {
+			axiosConfig.headers = Object.assign(axiosConfig.headers || {}, {
+				// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+				Authorization: `Bearer ${(requestObject['auth'] as IDataObject)['bearer']}`,
+			});
+		} else {
+			const authObj = requestObject['auth'] as IDataObject;
+			// Request accepts both user/username and pass/password
+			axiosConfig.auth = {
+				username: (authObj['user'] || authObj['username']) as string,
+				password: (authObj['password'] || authObj['pass']) as string,
+			};
+		}
+	}
+
+	// Only set header if we have a body, otherwise it may fail
+	if (requestObject['json'] === true) {
+		// Add application/json headers - do not set charset as it breaks a lot of stuff
+		// only add if no other accept headers was sent.
+		const acceptHeaderExists =
+			axiosConfig.headers === undefined
+				? false
+				: Object.keys(axiosConfig.headers)
+					.map((headerKey) => headerKey.toLowerCase())
+					.includes('accept');
+		if (!acceptHeaderExists) {
+			axiosConfig.headers = Object.assign(axiosConfig.headers || {}, {
+				Accept: 'application/json',
+			});
+		}
+	}
+	if (requestObject['json'] === false || requestObject['json'] === undefined) {
+		// Prevent json parsing
+		axiosConfig.transformResponse = (res) => res;
+	}
+
+	// Axios will follow redirects by default, so we simply tell it otherwise if needed.
+	if (
+		requestObject['followRedirect'] === false &&
+		((requestObject['method'] as string | undefined) || 'get').toLowerCase() === 'get'
+	) {
+		axiosConfig.maxRedirects = 0;
+	}
+	if (
+		requestObject['followAllRedirects'] === false &&
+		((requestObject['method'] as string | undefined) || 'get').toLowerCase() !== 'get'
+	) {
+		axiosConfig.maxRedirects = 0;
+	}
+
+	if (requestObject['rejectUnauthorized'] === false) {
+		axiosConfig.httpsAgent = new Agent({
+			rejectUnauthorized: false,
+		});
+	}
+
+	if (requestObject['timeout'] !== undefined) {
+		axiosConfig.timeout = requestObject['timeout'] as number;
+	}
+
+	if (requestObject['proxy'] !== undefined) {
+		// try our best to parse the url provided.
+		if (typeof requestObject['proxy'] === 'string') {
+			try {
+				const url = new URL(requestObject['proxy']);
+				axiosConfig.proxy = {
+					host: url.hostname,
+					port: parseInt(url.port, 10),
+					protocol: url.protocol,
+				};
+				if (!url.port) {
+					// Sets port to a default if not informed
+					if (url.protocol === 'http') {
+						axiosConfig.proxy.port = 80;
+					} else if (url.protocol === 'https') {
+						axiosConfig.proxy.port = 443;
+					}
+				}
+				if (url.username || url.password) {
+					axiosConfig.proxy.auth = {
+						username: url.username,
+						password: url.password,
+					};
+				}
+			} catch (error) {
+				// Not a valid URL. We will try to simply parse stuff
+				// such as user:pass@host:port without protocol (we'll assume http)
+				if (requestObject['proxy'].includes('@')) {
+					const [userpass, hostport] = requestObject['proxy'].split('@');
+					const [username, password] = userpass.split(':');
+					const [hostname, port] = hostport.split(':');
+					axiosConfig.proxy = {
+						host: hostname,
+						port: parseInt(port, 10),
+						protocol: 'http',
+						auth: {
+							username,
+							password,
+						},
+					};
+				} else if (requestObject['proxy'].includes(':')) {
+					const [hostname, port] = requestObject['proxy'].split(':');
+					axiosConfig.proxy = {
+						host: hostname,
+						port: parseInt(port, 10),
+						protocol: 'http',
+					};
+				} else {
+					axiosConfig.proxy = {
+						host: requestObject['proxy'],
+						port: 80,
+						protocol: 'http',
+					};
+				}
+			}
+		} else {
+			axiosConfig.proxy = requestObject['proxy'] as AxiosProxyConfig;
+		}
+	}
+
+	if (requestObject['encoding'] === null) {
+		// When downloading files, return an arrayBuffer.
+		axiosConfig.responseType = 'arraybuffer';
+	}
+
+	// If we don't set an accept header
+	// Axios forces "application/json, text/plan, */*"
+	// Which causes some nodes like NextCloud to break
+	// as the service returns XML unless requested otherwise.
+	const allHeaders = axiosConfig.headers ? Object.keys(axiosConfig.headers) : [];
+	if (!allHeaders.some((headerKey) => headerKey.toLowerCase() === 'accept')) {
+		axiosConfig.headers = Object.assign(axiosConfig.headers || {}, { accept: '*/*' });
+	}
+	if (
+		requestObject['json'] !== false &&
+		axiosConfig.data !== undefined &&
+		axiosConfig.data !== '' &&
+		!(axiosConfig.data instanceof Buffer) &&
+		!allHeaders.some((headerKey) => headerKey.toLowerCase() === 'content-type')
+	) {
+		// Use default header for application/json
+		// If we don't specify this here, axios will add
+		// application/json; charset=utf-8
+		// and this breaks a lot of stuff
+		axiosConfig.headers = Object.assign(axiosConfig.headers || {}, {
+			'content-type': 'application/json',
+		});
+	}
+
+	/**
+	 * Missing properties:
+	 * encoding (need testing)
+	 * gzip (ignored - default already works)
+	 * resolveWithFullResponse (implemented elsewhere)
+	 * simple (???)
+	 */
+
+	return axiosConfig;
+}
+
+function digestAuthAxiosConfig(
+	axiosConfig: AxiosRequestConfig,
+	response: AxiosResponse,
+	auth: AxiosRequestConfig['auth'],
+): AxiosRequestConfig {
+	const authDetails = response.headers['www-authenticate']
+		.split(',')
+		.map((v: string) => v.split('='));
+	if (authDetails) {
+		const nonceCount = `000000001`;
+		const cnonce = crypto.randomBytes(24).toString('hex');
+		const realm: string = authDetails
+			.find((el: any) => el[0].toLowerCase().indexOf('realm') > -1)[1]
+			.replace(/"/g, '');
+		const opaque: string = authDetails
+			.find((el: any) => el[0].toLowerCase().indexOf('opaque') > -1)[1]
+			.replace(/"/g, '');
+		const nonce: string = authDetails
+			.find((el: any) => el[0].toLowerCase().indexOf('nonce') > -1)[1]
+			.replace(/"/g, '');
+		const ha1 = crypto
+			.createHash('md5')
+			.update(`${auth?.username as string}:${realm}:${auth?.password as string}`)
+			.digest('hex');
+		const path = new url.URL(axiosConfig.url!).pathname;
+		const ha2 = crypto
+			.createHash('md5')
+			.update(`${axiosConfig.method ?? 'GET'}:${path}`)
+			.digest('hex');
+		const response = crypto
+			.createHash('md5')
+			.update(`${ha1}:${nonce}:${nonceCount}:${cnonce}:auth:${ha2}`)
+			.digest('hex');
+		const authorization =
+			`Digest username="${auth?.username as string}",realm="${realm}",` +
+			`nonce="${nonce}",uri="${path}",qop="auth",algorithm="MD5",` +
+			`response="${response}",nc="${nonceCount}",cnonce="${cnonce}",opaque="${opaque}"`;
+		if (axiosConfig.headers) {
+			axiosConfig.headers['authorization'] = authorization;
+		} else {
+			axiosConfig.headers = { authorization };
+		}
+	}
+	return axiosConfig;
+}
+
+async function proxyRequestToAxios(
+	uriOrObject: string | IDataObject,
+	options?: IDataObject
+): Promise<any> {
+	// tslint:disable-line:no-any
+
+	let axiosConfig: AxiosRequestConfig = {};
+	let axiosPromise: AxiosPromise;
+	type ConfigObject = {
+		auth?: { sendImmediately: boolean };
+		resolveWithFullResponse?: boolean;
+		simple?: boolean;
+	};
+	let configObject: ConfigObject;
+	if (uriOrObject !== undefined && typeof uriOrObject === 'string') {
+		axiosConfig.url = uriOrObject;
+	}
+	if (uriOrObject !== undefined && typeof uriOrObject === 'object') {
+		configObject = uriOrObject;
+	} else {
+		configObject = options || {};
+	}
+
+	axiosConfig = Object.assign(axiosConfig, await parseRequestObject(configObject));
+
+	Logger.debug(
+		'Proxying request to axios',
+		// {
+		// 	originalConfig: configObject,
+		// 	parsedConfig: axiosConfig,
+		// }
+	);
+
+	if (configObject.auth?.sendImmediately === false) {
+		// for digest-auth
+		const { auth } = axiosConfig;
+		delete axiosConfig.auth;
+		// eslint-disable-next-line no-async-promise-executor
+		axiosPromise = new Promise(async (resolve, reject) => {
+			try {
+				const result = await axios(axiosConfig);
+				resolve(result);
+			} catch (resp: any) {
+				if (
+					resp.response === undefined ||
+					resp.response.status !== 401 ||
+					!resp.response.headers['www-authenticate']?.includes('nonce')
+				) {
+					reject(resp);
+				}
+				axiosConfig = digestAuthAxiosConfig(axiosConfig, resp.response, auth);
+				resolve(axios(axiosConfig));
+			}
+		});
+	} else {
+		axiosPromise = axios(axiosConfig);
+	}
+
+	return new Promise((resolve, reject) => {
+		axiosPromise
+			.then((response) => {
+				if (configObject.resolveWithFullResponse === true) {
+					let body = response.data;
+					if (response.data === '') {
+						if (axiosConfig.responseType === 'arraybuffer') {
+							body = Buffer.alloc(0);
+						} else {
+							body = undefined;
+						}
+					}
+					resolve({
+						body,
+						headers: response.headers,
+						statusCode: response.status,
+						statusMessage: response.statusText,
+						request: response.request,
+					});
+				} else {
+					let body = response.data;
+					if (response.data === '') {
+						if (axiosConfig.responseType === 'arraybuffer') {
+							body = Buffer.alloc(0);
+						} else {
+							body = undefined;
+						}
+					}
+					resolve(body);
+				}
+			})
+			.catch((error) => {
+				if (configObject.simple === false && error.response) {
+					if (configObject.resolveWithFullResponse) {
+						resolve({
+							body: error.response.data,
+							headers: error.response.headers,
+							statusCode: error.response.status,
+							statusMessage: error.response.statusText,
+						});
+					} else {
+						resolve(error.response.data);
+					}
+					return;
+				}
+
+				Logger.debug('Request proxied to Axios failed', { error });
+
+				// Axios hydrates the original error with more data. We extract them.
+				// https://github.com/axios/axios/blob/master/lib/core/enhanceError.js
+				// Note: `code` is ignored as it's an expected part of the errorData.
+				const { request, response, isAxiosError, toJSON, config, ...errorData } = error;
+				if (response) {
+					error.message = `${response.status as number} - ${JSON.stringify(response.data)}`;
+				}
+
+				error.cause = errorData;
+				error.error = error.response?.data || errorData;
+				error.statusCode = error.response?.status;
+				error.options = config || {};
+
+				// Remove not needed data and so also remove circular references
+				error.request = undefined;
+				error.config = undefined;
+				error.options.adapter = undefined;
+				error.options.httpsAgent = undefined;
+				error.options.paramsSerializer = undefined;
+				error.options.transformRequest = undefined;
+				error.options.transformResponse = undefined;
+				error.options.validateStatus = undefined;
+
+				reject(error);
+			});
+	});
+}
+
+function convertN8nRequestToAxios(n8nRequest: IHttpRequestOptions): AxiosRequestConfig {
+	// Destructure properties with the same name first.
+	const { headers, method, timeout, auth, proxy, url } = n8nRequest;
+
+	const axiosRequest = {
+		headers: headers ?? {},
+		method,
+		timeout,
+		auth,
+		proxy,
+		url,
+	} as AxiosRequestConfig;
+
+	axiosRequest.params = n8nRequest.qs;
+
+	if (n8nRequest.baseURL !== undefined) {
+		axiosRequest.baseURL = n8nRequest.baseURL;
+	}
+
+	if (n8nRequest.disableFollowRedirect === true) {
+		axiosRequest.maxRedirects = 0;
+	}
+
+	if (n8nRequest.encoding !== undefined) {
+		axiosRequest.responseType = n8nRequest.encoding;
+	}
+
+	if (n8nRequest.skipSslCertificateValidation === true) {
+		axiosRequest.httpsAgent = new Agent({
+			rejectUnauthorized: false,
+		});
+	}
+
+	if (n8nRequest.arrayFormat !== undefined) {
+		axiosRequest.paramsSerializer = (params) => {
+			return stringify(params, { arrayFormat: n8nRequest.arrayFormat });
+		};
+	}
+
+	if (n8nRequest.body) {
+		axiosRequest.data = n8nRequest.body;
+		// Let's add some useful header standards here.
+		const existingContentTypeHeaderKey = axiosRequest.headers ? searchForHeader(axiosRequest.headers, 'content-type') : undefined;
+		if (existingContentTypeHeaderKey === undefined) {
+			// We are only setting content type headers if the user did
+			// not set it already manually. We're not overriding, even if it's wrong.
+			if (axiosRequest.data instanceof FormData) {
+				axiosRequest.headers = axiosRequest.headers || {};
+				axiosRequest.headers['Content-Type'] = 'multipart/form-data';
+			} else if (axiosRequest.data instanceof URLSearchParams) {
+				axiosRequest.headers = axiosRequest.headers || {};
+				axiosRequest.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+			}
+		}
+	}
+
+	if (n8nRequest.json) {
+		const key = axiosRequest.headers ? searchForHeader(axiosRequest.headers, 'accept') : undefined;
+		// If key exists, then the user has set both accept
+		// header and the json flag. Header should take precedence.
+		if (!key) {
+			axiosRequest.headers = axiosRequest.headers || {};
+			axiosRequest.headers.Accept = 'application/json';
+		}
+	}
+
+	const userAgentHeader = axiosRequest.headers ? searchForHeader(axiosRequest.headers as IDataObject, 'user-agent') : undefined;
+	// If key exists, then the user has set both accept
+	// header and the json flag. Header should take precedence.
+	if (!userAgentHeader) {
+		axiosRequest.headers = axiosRequest.headers || {};
+		axiosRequest.headers['User-Agent'] = 'n8n';
+	}
+
+	if (n8nRequest.ignoreHttpStatusErrors) {
+		axiosRequest.validateStatus = () => true;
+	}
+
+	return axiosRequest;
+}
+
+async function httpRequest(
+	requestOptions: IHttpRequestOptions,
+): Promise<IN8nHttpFullResponse | IN8nHttpResponse> {
+	const axiosRequest = convertN8nRequestToAxios(requestOptions);
+	const result = await axios(axiosRequest);
+	if (requestOptions.returnFullResponse) {
+		return {
+			body: result.data,
+			headers: result.headers,
+			statusCode: result.status,
+			statusMessage: result.statusText,
+		};
+	}
+	return result.data;
+}
+
+/**
+ * Returns binary data buffer for given item index and property name.
+ *
+ * @export
+ * @param {ITaskDataConnections} inputData
+ * @param {number} itemIndex
+ * @param {string} propertyName
+ * @param {number} inputIndex
+ * @returns {Promise<Buffer>}
+ */
+export async function getBinaryDataBuffer(
+	inputData: ITaskDataConnections,
+	itemIndex: number,
+	propertyName: string,
+	inputIndex: number,
+): Promise<Buffer> {
+	const binaryData = inputData['main']![inputIndex]![itemIndex]!.binary![propertyName]!;
+	return BinaryDataManager.getInstance().retrieveBinaryData(binaryData);
+}
+
+/**
+ * Takes a buffer and converts it into the format n8n uses. It encodes the binary data as
+ * base64 and adds metadata.
+ *
+ * @export
+ * @param {Buffer} binaryData
+ * @param {string} [filePath]
+ * @param {string} [mimeType]
+ * @returns {Promise<IBinaryData>}
+ */
+export async function prepareBinaryData(
+	binaryData: Buffer,
+	executionId: string,
+	filePath?: string,
+	mimeType?: string,
+): Promise<IBinaryData> {
+	if (!mimeType) {
+		// If no mime type is given figure it out
+
+		if (filePath) {
+			// Use file path to guess mime type
+			const mimeTypeLookup = lookup(filePath);
+			if (mimeTypeLookup) {
+				mimeType = mimeTypeLookup;
+			}
+		}
+
+		if (!mimeType) {
+			// Use buffer to guess mime type
+			const fileTypeData = await fromBuffer(binaryData);
+			if (fileTypeData) {
+				mimeType = fileTypeData.mime;
+			}
+		}
+
+		if (!mimeType) {
+			// Fall back to text
+			mimeType = 'text/plain';
+		}
+	}
+
+	const returnData: IBinaryData = {
+		mimeType,
+		data: '',
+	};
+
+	if (filePath) {
+		if (filePath.includes('?')) {
+			// Remove maybe present query parameters
+			filePath = filePath.split('?').shift();
+		}
+
+		const filePathParts = path.parse(filePath as string);
+
+		if (filePathParts.dir !== '') {
+			returnData.directory = filePathParts.dir;
+		}
+		returnData.fileName = filePathParts.base;
+
+		// Remove the dot
+		const fileExtension = filePathParts.ext.slice(1);
+		if (fileExtension) {
+			returnData.fileExtension = fileExtension;
+		}
+	}
+
+	return BinaryDataManager.getInstance().storeBinaryData(returnData, binaryData, executionId);
+}
+
+
+export async function getCurrentOAuth2AccessToken(
+	this: IAllExecuteFunctions,
+	credentialsType: string,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	oAuth2Options?: IOAuth2Options,
+): Promise<string> {
+	const credentials = await this.getCredentials(credentialsType) as ICredentialDataDecryptedObject;
+	if (!credentials) {
+		throw new NodeOperationError(node, `No credentials of type "${credentialsType}" were returned!`, { description: 'Credentials not found' });
+	}
+	const clientId = credentials['clientId'] as string;
+	const clientSecret = credentials['clientSecret'] as string;
+	const scope = credentials['scope'] as string;
+	const grantType = credentials['grantType'] as "authorizationCode" | "clientCredentials";
+	const authUrl = credentials['authUrl'] as string | undefined;
+	const accessTokenUrl = credentials['accessTokenUrl'] as string | undefined;
+	const httpAgent = credentials['httpAgent'] as string | undefined;
+	const oauthTokenData = (credentials['oauthTokenData'] ?? {}) as Record<string, unknown>;
+	let accessToken = (oauthTokenData?.['accessToken'] ?? "") as string;
+	let refreshToken = (oauthTokenData?.['refreshToken'] ?? "") as string;
+	let expiresAt = (oauthTokenData?.['expiresAt'] ?? "") as string;
+	let expiresIn = (oauthTokenData?.['expiresIn'] ?? 0) as number;
+	let tokenType = (oauthTokenData?.['tokenType'] ?? "") as string;
+
+	const isExpired = !accessToken || !expiresAt || new Date(expiresAt).getTime() <= Date.now();
+
+	if (isExpired) {
+		Logger.debug(`Node "${node.name}" is using credential "${credentialsType}", however the access token has expired. This will now be refreshed using the "${grantType}" flow.`);
+
+		if(!authUrl){
+			throw new NodeOperationError(node, `The "authUrl" property is required for the "${grantType}" flow. Please check your credentials configuration.`, { description: 'Missing authUrl' });
+		}
+		const config: ModuleOptions<'client_id'> = {
+			client: { id: clientId, secret: clientSecret },
+			auth: { tokenHost: authUrl, tokenPath: accessTokenUrl },
+			http: { agent: httpAgent },
+			options: { authorizationMethod: 'body' },
+		};
+		
+		if (grantType === 'authorizationCode') {
+			const client = new AuthorizationCode(config);
+
+			let token = client.createToken({
+				access_token: get(oauthTokenData, oAuth2Options?.property as string) || accessToken,
+				refresh_token: refreshToken,
+				token_type: oAuth2Options?.tokenType || tokenType || 'Bearer',
+				expires_at: expiresAt,
+				expires_in: expiresIn,
+			});
+
+			const refreshOptions: any = oAuth2Options?.includeCredentialsOnRefreshOnBody ? { // Use of 'any' here is bad, though copying from previous example
+				body: {
+					client_id: clientId,
+					client_secret: clientSecret,
+				},
+				headers: {
+					Authorization: '', // override default basic auth
+				},
+			} : {};
+
+			token = await token.refresh(refreshOptions);
+
+			accessToken = token.token['access_token'] as string;
+			refreshToken = token.token['refresh_token'] as string || refreshToken 
+			expiresAt = token.token['expires_at'] as string;
+			expiresIn = token.token['expires_in'] as number;
+			tokenType = token.token['token_type'] as string || 'Bearer';
+		} else if (grantType === 'clientCredentials') {
+			const client = new ClientCredentials(config);
+			const token = await client.getToken({scope});
+
+			accessToken = token.token['access_token'] as string;
+			refreshToken = token.token['refresh_token'] as string || refreshToken ;
+			expiresAt = token.token['expires_at'] as string;
+			expiresIn = token.token['expires_in'] as number;
+			tokenType = token.token['token_type'] as string || 'Bearer';
+		} else {
+			throw new Error(`Unsupported grant type "${grantType}" for Microsoft Graph API`);
+		}
+
+		oauthTokenData["accessToken"] = accessToken;
+		oauthTokenData["refreshToken"] = refreshToken;
+		oauthTokenData["expiresAt"] = expiresAt;
+		oauthTokenData["expiresIn"] = expiresIn;
+		oauthTokenData["tokenType"] = tokenType;
+
+		if (!node.credentials || !node.credentials[credentialsType]) {
+			throw new Error(`Node "${node.name}" has no credentials of type "${credentialsType}"`);
+		}
+
+		await additionalData.credentialsHelper.updateCredentials(
+			node.credentials[credentialsType],
+			credentialsType,
+			credentials,
+		);
+
+		Logger.debug(`Access token for credential "${credentialsType}" has been refreshed.`);
+	}
+
+	return accessToken;
+}
+
+export async function requestOAuth2(
+	this: IAllExecuteFunctions,
+	credentialsType: string,
+	requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions | IHttpRequestOptions,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	oAuth2Options?: IOAuth2Options,
+	isN8nRequest = false,
+) {
+	const credentials = (await this.getCredentials(
+		credentialsType,
+	)) as ICredentialDataDecryptedObject;
+
+	if (!credentials) {
+		throw new Error('No credentials were returned!');
+	}
+
+	const oauthTokenData = credentials['oauthTokenData'] as Record<string, any>;
+	if (!oauthTokenData) {
+		throw new Error('OAuth credentials not connected!');
+	}
+
+	const config: ModuleOptions<'client_id'> = {
+		client: {
+			id: credentials['clientId'] as string,
+			secret: credentials['clientSecret'] as string,
+		},
+		auth: {
+			tokenHost: credentials['authUrl'] as string,
+			tokenPath: credentials['accessTokenUrl'] as string,
+		},
+		http: {
+			agent: credentials['httpAgent'],
+		},
+		options: {
+			authorizationMethod: 'body',
+		},
+	};
+
+	const client = new AuthorizationCode(config);
+
+	// Construct token from saved data
+	const tokenObject: AccessToken = client.createToken({
+		access_token: get(oauthTokenData, oAuth2Options?.property as string) || oauthTokenData['accessToken'],
+		refresh_token: oauthTokenData['refreshToken'],
+		token_type: oAuth2Options?.tokenType || oauthTokenData['tokenType'] || 'Bearer',
+		expires_at: oauthTokenData['expiresAt'],
+		expires_in: oauthTokenData['expiresIn'],
+	});
+
+	const currentToken = tokenObject;
+
+	const signedOptions = {
+		...requestOptions,
+		headers: {
+			...(requestOptions.headers || {}),
+			Authorization: `${currentToken.token["token_type"]} ${currentToken.token["access_token"]}`,
+		},
+	};
+
+	// Remove 'Bearer' if `keepBearer` is false
+	if (oAuth2Options?.keepBearer === false && signedOptions.headers.Authorization) {
+		signedOptions.headers.Authorization = signedOptions.headers.Authorization.split(' ')[1];
+	}
+
+	try {
+		return await this.helpers['request']!(signedOptions);
+	} catch (error: any) {
+		const statusCodeReturned = oAuth2Options?.tokenExpiredStatusCode ?? 401;
+
+		if (error.statusCode === statusCodeReturned && currentToken.expired()) {
+			// Refresh token
+			Logger.debug(`OAuth2 token for "${credentialsType}" used by node "${node.name}" expired. Refreshing...`);
+			Logger.info(`OAuth2 token for "${credentialsType}" used by node "${node.name}" expired. Refreshing...`);
+
+			const refreshOptions: any = {};
+
+			if (oAuth2Options?.includeCredentialsOnRefreshOnBody) {
+				refreshOptions.body = {
+					client_id: credentials['clientId'],
+					client_secret: credentials['clientSecret'],
+				};
+				refreshOptions.headers = {
+					Authorization: '', // override default basic auth
+				};
+			}
+			let refreshedToken: AccessToken;
+
+			try {
+				refreshedToken = await currentToken.refresh(refreshOptions);
+			} catch (error: any) {
+				throw new Error("Failed to refresh token: " + error.message);
+			}
+
+			credentials['oauthTokenData'] = {
+				accessToken: refreshedToken.token["access_token"],
+				refreshToken: refreshedToken.token["refresh_token"] || currentToken.token["refresh_token"],
+				expiresAt: refreshedToken.token["expires_at"],
+				expiresIn: refreshedToken.token["expires_in"],
+				tokenType: refreshedToken.token["token_type"],
+			} as any;
+
+			// Persist new token
+			if (!node.credentials || !node.credentials[credentialsType]) {
+				throw new Error(`Node "${node.name}" has no credentials of type "${credentialsType}"`);
+			}
+
+			await additionalData.credentialsHelper.updateCredentials(
+				node.credentials[credentialsType],
+				credentialsType,
+				credentials,
+			);
+
+			Logger.debug(`OAuth2 token for "${credentialsType}" used by node "${node.name}" has been renewed.`);
+			Logger.info(`OAuth2 token for "${credentialsType}" used by node "${node.name}" has been renewed.`);
+
+			// Retry the original request with the new token
+			const retryOptions = {
+				...requestOptions,
+				headers: {
+					...(requestOptions.headers || {}),
+					Authorization: `${refreshedToken.token["token_type"]} ${refreshedToken.token["access_token"]}`,
+				},
+			};
+
+			if (oAuth2Options?.keepBearer === false && retryOptions.headers.Authorization) {
+				retryOptions.headers.Authorization = retryOptions.headers.Authorization.split(' ')[1];
+			}
+
+			return isN8nRequest
+				? this.helpers.httpRequest(retryOptions as IHttpRequestOptions)
+				: this.helpers['request']!(retryOptions);
+		}
+
+		throw error;
+	}
+}
+
+
+/* Makes a request using OAuth1 data for authentication
+ *
+ * @export
+ * @param {IAllExecuteFunctions} this
+ * @param {string} credentialsType
+ * @param {(OptionsWithUrl | requestPromise.RequestPromiseOptions)} requestOptionså
+ * @returns
+ */
+export async function requestOAuth1(
+	this: IAllExecuteFunctions,
+	credentialsType: string,
+	requestOptions:
+		| OptionsWithUrl
+		| OptionsWithUri
+		| requestPromise.RequestPromiseOptions
+		| IHttpRequestOptions,
+	isN8nRequest = false,
+) {
+	const credentials = (await this.getCredentials(
+		credentialsType,
+	)) as ICredentialDataDecryptedObject;
+
+	if (credentials === undefined) {
+		throw new Error('No credentials were returned!');
+	}
+
+	if (credentials['oauthTokenData'] === undefined) {
+		throw new Error('OAuth credentials not connected!');
+	}
+
+	const oauth = new clientOAuth1({
+		consumer: {
+			key: credentials['consumerKey'] as string,
+			secret: credentials['consumerSecret'] as string,
+		},
+		signature_method: credentials['signatureMethod'] as string,
+		hash_function(base: any, key: any) {
+			const algorithm = credentials['signatureMethod'] === 'HMAC-SHA1' ? 'sha1' : 'sha256';
+			return createHmac(algorithm, key).update(base).digest('base64');
+		},
+	});
+
+	const oauthTokenData = credentials['oauthTokenData'] as IDataObject;
+
+	const token: Token = {
+		key: oauthTokenData['oauth_token'] as string,
+		secret: oauthTokenData['oauth_token_secret'] as string,
+	};
+
+	// @ts-ignore
+	requestOptions.data = { ...requestOptions.qs, ...requestOptions.form };
+
+	// Fixes issue that OAuth1 library only works with "url" property and not with "uri"
+	// @ts-ignore
+	if (requestOptions.uri && !requestOptions.url) {
+		// @ts-ignore
+		requestOptions.url = requestOptions.uri;
+		// @ts-ignore
+		delete requestOptions.uri;
+	}
+
+	// @ts-ignore
+	requestOptions.headers = oauth.toHeader(oauth.authorize(requestOptions, token));
+
+	if (isN8nRequest) {
+		return this.helpers.httpRequest(requestOptions as IHttpRequestOptions);
+	}
+
+	return this.helpers['request']!(requestOptions).catch(async (error: IResponseError) => {
+		// Unknown error so simply throw it
+		throw error;
+	});
+}
+
+export async function httpRequestWithAuthentication(
+	this: IAllExecuteFunctions,
+	credentialsType: string,
+	requestOptions: IHttpRequestOptions,
+	workflow: Workflow,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	additionalCredentialOptions?: IAdditionalCredentialOptions,
+) {
+	try {
+		const parentTypes = additionalData.credentialsHelper.getParentTypes(credentialsType);
+
+		if (parentTypes.includes('oAuth1Api')) {
+			return await requestOAuth1.call(this, credentialsType, requestOptions, true);
+		}
+		if (parentTypes.includes('oAuth2Api')) {
+			return await requestOAuth2.call(
+				this,
+				credentialsType,
+				requestOptions,
+				node,
+				additionalData,
+				additionalCredentialOptions?.oauth2,
+				true,
+			);
+		}
+
+		let credentialsDecrypted: ICredentialDataDecryptedObject | undefined;
+		if (additionalCredentialOptions?.credentialsDecrypted) {
+			credentialsDecrypted = additionalCredentialOptions.credentialsDecrypted.data;
+		} else {
+			credentialsDecrypted = await this.getCredentials(credentialsType);
+		}
+
+		if (credentialsDecrypted === undefined) {
+			throw new NodeOperationError(
+				node,
+				`Node "${node.name}" does not have any credentials of type "${credentialsType}" set!`,
+			);
+		}
+
+		requestOptions = await additionalData.credentialsHelper.authenticate(
+			credentialsDecrypted,
+			credentialsType,
+			requestOptions,
+			workflow,
+			node,
+		);
+
+		return await httpRequest(requestOptions);
+	} catch (error) {
+		throw new NodeApiError(this.getNode(), error as JsonObject);
+	}
+}
+
+/**
+ * Takes generic input data and brings it into the json format n8n uses.
+ *
+ * @export
+ * @param {(IDataObject | IDataObject[])} jsonData
+ * @returns {INodeExecutionData[]}
+ */
+export function returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[] {
+	const returnData: INodeExecutionData[] = [];
+
+	if (!Array.isArray(jsonData)) {
+		jsonData = [jsonData];
+	}
+
+	jsonData.forEach((data) => {
+		returnData.push({ json: data });
+	});
+
+	return returnData;
+}
+
+/**
+ * Automatically put the objects under a 'json' key and don't error,
+ * if some objects contain json/binary keys and others don't, throws error 'Inconsistent item format'
+ *
+ * @export
+ * @param {INodeExecutionData | INodeExecutionData[]} executionData
+ * @returns {INodeExecutionData[]}
+ */
+export function normalizeItems(
+	executionData: INodeExecutionData | INodeExecutionData[],
+): INodeExecutionData[] {
+	if (typeof executionData === 'object' && !Array.isArray(executionData))
+		executionData = [{ json: executionData as IDataObject }];
+	if (executionData.every((item) => typeof item === 'object' && 'json' in item))
+		return executionData;
+
+	if (executionData.some((item) => typeof item === 'object' && 'json' in item)) {
+		throw new Error('Inconsistent item format');
+	}
+
+	if (executionData.every((item) => typeof item === 'object' && 'binary' in item)) {
+		const normalizedItems: INodeExecutionData[] = [];
+		executionData.forEach((item) => {
+			const json = Object.keys(item).reduce((acc, key) => {
+				if (key === 'binary') return acc;
+				return { ...acc, [key]: item[key] };
+			}, {});
+
+			normalizedItems.push({
+				json,
+				binary: item.binary,
+			});
+		});
+		return normalizedItems;
+	}
+
+	if (executionData.some((item) => typeof item === 'object' && 'binary' in item)) {
+		throw new Error('Inconsistent item format');
+	}
+
+	return executionData.map((item) => {
+		return { json: item };
+	});
+}
+
+// TODO: Move up later
+export async function requestWithAuthentication(
+	this: IAllExecuteFunctions,
+	credentialsType: string,
+	requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+	workflow: Workflow,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	additionalCredentialOptions?: IAdditionalCredentialOptions,
+) {
+	try {
+		const parentTypes = additionalData.credentialsHelper.getParentTypes(credentialsType);
+
+		if (parentTypes.includes('oAuth1Api')) {
+			return await requestOAuth1.call(this, credentialsType, requestOptions, false);
+		}
+		if (parentTypes.includes('oAuth2Api')) {
+			return await requestOAuth2.call(
+				this,
+				credentialsType,
+				requestOptions,
+				node,
+				additionalData,
+				additionalCredentialOptions?.oauth2,
+				false,
+			);
+		}
+
+		let credentialsDecrypted: ICredentialDataDecryptedObject | undefined;
+		if (additionalCredentialOptions?.credentialsDecrypted) {
+			credentialsDecrypted = additionalCredentialOptions.credentialsDecrypted.data;
+		} else {
+			credentialsDecrypted = await this.getCredentials(credentialsType);
+		}
+
+		if (credentialsDecrypted === undefined) {
+			throw new NodeOperationError(
+				node,
+				`Node "${node.name}" does not have any credentials of type "${credentialsType}" set!`,
+			);
+		}
+
+		requestOptions = await additionalData.credentialsHelper.authenticate(
+			credentialsDecrypted,
+			credentialsType,
+			requestOptions as IHttpRequestOptions,
+			workflow,
+			node,
+		);
+
+		return await proxyRequestToAxios(requestOptions as IDataObject);
+	} catch (error: any) {
+		throw new NodeApiError(this.getNode(), error);
+	}
+}
+
+/**
+ * Returns the additional keys for Expressions and Function-Nodes
+ *
+ * @export
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {(IWorkflowDataProxyAdditionalKeys)}
+ */
+export function getAdditionalKeys(
+	additionalData: IWorkflowExecuteAdditionalData,
+): IWorkflowDataProxyAdditionalKeys {
+	const executionId = additionalData.executionId || PLACEHOLDER_EMPTY_EXECUTION_ID;
+	return {
+		$executionId: executionId,
+		$resumeWebhookUrl: `${additionalData.webhookWaitingBaseUrl}/${executionId}`,
+	};
+}
+
+/**
+ * Returns the requested decrypted credentials if the node has access to them.
+ *
+ * @export
+ * @param {Workflow} workflow Workflow which requests the data
+ * @param {INode} node Node which request the data
+ * @param {string} type The credential type to return
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {(ICredentialDataDecryptedObject | undefined)}
+ */
+export async function getCredentials(
+	workflow: Workflow,
+	node: INode,
+	type: string,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+	runExecutionData?: IRunExecutionData | null,
+	runIndex?: number,
+	connectionInputData?: INodeExecutionData[],
+	itemIndex?: number,
+): Promise<ICredentialDataDecryptedObject | undefined> {
+	// Get the NodeType as it has the information if the credentials are required
+	const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+	if (nodeType === undefined) {
+		throw new NodeOperationError(
+			node,
+			`Node type "${node.type}" is not known so can not get credentials!`,
+		);
+	}
+
+	// Hardcode for now for security reasons that only a single node can access
+	// all credentials
+	const fullAccess = ['n8n-nodes-base.httpRequest'].includes(node.type);
+
+	let nodeCredentialDescription: INodeCredentialDescription | undefined;
+	if (!fullAccess) {
+		if (nodeType.description.credentials === undefined) {
+			throw new NodeOperationError(
+				node,
+				`Node type "${node.type}" does not have any credentials defined!`,
+			);
+		}
+
+		nodeCredentialDescription = nodeType.description.credentials.find(
+			(credentialTypeDescription) => credentialTypeDescription.name === type,
+		);
+		if (nodeCredentialDescription === undefined) {
+			throw new NodeOperationError(
+				node,
+				`Node type "${node.type}" does not have any credentials of type "${type}" defined!`,
+			);
+		}
+
+		if (
+			!NodeHelpers.displayParameter(
+				additionalData.currentNodeParameters || node.parameters,
+				nodeCredentialDescription,
+				node.parameters,
+			)
+		) {
+			// Credentials should not be displayed so return undefined even if they would be defined
+			return undefined;
+		}
+	}
+
+	// Check if node has any credentials defined
+	if (!fullAccess && (!node.credentials || !node.credentials[type])) {
+		// If none are defined check if the credentials are required or not
+
+		if (nodeCredentialDescription?.required === true) {
+			// Credentials are required so error
+			if (!node.credentials) {
+				throw new NodeOperationError(node, 'Node does not have any credentials set!');
+			}
+			if (!node.credentials[type]) {
+				throw new NodeOperationError(node, `Node does not have any credentials set for "${type}"!`);
+			}
+		} else {
+			// Credentials are not required so resolve with undefined
+			return undefined;
+		}
+	}
+
+	if (fullAccess && (!node.credentials || !node.credentials[type])) {
+		// Make sure that fullAccess nodes still behave like before that if they
+		// request access to credentials that are currently not set it returns undefined
+		return undefined;
+	}
+
+	let expressionResolveValues: ICredentialsExpressionResolveValues | undefined;
+	if (connectionInputData && runExecutionData && runIndex !== undefined) {
+		expressionResolveValues = {
+			connectionInputData,
+			itemIndex: itemIndex || 0,
+			node,
+			runExecutionData,
+			runIndex,
+			workflow,
+		} as ICredentialsExpressionResolveValues;
+	}
+
+	const nodeCredentials = node.credentials
+		? node.credentials[type]
+		: ({} as INodeCredentialsDetails);
+
+	// TODO: solve using credentials via expression
+	// if (name.charAt(0) === '=') {
+	// 	// If the credential name is an expression resolve it
+	// 	const additionalKeys = getAdditionalKeys(additionalData);
+	// 	name = workflow.expression.getParameterValue(
+	// 		name,
+	// 		runExecutionData || null,
+	// 		runIndex || 0,
+	// 		itemIndex || 0,
+	// 		node.name,
+	// 		connectionInputData || [],
+	// 		mode,
+	// 		additionalKeys,
+	// 	) as string;
+	// }
+
+	const decryptedDataObject = await additionalData.credentialsHelper.getDecrypted(
+		nodeCredentials,
+		type,
+		mode,
+		false,
+		expressionResolveValues,
+	);
+
+	return decryptedDataObject;
+}
+
+/**
+ * Returns a copy of the node
+ *
+ * @export
+ * @param {INode} node
+ * @returns {INode}
+ */
+export function getNode(node: INode): INode {
+	return JSON.parse(JSON.stringify(node));
+}
+
+/**
+ * Returns the requested resolved (all expressions replaced) node parameters.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {(IRunExecutionData | null)} runExecutionData
+ * @param {number} runIndex
+ * @param {INodeExecutionData[]} connectionInputData
+ * @param {INode} node
+ * @param {string} parameterName
+ * @param {number} itemIndex
+ * @param {*} [fallbackValue]
+ * @returns {(NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object)}
+ */
+
+export function getNodeParameter(
+	workflow: Workflow,
+	runExecutionData: IRunExecutionData | null,
+	runIndex: number,
+	connectionInputData: INodeExecutionData[],
+	node: INode,
+	parameterName: string,
+	itemIndex: number,
+	mode: WorkflowExecuteMode,
+	additionalKeys: IWorkflowDataProxyAdditionalKeys,
+	fallbackValue?: any,
+): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object {
+	const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+	if (nodeType === undefined) {
+		throw new Error(`Node type "${node.type}" is not known so can not return paramter value!`);
+	}
+
+	const value = get(node.parameters, parameterName, fallbackValue);
+
+	if (value === undefined) {
+		throw new Error(`Could not get parameter "${parameterName}"!`);
+	}
+
+	let returnData;
+	try {
+		returnData = workflow.expression.getParameterValue(
+			value,
+			runExecutionData,
+			runIndex,
+			itemIndex,
+			node.name,
+			connectionInputData,
+			mode,
+			additionalKeys,
+		);
+	} catch (e: any) {
+		e.message += ` [Error in parameter: "${parameterName}"]`;
+		throw e;
+	}
+
+	return returnData;
+}
+
+/**
+ * Returns if execution should be continued even if there was an error.
+ *
+ * @export
+ * @param {INode} node
+ * @returns {boolean}
+ */
+export function continueOnFail(node: INode): boolean {
+	return get(node, 'continueOnFail', false);
+}
+
+/**
+ * Returns the webhook URL of the webhook with the given name
+ *
+ * @export
+ * @param {string} name
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {boolean} [isTest]
+ * @returns {(string | undefined)}
+ */
+export function getNodeWebhookUrl(
+	name: string,
+	workflow: Workflow,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+	additionalKeys: IWorkflowDataProxyAdditionalKeys,
+	isTest?: boolean,
+): string | undefined {
+	let baseUrl = additionalData.webhookBaseUrl;
+	if (isTest === true) {
+		baseUrl = additionalData.webhookTestBaseUrl;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-use-before-define
+	const webhookDescription = getWebhookDescription(name, workflow, node);
+	if (webhookDescription === undefined) {
+		return undefined;
+	}
+
+	const path = workflow.expression.getSimpleParameterValue(
+		node,
+		webhookDescription.path,
+		mode,
+		additionalKeys,
+	);
+	if (path === undefined) {
+		return undefined;
+	}
+
+	const isFullPath: boolean = workflow.expression.getSimpleParameterValue(
+		node,
+		webhookDescription.isFullPath,
+		mode,
+		additionalKeys,
+		false,
+	) as boolean;
+	return NodeHelpers.getNodeWebhookUrl(baseUrl, workflow.id!, node, path.toString(), isFullPath);
+}
+
+/**
+ * Returns the timezone for the workflow
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {string}
+ */
+export function getTimezone(
+	workflow: Workflow,
+	additionalData: IWorkflowExecuteAdditionalData,
+): string {
+	// eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+	if (workflow.settings !== undefined && workflow.settings['timezone'] !== undefined) {
+		return (workflow.settings as IWorkflowSettings).timezone as string;
+	}
+	return additionalData.timezone;
+}
+
+/**
+ * Returns the full webhook description of the webhook with the given name
+ *
+ * @export
+ * @param {string} name
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @returns {(IWebhookDescription | undefined)}
+ */
+export function getWebhookDescription(
+	name: string,
+	workflow: Workflow,
+	node: INode,
+): IWebhookDescription | undefined {
+	const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion) as INodeType;
+
+	if (nodeType.description.webhooks === undefined) {
+		// Node does not have any webhooks so return
+		return undefined;
+	}
+
+	// eslint-disable-next-line no-restricted-syntax
+	for (const webhookDescription of nodeType.description.webhooks) {
+		if (webhookDescription.name === name) {
+			return webhookDescription;
+		}
+	}
+
+	return undefined;
+}
+
+/**
+ * Returns the workflow metadata
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @returns {IWorkflowMetadata}
+ */
+export function getWorkflowMetadata(workflow: Workflow): IWorkflowMetadata {
+	return {
+		id: workflow.id,
+		name: workflow.name,
+		active: workflow.active,
+	};
+}
+
+/**
+ * Returns the execute functions the poll nodes have access to.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {ITriggerFunctions}
+ */
+// TODO: Check if I can get rid of: additionalData, and so then maybe also at ActiveWorkflowRunner.add
+export function getExecutePollFunctions(
+	workflow: Workflow,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+	activation: WorkflowActivateMode,
+): IPollFunctions {
+	return ((workflow: Workflow, node: INode) => {
+		return {
+			__emit: (data: INodeExecutionData[][]): void => {
+				throw new Error('Overwrite NodeExecuteFunctions.getExecutePullFunctions.__emit function!');
+			},
+			async getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined> {
+				return getCredentials(workflow, node, type, additionalData, mode);
+			},
+			getMode: (): WorkflowExecuteMode => {
+				return mode;
+			},
+			getActivationMode: (): WorkflowActivateMode => {
+				return activation;
+			},
+			getNode: () => {
+				return getNode(node);
+			},
+			getNodeParameter: (
+				parameterName: string,
+				fallbackValue?: any,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object => {
+				const runExecutionData: IRunExecutionData | null = null;
+				const itemIndex = 0;
+				const runIndex = 0;
+				const connectionInputData: INodeExecutionData[] = [];
+
+				return getNodeParameter(
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					node,
+					parameterName,
+					itemIndex,
+					mode,
+					getAdditionalKeys(additionalData),
+					fallbackValue,
+				);
+			},
+			getRestApiUrl: (): string => {
+				return additionalData.restApiUrl;
+			},
+			getTimezone: (): string => {
+				return getTimezone(workflow, additionalData);
+			},
+			getWorkflow: () => {
+				return getWorkflowMetadata(workflow);
+			},
+			getWorkflowStaticData(type: string): IDataObject {
+				return workflow.getStaticData(type, node);
+			},
+			helpers: {
+				httpRequest,
+				async prepareBinaryData(
+					binaryData: Buffer,
+					filePath?: string,
+					mimeType?: string,
+				): Promise<IBinaryData> {
+					return prepareBinaryData.call(
+						this,
+						binaryData,
+						additionalData.executionId!,
+						filePath,
+						mimeType,
+					);
+				},
+				request: proxyRequestToAxios,
+				async requestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return requestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				async requestOAuth2(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return requestOAuth2.call(
+						this,
+						credentialsType,
+						requestOptions,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async getCurrentOAuth2AccessToken(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return getCurrentOAuth2AccessToken.call(
+						this,
+						credentialsType,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async requestOAuth1(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+				): Promise<any> {
+					return requestOAuth1.call(this, credentialsType, requestOptions);
+				},
+				async httpRequestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: IHttpRequestOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return httpRequestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				returnJsonArray,
+			},
+		};
+	})(workflow, node);
+}
+
+/**
+ * Returns the execute functions the trigger nodes have access to.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {ITriggerFunctions}
+ */
+// TODO: Check if I can get rid of: additionalData, and so then maybe also at ActiveWorkflowRunner.add
+export function getExecuteTriggerFunctions(
+	workflow: Workflow,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+	activation: WorkflowActivateMode,
+): ITriggerFunctions {
+	return ((workflow: Workflow, node: INode) => {
+		return {
+			emit: (data: INodeExecutionData[][]): void => {
+				throw new Error('Overwrite NodeExecuteFunctions.getExecuteTriggerFunctions.emit function!');
+			},
+			async getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined> {
+				return getCredentials(workflow, node, type, additionalData, mode);
+			},
+			getNode: () => {
+				return getNode(node);
+			},
+			getMode: (): WorkflowExecuteMode => {
+				return mode;
+			},
+			getActivationMode: (): WorkflowActivateMode => {
+				return activation;
+			},
+			getNodeParameter: (
+				parameterName: string,
+				fallbackValue?: any,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object => {
+				const runExecutionData: IRunExecutionData | null = null;
+				const itemIndex = 0;
+				const runIndex = 0;
+				const connectionInputData: INodeExecutionData[] = [];
+
+				return getNodeParameter(
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					node,
+					parameterName,
+					itemIndex,
+					mode,
+					getAdditionalKeys(additionalData),
+					fallbackValue,
+				);
+			},
+			getRestApiUrl: (): string => {
+				return additionalData.restApiUrl;
+			},
+			getTimezone: (): string => {
+				return getTimezone(workflow, additionalData);
+			},
+			getWorkflow: () => {
+				return getWorkflowMetadata(workflow);
+			},
+			getWorkflowStaticData(type: string): IDataObject {
+				return workflow.getStaticData(type, node);
+			},
+			helpers: {
+				httpRequest,
+				async requestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return requestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				async prepareBinaryData(
+					binaryData: Buffer,
+					filePath?: string,
+					mimeType?: string,
+				): Promise<IBinaryData> {
+					return prepareBinaryData.call(
+						this,
+						binaryData,
+						additionalData.executionId!,
+						filePath,
+						mimeType,
+					);
+				},
+				request: proxyRequestToAxios,
+				async requestOAuth2(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return requestOAuth2.call(
+						this,
+						credentialsType,
+						requestOptions,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async requestOAuth1(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+				): Promise<any> {
+					return requestOAuth1.call(this, credentialsType, requestOptions);
+				},
+				async httpRequestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: IHttpRequestOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return httpRequestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				returnJsonArray,
+			},
+		};
+	})(workflow, node);
+}
+
+/**
+ * Returns the execute functions regular nodes have access to.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IRunExecutionData} runExecutionData
+ * @param {number} runIndex
+ * @param {INodeExecutionData[]} connectionInputData
+ * @param {ITaskDataConnections} inputData
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {IExecuteFunctions}
+ */
+export function getExecuteFunctions(
+	workflow: Workflow,
+	runExecutionData: IRunExecutionData,
+	runIndex: number,
+	connectionInputData: INodeExecutionData[],
+	inputData: ITaskDataConnections,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+	nodeTypeData: INodeType,
+	closeFunctions: CloseFunction[],
+): IExecuteFunctions {
+	return ((workflow, runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions) => {
+		return {
+			continueOnFail: () => {
+				return continueOnFail(node);
+			},
+			evaluateExpression: (expression: string, itemIndex: number) => {
+				return workflow.expression.resolveSimpleParameterValue(
+					`=${expression}`,
+					{},
+					runExecutionData,
+					runIndex,
+					itemIndex,
+					node.name,
+					connectionInputData,
+					mode,
+					getAdditionalKeys(additionalData),
+				);
+			},
+			async executeWorkflow(
+				workflowInfo: IExecuteWorkflowInfo,
+				inputData?: INodeExecutionData[],
+			): Promise<any> {
+				return additionalData
+					.executeWorkflow(workflowInfo, additionalData, inputData)
+					.then(async (result) =>
+						BinaryDataManager.getInstance().duplicateBinaryData(
+							result,
+							additionalData.executionId!,
+						),
+					);
+			},
+			getContext(type: string): IContextObject {
+				return NodeHelpers.getContext(runExecutionData, type, node);
+			},
+			async getCredentials(
+				type: string,
+				itemIndex?: number,
+			): Promise<ICredentialDataDecryptedObject | undefined> {
+				return getCredentials(
+					workflow,
+					node,
+					type,
+					additionalData,
+					mode,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					itemIndex,
+				);
+			},
+			getExecutionId: (): string => {
+				return additionalData.executionId!;
+			},
+			getInputData: (inputIndex = 0, inputName = 'main') => {
+				if (!Object.prototype.hasOwnProperty.call(inputData, inputName)) {
+					// Return empty array because else it would throw error when nothing is connected to input
+					return [];
+				}
+
+				// TODO: Check if nodeType has input with that index defined
+				if (inputData[inputName].length < inputIndex) {
+					throw new Error(`Could not get input index "${inputIndex}" of input "${inputName}"!`);
+				}
+
+				if (inputData[inputName][inputIndex] === null) {
+					// return [];
+					throw new Error(`Value "${inputIndex}" of input "${inputName}" did not get set!`);
+				}
+
+				return inputData[inputName][inputIndex] as INodeExecutionData[];
+			},
+			getNodeParameter: (
+				parameterName: string,
+				itemIndex: number,
+				fallbackValue?: any,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object => {
+				return getNodeParameter(
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					node,
+					parameterName,
+					itemIndex,
+					mode,
+					getAdditionalKeys(additionalData),
+					fallbackValue,
+				);
+			},
+			getMode: (): WorkflowExecuteMode => {
+				return mode;
+			},
+			getNode: () => {
+				return getNode(node);
+			},
+			getRestApiUrl: (): string => {
+				return additionalData.restApiUrl;
+			},
+			getTimezone: (): string => {
+				return getTimezone(workflow, additionalData);
+			},
+			getWorkflow: () => {
+				return getWorkflowMetadata(workflow);
+			},
+			getWorkflowDataProxy: (itemIndex: number): IWorkflowDataProxyData => {
+				const dataProxy = new WorkflowDataProxy(
+					workflow,
+					runExecutionData,
+					runIndex,
+					itemIndex,
+					node.name,
+					connectionInputData,
+					{},
+					mode,
+					getAdditionalKeys(additionalData),
+				);
+				return dataProxy.getDataProxy();
+			},
+			getWorkflowStaticData(type: string): IDataObject {
+				return workflow.getStaticData(type, node);
+			},
+			prepareOutputData: NodeHelpers.prepareOutputData,
+			async putExecutionToWait(waitTill: Date): Promise<void> {
+				runExecutionData.waitTill = waitTill;
+			},
+			sendMessageToUI(...args: any[]): void {
+				if (mode !== 'manual') {
+					return;
+				}
+				try {
+					if (additionalData.sendMessageToUI) {
+						additionalData.sendMessageToUI(node.name, args);
+					}
+				} catch (error: any) {
+					// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+					Logger.warn(`There was a problem sending messsage to UI: ${error.message}`);
+				}
+			},
+			async sendResponse(response: IExecuteResponsePromiseData): Promise<void> {
+				await additionalData.hooks?.executeHookFunctions('sendResponse', [response]);
+			},
+			helpers: {
+				httpRequest,
+				async requestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return requestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				assertBinaryData(
+					itemIndex: number,
+					propertyName: string,
+					inputIndex: number = 0,
+				): IBinaryData {
+					const binaryKeyData = inputData['main'][inputIndex]![itemIndex].binary;
+					if (binaryKeyData === undefined) {
+						throw new NodeOperationError(
+							node,
+							`This operation expects the node's input data to contain a binary file '${propertyName}', but none was found [item ${itemIndex}]`,
+							{
+								itemIndex,
+								description: 'Make sure that the previous node outputs a binary file',
+							},
+						);
+					}
+
+					const binaryPropertyData = binaryKeyData[propertyName];
+					if (binaryPropertyData === undefined) {
+						throw new NodeOperationError(
+							node,
+							`The item has no binary field '${propertyName}' [item ${itemIndex}]`,
+							{
+								itemIndex,
+								description:
+									'Check that the parameter where you specified the input binary field name is correct, and that it matches a field in the binary input',
+							},
+						);
+					}
+
+					return binaryPropertyData;
+				},
+
+				async prepareBinaryData(
+					binaryData: Buffer,
+					filePath?: string,
+					mimeType?: string,
+				): Promise<IBinaryData> {
+					return prepareBinaryData.call(
+						this,
+						binaryData,
+						additionalData.executionId!,
+						filePath,
+						mimeType,
+					);
+				},
+				async getBinaryDataBuffer(
+					itemIndex: number,
+					propertyName: string,
+					inputIndex = 0,
+				): Promise<Buffer> {
+					return getBinaryDataBuffer.call(this, inputData, itemIndex, propertyName, inputIndex);
+				},
+				request: proxyRequestToAxios,
+				async requestOAuth2(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return requestOAuth2.call(
+						this,
+						credentialsType,
+						requestOptions,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async requestOAuth1(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+				): Promise<any> {
+					return requestOAuth1.call(this, credentialsType, requestOptions);
+				},
+				async httpRequestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: IHttpRequestOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return httpRequestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				returnJsonArray,
+				normalizeItems,
+			},
+			getInstanceId: () => {
+				// Return the node's instance ID if available, otherwise return an empty string
+				return node.id || '';
+			},
+			async getInputConnectionData(
+				this: IExecuteFunctions | ISupplyDataFunctions,
+				connectionType: NodeConnectionType,
+				itemIndex: number,
+			): Promise<unknown> {
+				return await getInputConnectionData.call(
+					this,
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					inputData,
+					additionalData,
+					connectionType,
+					mode,
+					itemIndex,
+					nodeTypeData,
+					closeFunctions,
+				);
+			},
+
+			addInputData(
+				data: INodeExecutionData[][] | ExecutionError,
+				node: INode
+			): { index: number, inputExecutionData: IRunExecutionData } {
+				const nodeName = node.name;
+				let currentNodeRunIndex = 0;
+				runExecutionData = {
+					startData: {
+						destinationNode: nodeName,
+					},
+					resultData: {
+						runData: {
+							[nodeName]: [JSON.parse(JSON.stringify(data))]
+						},
+						lastNodeExecuted: nodeName,
+					},
+				}
+		
+				return { index: currentNodeRunIndex, inputExecutionData: runExecutionData };
+			},
+			addOutputData(
+				data: INodeExecutionData[][] | ExecutionError,
+				node: INode
+			): { outputExecutionData: IRunExecutionData } {
+				const nodeName = node.name;
+				const outputExecutionData = {
+					startData: {
+						destinationNode: nodeName,
+					},
+					resultData: {
+						error: typeof data === 'object' && 'error' in data ? data.error as ExecutionError : undefined,
+						runData: {
+							[nodeName]: [JSON.parse(JSON.stringify(data))]
+						},
+						lastNodeExecuted: nodeName,
+					},
+				}
+				return { outputExecutionData };
+				
+			},
+			getExecutionCancelSignal: () => {
+				return undefined;
+			},
+		};
+
+
+	})(workflow, runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions)  as unknown as IExecuteFunctions;
+}
+
+/**
+ * Returns the execute functions regular nodes have access to when single-function is defined.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IRunExecutionData} runExecutionData
+ * @param {number} runIndex
+ * @param {INodeExecutionData[]} connectionInputData
+ * @param {ITaskDataConnections} inputData
+ * @param {INode} node
+ * @param {number} itemIndex
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {IExecuteSingleFunctions}
+ */
+export function getExecuteSingleFunctions(
+	workflow: Workflow,
+	runExecutionData: IRunExecutionData,
+	runIndex: number,
+	connectionInputData: INodeExecutionData[],
+	inputData: ITaskDataConnections,
+	node: INode,
+	itemIndex: number,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+): IExecuteSingleFunctions {
+	return ((workflow, runExecutionData, connectionInputData, inputData, node, itemIndex) => {
+		return {
+			continueOnFail: () => {
+				return continueOnFail(node);
+			},
+			evaluateExpression: (expression: string, evaluateItemIndex: number | undefined) => {
+				evaluateItemIndex = evaluateItemIndex === undefined ? itemIndex : evaluateItemIndex;
+				return workflow.expression.resolveSimpleParameterValue(
+					`=${expression}`,
+					{},
+					runExecutionData,
+					runIndex,
+					evaluateItemIndex,
+					node.name,
+					connectionInputData,
+					mode,
+					getAdditionalKeys(additionalData),
+				);
+			},
+			getContext(type: string): IContextObject {
+				return NodeHelpers.getContext(runExecutionData, type, node);
+			},
+			async getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined> {
+				return getCredentials(
+					workflow,
+					node,
+					type,
+					additionalData,
+					mode,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					itemIndex,
+				);
+			},
+			getInputData: (inputIndex = 0, inputName = 'main') => {
+				if (!Object.prototype.hasOwnProperty.call(inputData, inputName)) {
+					// Return empty array because else it would throw error when nothing is connected to input
+					return { json: {} };
+				}
+
+				// TODO: Check if nodeType has input with that index defined
+				if (inputData[inputName].length < inputIndex) {
+					throw new Error(`Could not get input index "${inputIndex}" of input "${inputName}"!`);
+				}
+
+				const allItems = inputData[inputName][inputIndex];
+
+				if (allItems === null) {
+					// return [];
+					throw new Error(`Value "${inputIndex}" of input "${inputName}" did not get set!`);
+				}
+
+				if (allItems[itemIndex] === null) {
+					// return [];
+					throw new Error(
+						`Value "${inputIndex}" of input "${inputName}" with itemIndex "${itemIndex}" did not get set!`,
+					);
+				}
+
+				return allItems[itemIndex];
+			},
+			getMode: (): WorkflowExecuteMode => {
+				return mode;
+			},
+			getNode: () => {
+				return getNode(node);
+			},
+			getRestApiUrl: (): string => {
+				return additionalData.restApiUrl;
+			},
+			getTimezone: (): string => {
+				return getTimezone(workflow, additionalData);
+			},
+			getNodeParameter: (
+				parameterName: string,
+				fallbackValue?: any,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object => {
+				return getNodeParameter(
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					node,
+					parameterName,
+					itemIndex,
+					mode,
+					getAdditionalKeys(additionalData),
+					fallbackValue,
+				);
+			},
+			getWorkflow: () => {
+				return getWorkflowMetadata(workflow);
+			},
+			getWorkflowDataProxy: (): IWorkflowDataProxyData => {
+				const dataProxy = new WorkflowDataProxy(
+					workflow,
+					runExecutionData,
+					runIndex,
+					itemIndex,
+					node.name,
+					connectionInputData,
+					{},
+					mode,
+					getAdditionalKeys(additionalData),
+				);
+				return dataProxy.getDataProxy();
+			},
+			getWorkflowStaticData(type: string): IDataObject {
+				return workflow.getStaticData(type, node);
+			},
+			helpers: {
+				httpRequest,
+				async requestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return requestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				async prepareBinaryData(
+					binaryData: Buffer,
+					filePath?: string,
+					mimeType?: string,
+				): Promise<IBinaryData> {
+					return prepareBinaryData.call(
+						this,
+						binaryData,
+						additionalData.executionId!,
+						filePath,
+						mimeType,
+					);
+				},
+				request: proxyRequestToAxios,
+				async requestOAuth2(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return requestOAuth2.call(
+						this,
+						credentialsType,
+						requestOptions,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async requestOAuth1(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+				): Promise<any> {
+					return requestOAuth1.call(this, credentialsType, requestOptions);
+				},
+				async httpRequestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: IHttpRequestOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return httpRequestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+			},
+			getInstanceId: () => {
+				// Return the node's instance ID if available, otherwise return an empty string
+				return node.id || '';
+			},
+		};
+	})(workflow, runExecutionData, connectionInputData, inputData, node, itemIndex) as IExecuteSingleFunctions;
+}
+
+export function getCredentialTestFunctions(): ICredentialTestFunctions {
+	return {
+		helpers: {
+			request: proxyRequestToAxios,
+		},
+	};
+}
+
+/**
+ * Returns the execute functions regular nodes have access to in load-options-function.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {ILoadOptionsFunctions}
+ */
+export function getLoadOptionsFunctions(
+	workflow: Workflow,
+	node: INode,
+	path: string,
+	additionalData: IWorkflowExecuteAdditionalData,
+): ILoadOptionsFunctions {
+	return ((workflow: Workflow, node: INode, path: string) => {
+		const that = {
+			async getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined> {
+				return getCredentials(workflow, node, type, additionalData, 'internal');
+			},
+			getCurrentNodeParameter: (
+				parameterPath: string,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object
+				| undefined => {
+				const nodeParameters = additionalData.currentNodeParameters;
+
+				if (parameterPath.charAt(0) === '&') {
+					parameterPath = `${path.split('.').slice(1, -1).join('.')}.${parameterPath.slice(1)}`;
+				}
+
+				return get(nodeParameters, parameterPath);
+			},
+			getCurrentNodeParameters: (): INodeParameters | undefined => {
+				return additionalData.currentNodeParameters;
+			},
+			getNode: () => {
+				return getNode(node);
+			},
+			getNodeParameter: (
+				parameterName: string,
+				fallbackValue?: any,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object => {
+				const runExecutionData: IRunExecutionData | null = null;
+				const itemIndex = 0;
+				const runIndex = 0;
+				const connectionInputData: INodeExecutionData[] = [];
+
+				return getNodeParameter(
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					node,
+					parameterName,
+					itemIndex,
+					'internal' as WorkflowExecuteMode,
+					getAdditionalKeys(additionalData),
+					fallbackValue,
+				);
+			},
+			getTimezone: (): string => {
+				return getTimezone(workflow, additionalData);
+			},
+			getRestApiUrl: (): string => {
+				return additionalData.restApiUrl;
+			},
+			helpers: {
+				httpRequest,
+				async requestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return requestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				request: proxyRequestToAxios,
+				async requestOAuth2(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return requestOAuth2.call(
+						this,
+						credentialsType,
+						requestOptions,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async requestOAuth1(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+				): Promise<any> {
+					return requestOAuth1.call(this, credentialsType, requestOptions);
+				},
+				async httpRequestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: IHttpRequestOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return httpRequestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+			},
+			getInstanceId: () => {
+				// Return the node's instance ID if available, otherwise return an empty string
+				return node.id || '';
+			},
+		};
+		return that;
+	})(workflow, node, path) as ILoadOptionsFunctions;
+}
+
+/**
+ * Returns the execute functions regular nodes have access to in hook-function.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {IHookFunctions}
+ */
+export function getExecuteHookFunctions(
+	workflow: Workflow,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+	activation: WorkflowActivateMode,
+	isTest?: boolean,
+	webhookData?: IWebhookData,
+): IHookFunctions {
+	return ((workflow: Workflow, node: INode) => {
+		const that = {
+			async getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined> {
+				return getCredentials(workflow, node, type, additionalData, mode);
+			},
+			getMode: (): WorkflowExecuteMode => {
+				return mode;
+			},
+			getActivationMode: (): WorkflowActivateMode => {
+				return activation;
+			},
+			getNode: () => {
+				return getNode(node);
+			},
+			getNodeParameter: (
+				parameterName: string,
+				fallbackValue?: any,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object => {
+				const runExecutionData: IRunExecutionData | null = null;
+				const itemIndex = 0;
+				const runIndex = 0;
+				const connectionInputData: INodeExecutionData[] = [];
+
+				return getNodeParameter(
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					node,
+					parameterName,
+					itemIndex,
+					mode,
+					getAdditionalKeys(additionalData),
+					fallbackValue,
+				);
+			},
+			getNodeWebhookUrl: (name: string): string | undefined => {
+				return getNodeWebhookUrl(
+					name,
+					workflow,
+					node,
+					additionalData,
+					mode,
+					getAdditionalKeys(additionalData),
+					isTest,
+				);
+			},
+			getTimezone: (): string => {
+				return getTimezone(workflow, additionalData);
+			},
+			getWebhookName(): string {
+				if (webhookData === undefined) {
+					throw new Error('Is only supported in webhook functions!');
+				}
+				return webhookData.webhookDescription.name;
+			},
+			getWebhookDescription(name: string): IWebhookDescription | undefined {
+				return getWebhookDescription(name, workflow, node);
+			},
+			getWorkflow: () => {
+				return getWorkflowMetadata(workflow);
+			},
+			getWorkflowStaticData(type: string): IDataObject {
+				return workflow.getStaticData(type, node);
+			},
+			helpers: {
+				httpRequest,
+				async requestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return requestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				request: proxyRequestToAxios,
+				async requestOAuth2(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return requestOAuth2.call(
+						this,
+						credentialsType,
+						requestOptions,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async requestOAuth1(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+				): Promise<any> {
+					return requestOAuth1.call(this, credentialsType, requestOptions);
+				},
+				async httpRequestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: IHttpRequestOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return httpRequestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+			},
+			getInstanceId: () => {
+				// Return the node's instance ID if available, otherwise return an empty string
+				return node.id || '';
+			},
+		};
+		return that;
+	})(workflow, node) as IHookFunctions;
+}
+
+/**
+ * Returns the execute functions regular nodes have access to when webhook-function is defined.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IRunExecutionData} runExecutionData
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {IWebhookFunctions}
+ */
+export function getExecuteWebhookFunctions(
+	workflow: Workflow,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+	webhookData: IWebhookData,
+	runExecutionData: IRunExecutionData | undefined,
+): IWebhookFunctions {
+	return ((workflow: Workflow, node: INode) => {
+		return {
+			logger: Logger,
+			evaluateExpression: (expression: string, itemIndex?: number) => {
+				//TODO: Implement this EVALUATE EXPRESSION in get webhook execute function
+				return {} as NodeParameterValueType;
+			},
+			getChildNodes: (nodeName: string, options?: { includeNodeParameters?: boolean }) => {
+				return [];
+			},
+			getParentNodes: (nodeName: string): NodeTypeAndVersion[] => {
+				return [];
+			},
+			getBodyData(): IDataObject {
+				if (additionalData.httpRequest === undefined) {
+					throw new Error('Request is missing!');
+				}
+				return additionalData.httpRequest.body;
+			},
+			async getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined> {
+				return getCredentials(workflow, node, type, additionalData, mode);
+			},
+			nodeHelpers: {
+				copyBinaryFile: async (filePath: string, fileName: string, mimeType?: string): Promise<IBinaryData> => {
+					// Use fs.promises.readFile instead of fsReadFileAsync
+					const buffer = await fs.readFile(filePath);
+					return prepareBinaryData(buffer, workflow.id || '', filePath, mimeType);
+				},
+			},
+			getHeaderData(): object {
+				if (additionalData.httpRequest === undefined) {
+					throw new Error('Request is missing!');
+				}
+				return additionalData.httpRequest.headers;
+			},
+			getMode: (): WorkflowExecuteMode => {
+				return mode;
+			},
+			getNode: () => {
+				return getNode(node);
+			},
+			getNodeParameter: (
+				parameterName: string,
+				fallbackValue?: any,
+				options?: IGetNodeParameterOptions,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object => {
+				const itemIndex = 0;
+				const runIndex = 0;
+
+				let connectionInputData: INodeExecutionData[] = [];
+				let executionData: IExecuteData | undefined;
+				if (runExecutionData?.executionData !== undefined) {
+					executionData = runExecutionData.executionData.nodeExecutionStack[0];
+					if (executionData !== undefined) {
+						connectionInputData = executionData.data['main']?.[0] || [];
+					}
+				}
+
+				return getNodeParameter(
+					workflow,
+					runExecutionData || null,
+					runIndex,
+					connectionInputData,
+					node,
+					parameterName,
+					itemIndex,
+					mode,
+					getAdditionalKeys(additionalData),
+					fallbackValue,
+				);
+			},
+			getParamsData(): object {
+				if (additionalData.httpRequest === undefined) {
+					throw new Error('Request is missing!');
+				}
+				return additionalData.httpRequest.params;
+			},
+			getQueryData(): object {
+				if (additionalData.httpRequest === undefined) {
+					throw new Error('Request is missing!');
+				}
+				return additionalData.httpRequest.query;
+			},
+			getRequestObject(): Request {
+				if (additionalData.httpRequest === undefined) {
+					throw new Error('Request is missing!');
+				}
+				return additionalData.httpRequest;
+			},
+			getResponseObject(): Response {
+				if (additionalData.httpResponse === undefined) {
+					throw new Error('Response is missing!');
+				}
+				return additionalData.httpResponse;
+			},
+			getNodeWebhookUrl: (name: string): string | undefined => {
+				return getNodeWebhookUrl(
+					name,
+					workflow,
+					node,
+					additionalData,
+					mode,
+					getAdditionalKeys(additionalData),
+				);
+			},
+			getTimezone: (): string => {
+				return getTimezone(workflow, additionalData);
+			},
+			getWorkflow: () => {
+				return getWorkflowMetadata(workflow);
+			},
+			getWorkflowStaticData(type: string): IDataObject {
+				return workflow.getStaticData(type, node);
+			},
+			getWebhookName(): string {
+				return webhookData.webhookDescription.name;
+			},
+			addInputData(
+				data: INodeExecutionData[][] | ExecutionError,
+				node: INode
+			): { index: number, inputExecutionData: IRunExecutionData } {
+				const nodeName = node.name;
+				let currentNodeRunIndex = 0;
+				runExecutionData = {
+					startData: {
+						destinationNode: nodeName,
+					},
+					resultData: {
+						error: undefined,
+						runData: {
+							[nodeName]: [JSON.parse(JSON.stringify(data))]
+						},
+						lastNodeExecuted: nodeName,
+					},
+					executionData: {
+						contextData: {},
+						nodeExecutionStack: [],
+						waitingExecution: {},
+					},
+					waitTill: undefined,
+				}
+		
+				return { index: currentNodeRunIndex, inputExecutionData: runExecutionData };
+			},
+			addOutputData(
+				data: INodeExecutionData[][] | ExecutionError,
+				node: INode,
+			): { outputExecutionData: IRunExecutionData } {
+				const nodeName = node.name;
+				const outputExecutionData = {
+					startData: {
+						destinationNode: nodeName,
+					},
+					resultData: {
+						error: undefined,
+						runData: {
+							[nodeName]: [JSON.parse(JSON.stringify(data))]
+						},
+						lastNodeExecuted: nodeName,
+					},
+					executionData: {
+						contextData: {},
+						nodeExecutionStack: [],
+						waitingExecution: {},
+					},
+					waitTill: undefined,
+				}
+				return { outputExecutionData };
+				
+			},
+			logAiEvent: (event: AiEvent, data?: string): void => {
+				// Simple implementation for logAiEvent in webhook functions
+				return;
+			},
+			prepareOutputData: NodeHelpers.prepareOutputData,
+			helpers: {
+				httpRequest,
+				async requestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return requestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				async prepareBinaryData(
+					binaryData: Buffer,
+					filePath?: string,
+					mimeType?: string,
+				): Promise<IBinaryData> {
+					return prepareBinaryData.call(
+						this,
+						binaryData,
+						additionalData.executionId!,
+						filePath,
+						mimeType,
+					);
+				},
+				request: proxyRequestToAxios,
+				async requestOAuth2(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return requestOAuth2.call(
+						this,
+						credentialsType,
+						requestOptions,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async requestOAuth1(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+				): Promise<any> {
+					return requestOAuth1.call(this, credentialsType, requestOptions);
+				},
+				async httpRequestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: IHttpRequestOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return httpRequestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				returnJsonArray,
+			},
+			getInstanceId: () => {
+				// Return the node's instance ID if available, otherwise return an empty string
+				return node.id || '';
+			},
+		};
+	})(workflow, node) as IWebhookFunctions;
+}
+
+export function getSupplyDataFunctions(
+	workflow: Workflow,
+	runExecutionData: IRunExecutionData,
+	runIndex: number,
+	connectionInputData: INodeExecutionData[],
+	inputData: ITaskDataConnections,
+	node: INode,
+	additionalData: IWorkflowExecuteAdditionalData,
+	mode: WorkflowExecuteMode,
+	nodeTypeData: INodeType,
+	closeFunctions: CloseFunction[],
+): ISupplyDataFunctions {
+	return ((workflow, runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions) => {
+		return {
+			logger: Logger,
+			continueOnFail: () => {
+				return continueOnFail(node);
+			},
+			evaluateExpression: (expression: string, itemIndex: number) => {
+				return workflow.expression.resolveSimpleParameterValue(
+					`=${expression}`,
+					{},
+					runExecutionData,
+					runIndex,
+					itemIndex,
+					node.name,
+					connectionInputData,
+					mode,
+					getAdditionalKeys(additionalData),
+				);
+			},
+			async executeWorkflow(
+				workflowInfo: IExecuteWorkflowInfo,
+				inputData?: INodeExecutionData[],
+			): Promise<any> {
+				return additionalData
+					.executeWorkflow(workflowInfo, additionalData, inputData)
+					.then(async (result) =>
+						BinaryDataManager.getInstance().duplicateBinaryData(
+							result,
+							additionalData.executionId!,
+						),
+					);
+			},
+			getContext(type: string): IContextObject {
+				return NodeHelpers.getContext(runExecutionData, type, node);
+			},
+			async getCredentials(
+				type: string,
+				itemIndex?: number,
+			): Promise<ICredentialDataDecryptedObject | undefined> {
+				return getCredentials(
+					workflow,
+					node,
+					type,
+					additionalData,
+					mode,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					itemIndex,
+				);
+			},
+			getExecutionId: (): string => {
+				return additionalData.executionId!;
+			},
+			getInputData: (inputIndex = 0, inputName = 'main') => {
+				if (!Object.prototype.hasOwnProperty.call(inputData, inputName)) {
+					// Return empty array because else it would throw error when nothing is connected to input
+					return [];
+				}
+
+				// TODO: Check if nodeType has input with that index defined
+				if (inputData[inputName].length < inputIndex) {
+					throw new Error(`Could not get input index "${inputIndex}" of input "${inputName}"!`);
+				}
+
+				if (inputData[inputName][inputIndex] === null) {
+					// return [];
+					throw new Error(`Value "${inputIndex}" of input "${inputName}" did not get set!`);
+				}
+
+				return inputData[inputName][inputIndex] as INodeExecutionData[];
+			},
+			getNodeParameter: (
+				parameterName: string,
+				itemIndex: number,
+				fallbackValue?: any,
+			):
+				| NodeParameterValue
+				| INodeParameters
+				| NodeParameterValue[]
+				| INodeParameters[]
+				| object => {
+				return getNodeParameter(
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					node,
+					parameterName,
+					itemIndex,
+					mode,
+					getAdditionalKeys(additionalData),
+					fallbackValue,
+				);
+			},
+			getMode: (): WorkflowExecuteMode => {
+				return mode;
+			},
+			getNode: () => {
+				return getNode(node);
+			},
+			getRestApiUrl: (): string => {
+				return additionalData.restApiUrl;
+			},
+			getTimezone: (): string => {
+				return getTimezone(workflow, additionalData);
+			},
+			getWorkflow: () => {
+				return getWorkflowMetadata(workflow);
+			},
+			getWorkflowDataProxy: (itemIndex: number): IWorkflowDataProxyData => {
+				const dataProxy = new WorkflowDataProxy(
+					workflow,
+					runExecutionData,
+					runIndex,
+					itemIndex,
+					node.name,
+					connectionInputData,
+					{},
+					mode,
+					getAdditionalKeys(additionalData),
+				);
+				return dataProxy.getDataProxy();
+			},
+			getWorkflowStaticData(type: string): IDataObject {
+				return workflow.getStaticData(type, node);
+			},
+			prepareOutputData: NodeHelpers.prepareOutputData,
+			async putExecutionToWait(waitTill: Date): Promise<void> {
+				runExecutionData.waitTill = waitTill;
+			},
+			sendMessageToUI(...args: any[]): void {
+				if (mode !== 'manual') {
+					return;
+				}
+				try {
+					if (additionalData.sendMessageToUI) {
+						additionalData.sendMessageToUI(node.name, args);
+					}
+				} catch (error: any) {
+					// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+					Logger.warn(`There was a problem sending messsage to UI: ${error.message}`);
+				}
+			},
+			async sendResponse(response: IExecuteResponsePromiseData): Promise<void> {
+				await additionalData.hooks?.executeHookFunctions('sendResponse', [response]);
+			},
+			helpers: {
+				httpRequest,
+				async requestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return requestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				assertBinaryData(
+					itemIndex: number,
+					propertyName: string,
+					inputIndex = 0,
+				): IBinaryData {
+					const binaryKeyData = inputData['main'][inputIndex]![itemIndex].binary;
+					if (binaryKeyData === undefined) {
+						throw new NodeOperationError(
+							node,
+							`This operation expects the node's input data to contain a binary file '${propertyName}', but none was found [item ${itemIndex}]`,
+							{
+								itemIndex,
+								description: 'Make sure that the previous node outputs a binary file',
+							},
+						);
+					}
+
+					const binaryPropertyData = binaryKeyData[propertyName];
+					if (binaryPropertyData === undefined) {
+						throw new NodeOperationError(
+							node,
+							`The item has no binary field '${propertyName}' [item ${itemIndex}]`,
+							{
+								itemIndex,
+								description:
+									'Check that the parameter where you specified the input binary field name is correct, and that it matches a field in the binary input',
+							},
+						);
+					}
+
+					return binaryPropertyData;
+				},
+
+				async prepareBinaryData(
+					binaryData: Buffer,
+					filePath?: string,
+					mimeType?: string,
+				): Promise<IBinaryData> {
+					return prepareBinaryData.call(
+						this,
+						binaryData,
+						additionalData.executionId!,
+						filePath,
+						mimeType,
+					);
+				},
+				async getBinaryDataBuffer(
+					itemIndex: number,
+					propertyName: string,
+					inputIndex = 0,
+				): Promise<Buffer> {
+					return getBinaryDataBuffer.call(this, inputData, itemIndex, propertyName, inputIndex);
+				},
+				request: proxyRequestToAxios,
+				async requestOAuth2(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
+					oAuth2Options?: IOAuth2Options,
+				): Promise<any> {
+					return requestOAuth2.call(
+						this,
+						credentialsType,
+						requestOptions,
+						node,
+						additionalData,
+						oAuth2Options,
+					);
+				},
+				async requestOAuth1(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
+				): Promise<any> {
+					return requestOAuth1.call(this, credentialsType, requestOptions);
+				},
+				async httpRequestWithAuthentication(
+					this: IAllExecuteFunctions,
+					credentialsType: string,
+					requestOptions: IHttpRequestOptions,
+					additionalCredentialOptions?: IAdditionalCredentialOptions,
+				): Promise<any> {
+					return httpRequestWithAuthentication.call(
+						this,
+						credentialsType,
+						requestOptions,
+						workflow,
+						node,
+						additionalData,
+						additionalCredentialOptions,
+					);
+				},
+				returnJsonArray,
+				normalizeItems,
+			},
+			getInstanceId: () => {
+				// Return the node's instance ID if available, otherwise return an empty string
+				return node.id || '';
+			},
+
+			addInputData(
+				data: INodeExecutionData[][] | ExecutionError,
+				node: INode
+			): { index: number, inputExecutionData: IRunExecutionData } {
+				const nodeName = node.name;
+				let currentNodeRunIndex = 0;
+				runExecutionData = {
+					startData: {
+						destinationNode: nodeName,
+					},
+					resultData: {
+						error: undefined,
+						runData: {
+							[nodeName]: [JSON.parse(JSON.stringify(data))]
+						},
+						lastNodeExecuted: nodeName,
+					},
+					executionData: {
+						contextData: {},
+						nodeExecutionStack: [],
+						waitingExecution: {},
+					},
+					waitTill: undefined,
+				}
+		
+				return { index: currentNodeRunIndex, inputExecutionData: runExecutionData };
+			},
+			addOutputData(
+				data: INodeExecutionData[][] | ExecutionError,
+				node: INode,
+			): { outputExecutionData: IRunExecutionData } {
+				const nodeName = node.name;
+				const outputExecutionData = {
+					startData: {
+						destinationNode: nodeName,
+					},
+					resultData: {
+						error: undefined,
+						runData: {
+							[nodeName]: [JSON.parse(JSON.stringify(data))]
+						},
+						lastNodeExecuted: nodeName,
+					},
+					executionData: {
+						contextData: {},
+						nodeExecutionStack: [],
+						waitingExecution: {},
+					},
+					waitTill: undefined,
+				}
+				return { outputExecutionData };
+				
+			},
+			async getInputConnectionData(
+				this: IExecuteFunctions | ISupplyDataFunctions,
+				connectionType: NodeConnectionType,
+				itemIndex: number,
+			): Promise<unknown> {
+				return await getInputConnectionData.call(
+					this,
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					inputData,
+					additionalData,
+					connectionType,
+					mode,
+					itemIndex,
+					nodeTypeData,
+					closeFunctions,
+				);
+			},
+		};
+	})(workflow, runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions);
+}
+
+export async function getInputConnectionData(
+	this: IExecuteFunctions | ISupplyDataFunctions,
+	workflow: Workflow,
+	runExecutionData: IRunExecutionData,
+	runIndex: number,
+	connectionInputData: INodeExecutionData[],
+	inputData: ITaskDataConnections,
+	additionalData: IWorkflowExecuteAdditionalData,
+	connectionType: NodeConnectionType,
+	mode: WorkflowExecuteMode,
+	itemIndex: number,
+	nodeTypeData: INodeType,
+	closeFunctions: CloseFunction[],
+): Promise<unknown> {
+	const parentNode = this.getNode();
+	const startTime = Date.now();
+
+	const nodeInputs = getNodeInputs(workflow, parentNode, nodeTypeData.description).map(
+		(input) => (typeof input === 'string' ? { type: input } : input),
+	) as INodeInputConfiguration[];
+	const inputConfiguration = nodeInputs.find((input) => input.type === connectionType);
+	if (inputConfiguration === undefined) {
+		throw new NodeOperationError(
+			parentNode,
+			`Node does not have input of type`,
+			{
+				description: `Node ${parentNode.name} does not have input of type ${connectionType}`,
+			}
+		);
+	}
+
+	const connectedNodes = getConnectedNodes(workflow, parentNode, connectionType);
+	if (connectedNodes.length === 0) {
+		if (inputConfiguration.required) {
+			throw new NodeOperationError(
+				parentNode,
+				`A ${inputConfiguration?.displayName ?? connectionType} sub-node must be connected and enabled`,
+			);
+		}
+		return inputConfiguration.maxConnections === 1 ? undefined : [];
+	}
+
+	if (
+		inputConfiguration.maxConnections !== undefined &&
+		connectedNodes.length > inputConfiguration.maxConnections
+	) {
+		throw new NodeOperationError(
+			parentNode,
+			`Only ${inputConfiguration.maxConnections} ${connectionType} sub-nodes are/is allowed to be connected`,
+		);
+	}
+
+	const nodes: SupplyData[] = [];
+	for (const connectedNode of connectedNodes) {
+		const connectedNodeType = workflow.nodeTypes.getByNameAndVersion(
+			connectedNode.type,
+			connectedNode.typeVersion,
+		);
+
+		if (!connectedNodeType) {
+			continue;
+		}
+
+		if (connectedNodeType && !connectedNodeType.supplyData) {
+			throw new NodeOperationError(connectedNode, 'Node does not have a `supplyData` method defined', {
+				itemIndex,
+			});
+		} else {
+			try {
+				await additionalData.hooks?.executeHookFunctions('nodeExecuteBefore', [connectedNode.name, {
+					startTime: startTime,
+					executionTime: new Date().getTime() - startTime
+				}]);
+				
+				const context = getSupplyDataFunctions(
+					workflow,
+					runExecutionData,
+					runIndex,
+					connectionInputData,
+					inputData,
+					connectedNode,
+					additionalData,
+					mode,
+					nodeTypeData,
+					closeFunctions,
+				);
+
+				const supplyData = await connectedNodeType.supplyData?.call(context, itemIndex);
+				if (supplyData) {
+					nodes.push(supplyData);
+					
+					if (supplyData.closeFunction) {
+						closeFunctions.push(supplyData.closeFunction);
+					}
+
+					const taskData: ITaskData = {
+						startTime: startTime,
+						executionTime: new Date().getTime() - startTime
+					};
+
+					if (!Object.prototype.hasOwnProperty.call(runExecutionData.resultData.runData, connectedNode.name)) {
+						runExecutionData.resultData.runData[connectedNode.name] = [];
+					}
+
+					runExecutionData.resultData.runData[connectedNode.name][runIndex] = taskData;
+
+					await additionalData.hooks?.executeHookFunctions('nodeExecuteAfter', [
+						connectedNode.name,
+						taskData,
+						runExecutionData
+					]);
+				}
+			} catch (error: any) {
+				const taskData: ITaskData = {
+					startTime: startTime,
+					executionTime: new Date().getTime() - startTime,
+					error: error
+				};
+				runExecutionData.resultData.runData[connectedNode.name][runIndex] = taskData;
+
+				await additionalData.hooks?.executeHookFunctions('nodeExecuteAfter', [
+					connectedNode.name,
+					taskData,
+					runExecutionData
+				]);
+
+				throw new NodeOperationError(connectedNode, `Error in sub-node ${connectedNode.name}`, {
+					itemIndex,
+					description: error?.message ?? 'Unknown error',
+				});
+			}
+		}
+	}
+
+	return inputConfiguration.maxConnections === 1
+		? (nodes || [])[0]?.response
+		: nodes.map((node) => node.response);
+}
+
+function getNodeInputs(
+	workflow: Workflow,
+	node: INode,
+	nodeTypeData: INodeTypeDescription,
+): Array<NodeConnectionType | INodeInputConfiguration> {
+	if (Array.isArray(nodeTypeData?.inputs)) {
+		return nodeTypeData.inputs as Array<NodeConnectionType | INodeInputConfiguration>;
+	}
+
+	// Calculate the outputs dynamically
+	try {
+		return (workflow.expression.getSimpleParameterValue(
+			node,
+			nodeTypeData.inputs,
+			'internal',
+			{},
+		) || []) as NodeConnectionType[];
+	} catch (e) {
+		console.warn('Could not calculate inputs dynamically for node: ', node.name);
+		return [];
+	}
+}
+
+function getConnectedNodes(workflow: Workflow, node: INode, connectionType: NodeConnectionType) {
+	return workflow
+		.getParentNodes(node.name, connectionType, 1)
+		.map((nodeName) => workflow.getNode(nodeName))
+		.filter((node) => !!node)
+		.filter((node) => node.disabled !== true);
+}