@fsai-flow/core 0.0.5 → 0.1.1

package/dist/lib/NodeExecuteFunctions.js

@@ -0,0 +1,2467 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBinaryDataBuffer = getBinaryDataBuffer;
+exports.prepareBinaryData = prepareBinaryData;
+exports.getCurrentOAuth2AccessToken = getCurrentOAuth2AccessToken;
+exports.requestOAuth2 = requestOAuth2;
+exports.requestOAuth1 = requestOAuth1;
+exports.httpRequestWithAuthentication = httpRequestWithAuthentication;
+exports.returnJsonArray = returnJsonArray;
+exports.normalizeItems = normalizeItems;
+exports.requestWithAuthentication = requestWithAuthentication;
+exports.getAdditionalKeys = getAdditionalKeys;
+exports.getCredentials = getCredentials;
+exports.getNode = getNode;
+exports.getNodeParameter = getNodeParameter;
+exports.continueOnFail = continueOnFail;
+exports.getNodeWebhookUrl = getNodeWebhookUrl;
+exports.getTimezone = getTimezone;
+exports.getWebhookDescription = getWebhookDescription;
+exports.getWorkflowMetadata = getWorkflowMetadata;
+exports.getExecutePollFunctions = getExecutePollFunctions;
+exports.getExecuteTriggerFunctions = getExecuteTriggerFunctions;
+exports.getExecuteFunctions = getExecuteFunctions;
+exports.getExecuteSingleFunctions = getExecuteSingleFunctions;
+exports.getCredentialTestFunctions = getCredentialTestFunctions;
+exports.getLoadOptionsFunctions = getLoadOptionsFunctions;
+exports.getExecuteHookFunctions = getExecuteHookFunctions;
+exports.getExecuteWebhookFunctions = getExecuteWebhookFunctions;
+exports.getSupplyDataFunctions = getSupplyDataFunctions;
+exports.getInputConnectionData = getInputConnectionData;
+const crypto = __importStar(require("node:crypto"));
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_https_1 = require("node:https");
+const path = __importStar(require("node:path"));
+const url = __importStar(require("node:url"));
+const node_url_1 = require("node:url");
+const workflow_1 = require("@fsai-flow/workflow");
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const lodash_1 = require("lodash");
+const mime_types_1 = require("mime-types");
+const oauth_1_0a_1 = __importDefault(require("oauth-1.0a"));
+const qs_1 = require("qs");
+const simple_oauth2_1 = require("simple-oauth2");
+const __1 = require("..");
+const BinaryDataManager_1 = require("./BinaryDataManager");
+axios_1.default.defaults.timeout = 900000;
+/**
+ * Creates an HTTPS agent for requests that need to skip standard SSL certificate
+ * validation. If the environment variable `NODE_CUSTOM_CA_CERT_PATH` is set, the
+ * agent will use that CA certificate instead of fully disabling validation — this
+ * is the recommended approach for self-signed or internal certificates.
+ *
+ * Falls back to `rejectUnauthorized: false` only when no custom CA is provided.
+ */
+function createInsecureOrCustomCaAgent() {
+    const customCaPath = process.env["NODE_CUSTOM_CA_CERT_PATH"];
+    if (customCaPath) {
+        try {
+            const ca = (0, node_fs_1.readFileSync)(customCaPath);
+            return new node_https_1.Agent({ ca });
+        }
+        catch (error) {
+            workflow_1.LoggerProxy.warn(`Failed to read custom CA certificate from NODE_CUSTOM_CA_CERT_PATH ("${customCaPath}"). Falling back to disabling SSL certificate validation.`, { error });
+        }
+    }
+    workflow_1.LoggerProxy.warn("SSL certificate validation is disabled for this request. This is strongly discouraged in production. Set the NODE_CUSTOM_CA_CERT_PATH environment variable to a CA certificate file to avoid disabling validation entirely.");
+    // CodeQL: This is intentional — the caller explicitly opted in to skipping
+    // certificate validation (e.g. for self-signed certs in internal environments).
+    // The preferred alternative (custom CA via NODE_CUSTOM_CA_CERT_PATH) is checked above.
+    return new node_https_1.Agent({ rejectUnauthorized: false }); // lgtm[js/disabling-certificate-validation]
+}
+// Prevent axios from adding x-form-www-urlencoded headers by default
+axios_1.default.defaults.headers.post = {};
+axios_1.default.defaults.headers.put = {};
+axios_1.default.defaults.headers.patch = {};
+axios_1.default.defaults.paramsSerializer = (params) => {
+    if (params instanceof node_url_1.URLSearchParams) {
+        return params.toString();
+    }
+    return (0, qs_1.stringify)(params, { arrayFormat: "indices" });
+};
+const pushFormDataValue = (form, key, value) => {
+    if (value != null &&
+        Object.hasOwn(value, "value") &&
+        Object.hasOwn(value, "options")) {
+        // @ts-expect-error
+        form.append(key, value.value, value.options);
+    }
+    else {
+        form.append(key, value);
+    }
+};
+const createFormDataObject = (data) => {
+    const formData = new form_data_1.default();
+    const keys = Object.keys(data);
+    for (const key of keys) {
+        // @ts-expect-error
+        const formField = data[key];
+        if (Array.isArray(formField)) {
+            for (const item of formField) {
+                pushFormDataValue(formData, key, item);
+            }
+        }
+        else {
+            pushFormDataValue(formData, key, formField);
+        }
+    }
+    return formData;
+};
+function searchForHeader(headers, headerName) {
+    if (headers === undefined) {
+        return undefined;
+    }
+    const headerNames = Object.keys(headers);
+    const lowerHeaderName = headerName.toLowerCase();
+    return headerNames.find((thisHeader) => thisHeader.toLowerCase() === lowerHeaderName);
+}
+async function generateContentLengthHeader(formData, headers) {
+    if (!formData || !formData.getLength) {
+        return;
+    }
+    try {
+        const length = await new Promise((res, rej) => {
+            formData.getLength((error, length) => {
+                if (error) {
+                    rej(error);
+                    return;
+                }
+                res(length);
+            });
+        });
+        Object.assign(headers, {
+            "content-length": length,
+        });
+    }
+    catch (error) {
+        workflow_1.LoggerProxy.error("Unable to calculate form data length", { error });
+    }
+}
+async function parseRequestObject(requestObject) {
+    // 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 = {};
+    if (typeof requestObject["headers"] === "object" &&
+        requestObject["headers"] !== null) {
+        axiosConfig.headers = requestObject["headers"];
+    }
+    // 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];
+    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"] || {});
+            if (requestObject["useQuerystring"] === true) {
+                axiosConfig.data = (0, qs_1.stringify)(allData, { arrayFormat: "repeat" });
+            }
+            else {
+                axiosConfig.data = (0, qs_1.stringify)(allData);
+            }
+        }
+    }
+    else if (contentType &&
+        contentType.includes("multipart/form-data") !== false) {
+        if (requestObject["formData"] !== undefined &&
+            requestObject["formData"] instanceof form_data_1.default) {
+            axiosConfig.data = requestObject["formData"];
+        }
+        else {
+            const allData = {
+                ...requestObject["body"],
+                ...requestObject["formData"],
+            };
+            axiosConfig.data = createFormDataObject(allData);
+        }
+        // replace the existing header with a new one that
+        // contains the boundary property.
+        // @ts-expect-error
+        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);
+    }
+    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"
+                    ? (0, qs_1.stringify)(requestObject["form"], { format: "RFC3986" })
+                    : (0, qs_1.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);
+                for (const header of headers) {
+                    if (header.toLowerCase() === "content-type" && axiosConfig.headers) {
+                        delete axiosConfig.headers[header];
+                    }
+                }
+            }
+            if (requestObject["formData"] instanceof form_data_1.default) {
+                axiosConfig.data = requestObject["formData"];
+            }
+            else {
+                axiosConfig.data = createFormDataObject(requestObject["formData"]);
+            }
+            // 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);
+        }
+        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"];
+        }
+    }
+    if (requestObject["uri"] !== undefined) {
+        axiosConfig.url = requestObject["uri"]?.toString();
+    }
+    if (requestObject["url"] !== undefined) {
+        axiosConfig.url = requestObject["url"]?.toString();
+    }
+    if (requestObject["baseURL"] !== undefined) {
+        axiosConfig.baseURL = requestObject["baseURL"]?.toString();
+    }
+    if (requestObject["method"] !== undefined) {
+        axiosConfig.method = requestObject["method"];
+    }
+    if (requestObject["qs"] !== undefined &&
+        Object.keys(requestObject["qs"]).length > 0) {
+        axiosConfig.params = requestObject["qs"];
+    }
+    if (requestObject["useQuerystring"] === true ||
+        // @ts-expect-error
+        requestObject.qsStringifyOptions?.arrayFormat === "repeat") {
+        axiosConfig.paramsSerializer = (params) => {
+            return (0, qs_1.stringify)(params, { arrayFormat: "repeat" });
+        };
+    }
+    else if (requestObject["useQuerystring"] === false) {
+        axiosConfig.paramsSerializer = (params) => {
+            return (0, qs_1.stringify)(params, { arrayFormat: "indices" });
+        };
+    }
+    // @ts-expect-error
+    if (requestObject.qsStringifyOptions?.arrayFormat === "brackets") {
+        axiosConfig.paramsSerializer = (params) => {
+            return (0, qs_1.stringify)(params, { arrayFormat: "brackets" });
+        };
+    }
+    if (requestObject["auth"] !== undefined) {
+        // Check support for sendImmediately
+        if (requestObject["auth"]["bearer"] !== undefined) {
+            axiosConfig.headers = Object.assign(axiosConfig.headers || {}, {
+                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                Authorization: `Bearer ${requestObject["auth"]["bearer"]}`,
+            });
+        }
+        else {
+            const authObj = requestObject["auth"];
+            // Request accepts both user/username and pass/password
+            axiosConfig.auth = {
+                username: (authObj["user"] || authObj["username"]),
+                password: (authObj["password"] || authObj["pass"]),
+            };
+        }
+    }
+    // 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"] || "get").toLowerCase() ===
+            "get") {
+        axiosConfig.maxRedirects = 0;
+    }
+    if (requestObject["followAllRedirects"] === false &&
+        (requestObject["method"] || "get").toLowerCase() !==
+            "get") {
+        axiosConfig.maxRedirects = 0;
+    }
+    if (requestObject["rejectUnauthorized"] === false) {
+        axiosConfig.httpsAgent = createInsecureOrCustomCaAgent();
+    }
+    if (requestObject["timeout"] !== undefined) {
+        axiosConfig.timeout = requestObject["timeout"];
+    }
+    if (requestObject["proxy"] !== undefined) {
+        // try our best to parse the url provided.
+        if (typeof requestObject["proxy"] === "string") {
+            try {
+                const url = new node_url_1.URL(requestObject["proxy"]);
+                axiosConfig.proxy = {
+                    host: url.hostname,
+                    port: Number.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: Number.parseInt(port, 10),
+                        protocol: "http",
+                        auth: {
+                            username,
+                            password,
+                        },
+                    };
+                }
+                else if (requestObject["proxy"].includes(":")) {
+                    const [hostname, port] = requestObject["proxy"].split(":");
+                    axiosConfig.proxy = {
+                        host: hostname,
+                        port: Number.parseInt(port, 10),
+                        protocol: "http",
+                    };
+                }
+                else {
+                    axiosConfig.proxy = {
+                        host: requestObject["proxy"],
+                        port: 80,
+                        protocol: "http",
+                    };
+                }
+            }
+        }
+        else {
+            axiosConfig.proxy = requestObject["proxy"];
+        }
+    }
+    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, response, auth) {
+    const authDetails = response.headers["www-authenticate"]
+        .split(",")
+        .map((v) => v.split("="));
+    if (authDetails) {
+        const nonceCount = "000000001";
+        const cnonce = crypto.randomBytes(24).toString("hex");
+        const findDetail = (key) => {
+            const entry = authDetails.find((el) => el[0].toLowerCase().indexOf(key) > -1);
+            return entry?.[1]?.replace(/"/g, "");
+        };
+        const realm = findDetail("realm") ?? "";
+        const opaque = findDetail("opaque") ?? "";
+        const nonce = findDetail("nonce") ?? "";
+        // RFC 7616: Support SHA-256 when the server advertises it, falling back
+        // to MD5 only when required by the server (RFC 2617 legacy).  MD5 is
+        // flagged by security scanners as insufficient computational effort for
+        // password hashing, so we prefer SHA-256 whenever available.
+        const serverAlgorithm = (findDetail("algorithm") ?? "MD5").toUpperCase();
+        const hashAlgorithm = serverAlgorithm === "SHA-256" ? "sha256" : "md5";
+        const algorithmLabel = serverAlgorithm === "SHA-256" ? "SHA-256" : "MD5";
+        const ha1 = crypto
+            .createHash(hashAlgorithm)
+            .update(`${auth?.username}:${realm}:${auth?.password}`)
+            .digest("hex");
+        const path = new url.URL(axiosConfig.url).pathname;
+        const ha2 = crypto
+            .createHash(hashAlgorithm)
+            .update(`${axiosConfig.method ?? "GET"}:${path}`)
+            .digest("hex");
+        const response = crypto
+            .createHash(hashAlgorithm)
+            .update(`${ha1}:${nonce}:${nonceCount}:${cnonce}:auth:${ha2}`)
+            .digest("hex");
+        const authorization = `Digest username="${auth?.username}",realm="${realm}",` +
+            `nonce="${nonce}",uri="${path}",qop="auth",algorithm="${algorithmLabel}",` +
+            `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, options) {
+    let axiosConfig = {};
+    let axiosPromise;
+    let configObject;
+    if (uriOrObject !== undefined && typeof uriOrObject === "string") {
+        axiosConfig.url = uriOrObject;
+    }
+    if (uriOrObject !== undefined &&
+        typeof uriOrObject === "object" &&
+        uriOrObject !== null) {
+        configObject = uriOrObject;
+    }
+    else {
+        configObject = options || {};
+    }
+    axiosConfig = Object.assign(axiosConfig, await parseRequestObject(configObject));
+    workflow_1.LoggerProxy.debug("Proxying request to axios");
+    if (configObject.auth?.sendImmediately === false) {
+        // for digest-auth
+        const { auth } = axiosConfig;
+        axiosConfig.auth = undefined;
+        axiosPromise = (async () => {
+            try {
+                return await (0, axios_1.default)(axiosConfig);
+            }
+            catch (resp) {
+                const axiosError = resp;
+                if (axiosError.response === undefined ||
+                    axiosError.response.status !== 401 ||
+                    !axiosError.response.headers["www-authenticate"]?.includes("nonce")) {
+                    throw resp;
+                }
+                axiosConfig = digestAuthAxiosConfig(axiosConfig, axiosError.response, auth);
+                return (0, axios_1.default)(axiosConfig);
+            }
+        })();
+    }
+    else {
+        axiosPromise = (0, axios_1.default)(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;
+            }
+            workflow_1.LoggerProxy.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} - ${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) {
+    // Destructure properties with the same name first.
+    const { headers, method, timeout, auth, proxy, url } = n8nRequest;
+    const axiosRequest = {
+        headers: headers ?? {},
+        method,
+        timeout,
+        auth,
+        proxy,
+        url,
+    };
+    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 = createInsecureOrCustomCaAgent();
+    }
+    if (n8nRequest.arrayFormat !== undefined) {
+        axiosRequest.paramsSerializer = (params) => {
+            return (0, qs_1.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 form_data_1.default) {
+                axiosRequest.headers = axiosRequest.headers || {};
+                axiosRequest.headers["Content-Type"] = "multipart/form-data";
+            }
+            else if (axiosRequest.data instanceof node_url_1.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, "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) {
+    const axiosRequest = convertN8nRequestToAxios(requestOptions);
+    const result = await (0, axios_1.default)(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>}
+ */
+async function getBinaryDataBuffer(inputData, itemIndex, propertyName, inputIndex) {
+    const binaryData = inputData["main"]?.[inputIndex]?.[itemIndex]?.binary?.[propertyName];
+    if (!binaryData) {
+        throw new Error(`No binary data property "${propertyName}" exists on item at index ${itemIndex}`);
+    }
+    return BinaryDataManager_1.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>}
+ */
+async function prepareBinaryData(binaryData, executionId, filePath, mimeType) {
+    let resolvedMimeType = mimeType;
+    if (!resolvedMimeType) {
+        // If no mime type is given figure it out
+        if (filePath) {
+            // Use file path to guess mime type
+            const mimeTypeLookup = (0, mime_types_1.lookup)(filePath);
+            if (mimeTypeLookup) {
+                resolvedMimeType = mimeTypeLookup;
+            }
+        }
+        if (!resolvedMimeType) {
+            // Use buffer to guess mime type
+            const { fileTypeFromBuffer } = await Promise.resolve().then(() => __importStar(require("file-type")));
+            const fileTypeData = await fileTypeFromBuffer(binaryData);
+            if (fileTypeData) {
+                resolvedMimeType = fileTypeData.mime;
+            }
+        }
+        if (!resolvedMimeType) {
+            // Fall back to text
+            resolvedMimeType = "text/plain";
+        }
+    }
+    const returnData = {
+        mimeType: resolvedMimeType,
+        data: "",
+    };
+    let resolvedFilePath = filePath;
+    if (resolvedFilePath) {
+        if (resolvedFilePath.includes("?")) {
+            // Remove maybe present query parameters
+            resolvedFilePath = resolvedFilePath.split("?").shift();
+        }
+        const filePathParts = path.parse(resolvedFilePath);
+        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_1.BinaryDataManager.getInstance().storeBinaryData(returnData, binaryData, executionId);
+}
+async function getCurrentOAuth2AccessToken(credentialsType, node, additionalData, oAuth2Options) {
+    const credentials = (await this.getCredentials(credentialsType));
+    if (!credentials) {
+        throw new workflow_1.NodeOperationError(node, `No credentials of type "${credentialsType}" were returned!`, { description: "Credentials not found" });
+    }
+    const clientId = credentials["clientId"];
+    const clientSecret = credentials["clientSecret"];
+    const scope = credentials["scope"];
+    const grantType = credentials["grantType"];
+    const authUrl = credentials["authUrl"];
+    const accessTokenUrl = credentials["accessTokenUrl"];
+    const httpAgent = credentials["httpAgent"];
+    const oauthTokenData = (credentials["oauthTokenData"] ?? {});
+    let accessToken = (oauthTokenData?.["accessToken"] ?? "");
+    let refreshToken = (oauthTokenData?.["refreshToken"] ?? "");
+    let expiresAt = (oauthTokenData?.["expiresAt"] ?? "");
+    let expiresIn = (oauthTokenData?.["expiresIn"] ?? 0);
+    let tokenType = (oauthTokenData?.["tokenType"] ?? "");
+    const isExpired = !accessToken || !expiresAt || new Date(expiresAt).getTime() <= Date.now();
+    if (isExpired) {
+        workflow_1.LoggerProxy.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 workflow_1.NodeOperationError(node, `The "authUrl" property is required for the "${grantType}" flow. Please check your credentials configuration.`, { description: "Missing authUrl" });
+        }
+        const config = {
+            client: { id: clientId, secret: clientSecret },
+            auth: { tokenHost: authUrl, tokenPath: accessTokenUrl },
+            http: { agent: httpAgent },
+        };
+        if (grantType === "authorizationCode") {
+            const client = new simple_oauth2_1.AuthorizationCode(config);
+            let token = client.createToken({
+                access_token: (0, lodash_1.get)(oauthTokenData, oAuth2Options?.property) || accessToken,
+                refresh_token: refreshToken,
+                token_type: oAuth2Options?.tokenType || tokenType || "Bearer",
+                expires_at: expiresAt,
+                expires_in: expiresIn,
+            });
+            const refreshOptions = oAuth2Options?.includeCredentialsOnRefreshOnBody
+                ? {
+                    body: {
+                        client_id: clientId,
+                        client_secret: clientSecret,
+                    },
+                    headers: {
+                        Authorization: "", // override default basic auth
+                    },
+                }
+                : {};
+            token = await token.refresh(refreshOptions);
+            accessToken = token.token["access_token"];
+            refreshToken = token.token["refresh_token"] || refreshToken;
+            expiresAt = token.token["expires_at"];
+            expiresIn = token.token["expires_in"];
+            tokenType = token.token["token_type"] || "Bearer";
+        }
+        else if (grantType === "clientCredentials") {
+            const client = new simple_oauth2_1.ClientCredentials(config);
+            const token = await client.getToken({ scope });
+            accessToken = token.token["access_token"];
+            refreshToken = token.token["refresh_token"] || refreshToken;
+            expiresAt = token.token["expires_at"];
+            expiresIn = token.token["expires_in"];
+            tokenType = token.token["token_type"] || "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);
+        workflow_1.LoggerProxy.debug(`Access token for credential "${credentialsType}" has been refreshed.`);
+    }
+    return accessToken;
+}
+async function requestOAuth2(credentialsType, requestOptions, node, additionalData, oAuth2Options, isN8nRequest = false) {
+    const credentials = (await this.getCredentials(credentialsType));
+    if (!credentials) {
+        throw new Error("No credentials were returned!");
+    }
+    const oauthTokenData = credentials["oauthTokenData"];
+    if (!oauthTokenData) {
+        throw new Error("OAuth credentials not connected!");
+    }
+    const config = {
+        client: {
+            id: credentials["clientId"],
+            secret: credentials["clientSecret"],
+        },
+        auth: {
+            tokenHost: credentials["authUrl"],
+            tokenPath: credentials["accessTokenUrl"],
+        },
+        http: {
+            agent: credentials["httpAgent"],
+        },
+    };
+    const client = new simple_oauth2_1.AuthorizationCode(config);
+    // Construct token from saved data
+    const tokenObject = client.createToken({
+        access_token: (0, lodash_1.get)(oauthTokenData, oAuth2Options?.property) ||
+            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 {
+        const requestFn = this.helpers["request"];
+        return await requestFn?.(signedOptions);
+    }
+    catch (error) {
+        const statusCodeReturned = oAuth2Options?.tokenExpiredStatusCode ?? 401;
+        const err = error;
+        if (err.statusCode === statusCodeReturned && currentToken.expired()) {
+            // Refresh token
+            workflow_1.LoggerProxy.debug(`OAuth2 token for "${credentialsType}" used by node "${node.name}" expired. Refreshing...`);
+            workflow_1.LoggerProxy.info(`OAuth2 token for "${credentialsType}" used by node "${node.name}" expired. Refreshing...`);
+            const refreshOptions = {};
+            if (oAuth2Options?.includeCredentialsOnRefreshOnBody) {
+                refreshOptions["body"] = {
+                    client_id: credentials["clientId"],
+                    client_secret: credentials["clientSecret"],
+                };
+                refreshOptions["headers"] = {
+                    Authorization: "", // override default basic auth
+                };
+            }
+            let refreshedToken;
+            try {
+                refreshedToken = await currentToken.refresh(refreshOptions);
+            }
+            catch (error) {
+                throw new Error(`Failed to refresh token: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            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"],
+            };
+            // 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);
+            workflow_1.LoggerProxy.debug(`OAuth2 token for "${credentialsType}" used by node "${node.name}" has been renewed.`);
+            workflow_1.LoggerProxy.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];
+            }
+            const retryRequestFn = this.helpers["request"];
+            return isN8nRequest
+                ? this.helpers.httpRequest(retryOptions)
+                : retryRequestFn?.(retryOptions);
+        }
+        throw error;
+    }
+}
+/* Makes a request using OAuth1 data for authentication
+ *
+ * @export
+ * @param {IAllExecuteFunctions} this
+ * @param {string} credentialsType
+ * @param {(OptionsWithUrl | RequestPromiseOptions)} requestOptionså
+ * @returns
+ */
+async function requestOAuth1(credentialsType, requestOptions, isN8nRequest = false) {
+    const credentials = (await this.getCredentials(credentialsType));
+    if (credentials === undefined) {
+        throw new Error("No credentials were returned!");
+    }
+    if (credentials["oauthTokenData"] === undefined) {
+        throw new Error("OAuth credentials not connected!");
+    }
+    const oauth = new oauth_1_0a_1.default({
+        consumer: {
+            key: credentials["consumerKey"],
+            secret: credentials["consumerSecret"],
+        },
+        signature_method: credentials["signatureMethod"],
+        hash_function(base, key) {
+            const algorithm = credentials["signatureMethod"] === "HMAC-SHA1" ? "sha1" : "sha256";
+            return (0, node_crypto_1.createHmac)(algorithm, key).update(base).digest("base64");
+        },
+    });
+    const oauthTokenData = credentials["oauthTokenData"];
+    const token = {
+        key: oauthTokenData["oauth_token"],
+        secret: oauthTokenData["oauth_token_secret"],
+    };
+    // @ts-expect-error
+    requestOptions.data = { ...requestOptions.qs, ...requestOptions.form };
+    // Fixes issue that OAuth1 library only works with "url" property and not with "uri"
+    // @ts-expect-error
+    if (requestOptions.uri && !requestOptions.url) {
+        // @ts-expect-error
+        requestOptions.url = requestOptions.uri;
+        // @ts-expect-error
+        requestOptions.uri = undefined;
+    }
+    // @ts-expect-error
+    requestOptions.headers = oauth.toHeader(oauth.authorize(requestOptions, token));
+    if (isN8nRequest) {
+        return this.helpers.httpRequest(requestOptions);
+    }
+    const oauth1RequestFn = this.helpers["request"];
+    return oauth1RequestFn?.(requestOptions)?.catch(async (error) => {
+        // Unknown error so simply throw it
+        throw error;
+    });
+}
+async function httpRequestWithAuthentication(credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions) {
+    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;
+        if (additionalCredentialOptions?.credentialsDecrypted) {
+            credentialsDecrypted =
+                additionalCredentialOptions.credentialsDecrypted.data;
+        }
+        else {
+            credentialsDecrypted = await this.getCredentials(credentialsType);
+        }
+        if (credentialsDecrypted === undefined) {
+            throw new workflow_1.NodeOperationError(node, `Node "${node.name}" does not have any credentials of type "${credentialsType}" set!`);
+        }
+        const authenticatedOptions = await additionalData.credentialsHelper.authenticate(credentialsDecrypted, credentialsType, requestOptions, workflow, node);
+        return await httpRequest(authenticatedOptions);
+    }
+    catch (error) {
+        throw new workflow_1.NodeApiError(this.getNode(), error);
+    }
+}
+/**
+ * Takes generic input data and brings it into the json format n8n uses.
+ *
+ * @export
+ * @param {(IDataObject | IDataObject[])} jsonData
+ * @returns {INodeExecutionData[]}
+ */
+function returnJsonArray(jsonData) {
+    const returnData = [];
+    const dataArray = Array.isArray(jsonData) ? jsonData : [jsonData];
+    for (const data of dataArray) {
+        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[]}
+ */
+function normalizeItems(executionData) {
+    const dataArray = typeof executionData === "object" && !Array.isArray(executionData)
+        ? [{ json: executionData }]
+        : executionData;
+    if (dataArray.every((item) => typeof item === "object" && "json" in item))
+        return dataArray;
+    if (dataArray.some((item) => typeof item === "object" && "json" in item)) {
+        throw new Error("Inconsistent item format");
+    }
+    if (dataArray.every((item) => typeof item === "object" && "binary" in item)) {
+        const normalizedItems = [];
+        for (const item of dataArray) {
+            const json = {};
+            for (const key of Object.keys(item)) {
+                if (key !== "binary") {
+                    json[key] = item[key];
+                }
+            }
+            normalizedItems.push({
+                json,
+                binary: item.binary,
+            });
+        }
+        return normalizedItems;
+    }
+    if (dataArray.some((item) => typeof item === "object" && "binary" in item)) {
+        throw new Error("Inconsistent item format");
+    }
+    return dataArray.map((item) => {
+        return { json: item };
+    });
+}
+// TODO: Move up later
+async function requestWithAuthentication(credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions) {
+    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;
+        if (additionalCredentialOptions?.credentialsDecrypted) {
+            credentialsDecrypted =
+                additionalCredentialOptions.credentialsDecrypted.data;
+        }
+        else {
+            credentialsDecrypted = await this.getCredentials(credentialsType);
+        }
+        if (credentialsDecrypted === undefined) {
+            throw new workflow_1.NodeOperationError(node, `Node "${node.name}" does not have any credentials of type "${credentialsType}" set!`);
+        }
+        const authenticatedOptions = await additionalData.credentialsHelper.authenticate(credentialsDecrypted, credentialsType, requestOptions, workflow, node);
+        return await proxyRequestToAxios(authenticatedOptions);
+    }
+    catch (error) {
+        throw new workflow_1.NodeApiError(this.getNode(), error);
+    }
+}
+/**
+ * Returns the additional keys for Expressions and Function-Nodes
+ *
+ * @export
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {(IWorkflowDataProxyAdditionalKeys)}
+ */
+function getAdditionalKeys(additionalData) {
+    const executionId = additionalData.executionId || __1.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)}
+ */
+async function getCredentials(workflow, node, type, additionalData, mode, runExecutionData, runIndex, connectionInputData, itemIndex) {
+    // 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 workflow_1.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;
+    if (!fullAccess) {
+        if (nodeType.description.credentials === undefined) {
+            throw new workflow_1.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 workflow_1.NodeOperationError(node, `Node type "${node.type}" does not have any credentials of type "${type}" defined!`);
+        }
+        if (!workflow_1.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 workflow_1.NodeOperationError(node, "Node does not have any credentials set!");
+            }
+            if (!node.credentials[type]) {
+                throw new workflow_1.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;
+    if (connectionInputData && runExecutionData && runIndex !== undefined) {
+        expressionResolveValues = {
+            connectionInputData,
+            itemIndex: itemIndex || 0,
+            node,
+            runExecutionData,
+            runIndex,
+            workflow,
+        };
+    }
+    const nodeCredentials = node.credentials
+        ? node.credentials[type]
+        : {};
+    // 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}
+ */
+function getNode(node) {
+    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)}
+ */
+function getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, additionalKeys, fallbackValue) {
+    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 = (0, lodash_1.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) {
+        if (e instanceof Error) {
+            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}
+ */
+function continueOnFail(node) {
+    return (0, lodash_1.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)}
+ */
+function getNodeWebhookUrl(name, workflow, node, additionalData, mode, additionalKeys, isTest) {
+    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 = workflow.expression.getSimpleParameterValue(node, webhookDescription.isFullPath, mode, additionalKeys, false);
+    return workflow_1.NodeHelpers.getNodeWebhookUrl(baseUrl, workflow.id, node, path.toString(), isFullPath);
+}
+/**
+ * Returns the timezone for the workflow
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {string}
+ */
+function getTimezone(workflow, additionalData) {
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (workflow.settings !== undefined &&
+        workflow.settings["timezone"] !== undefined) {
+        return workflow.settings.timezone;
+    }
+    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)}
+ */
+function getWebhookDescription(name, workflow, node) {
+    const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+    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}
+ */
+function getWorkflowMetadata(workflow) {
+    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
+function getExecutePollFunctions(workflow, node, additionalData, mode, activation) {
+    return ((workflow, node) => {
+        return {
+            __emit: (_data) => {
+                throw new Error("Overwrite NodeExecuteFunctions.getExecutePullFunctions.__emit function!");
+            },
+            async getCredentials(type) {
+                return getCredentials(workflow, node, type, additionalData, mode);
+            },
+            getMode: () => {
+                return mode;
+            },
+            getActivationMode: () => {
+                return activation;
+            },
+            getNode: () => {
+                return getNode(node);
+            },
+            getNodeParameter: (parameterName, fallbackValue) => {
+                const runExecutionData = null;
+                const itemIndex = 0;
+                const runIndex = 0;
+                const connectionInputData = [];
+                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData), fallbackValue);
+            },
+            getRestApiUrl: () => {
+                return additionalData.restApiUrl;
+            },
+            getTimezone: () => {
+                return getTimezone(workflow, additionalData);
+            },
+            getWorkflow: () => {
+                return getWorkflowMetadata(workflow);
+            },
+            getWorkflowStaticData(type) {
+                return workflow.getStaticData(type, node);
+            },
+            helpers: {
+                httpRequest,
+                async prepareBinaryData(binaryData, filePath, mimeType) {
+                    return prepareBinaryData.call(this, binaryData, additionalData.executionId, filePath, mimeType);
+                },
+                request: proxyRequestToAxios,
+                async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    return requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
+                },
+                async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
+                    return requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
+                },
+                async getCurrentOAuth2AccessToken(credentialsType, oAuth2Options) {
+                    return getCurrentOAuth2AccessToken.call(this, credentialsType, node, additionalData, oAuth2Options);
+                },
+                async requestOAuth1(credentialsType, requestOptions) {
+                    return requestOAuth1.call(this, credentialsType, requestOptions);
+                },
+                async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    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
+function getExecuteTriggerFunctions(workflow, node, additionalData, mode, activation) {
+    return ((workflow, node) => {
+        return {
+            emit: (_data) => {
+                throw new Error("Overwrite NodeExecuteFunctions.getExecuteTriggerFunctions.emit function!");
+            },
+            async getCredentials(type) {
+                return getCredentials(workflow, node, type, additionalData, mode);
+            },
+            getNode: () => {
+                return getNode(node);
+            },
+            getMode: () => {
+                return mode;
+            },
+            getActivationMode: () => {
+                return activation;
+            },
+            getNodeParameter: (parameterName, fallbackValue) => {
+                const runExecutionData = null;
+                const itemIndex = 0;
+                const runIndex = 0;
+                const connectionInputData = [];
+                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData), fallbackValue);
+            },
+            getRestApiUrl: () => {
+                return additionalData.restApiUrl;
+            },
+            getTimezone: () => {
+                return getTimezone(workflow, additionalData);
+            },
+            getWorkflow: () => {
+                return getWorkflowMetadata(workflow);
+            },
+            getWorkflowStaticData(type) {
+                return workflow.getStaticData(type, node);
+            },
+            helpers: {
+                httpRequest,
+                async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    return requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
+                },
+                async prepareBinaryData(binaryData, filePath, mimeType) {
+                    return prepareBinaryData.call(this, binaryData, additionalData.executionId, filePath, mimeType);
+                },
+                request: proxyRequestToAxios,
+                async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
+                    return requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
+                },
+                async requestOAuth1(credentialsType, requestOptions) {
+                    return requestOAuth1.call(this, credentialsType, requestOptions);
+                },
+                async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    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}
+ */
+function getExecuteFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, node, additionalData, mode, nodeTypeData, closeFunctions) {
+    return ((workflow, _runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions) => {
+        let runExecutionData = _runExecutionData;
+        return {
+            continueOnFail: () => {
+                return continueOnFail(node);
+            },
+            evaluateExpression: (expression, itemIndex) => {
+                return workflow.expression.resolveSimpleParameterValue(`=${expression}`, {}, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, getAdditionalKeys(additionalData));
+            },
+            async executeWorkflow(workflowInfo, inputData) {
+                return additionalData
+                    .executeWorkflow(workflowInfo, additionalData, inputData)
+                    .then(async (result) => BinaryDataManager_1.BinaryDataManager.getInstance().duplicateBinaryData(result, additionalData.executionId));
+            },
+            getContext(type) {
+                return workflow_1.NodeHelpers.getContext(runExecutionData, type, node);
+            },
+            async getCredentials(type, itemIndex) {
+                return getCredentials(workflow, node, type, additionalData, mode, runExecutionData, runIndex, connectionInputData, itemIndex);
+            },
+            getExecutionId: () => {
+                return additionalData.executionId;
+            },
+            getInputData: (inputIndex = 0, inputName = "main") => {
+                if (!Object.hasOwn(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];
+            },
+            getNodeParameter: (parameterName, itemIndex, fallbackValue) => {
+                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData), fallbackValue);
+            },
+            getMode: () => {
+                return mode;
+            },
+            getNode: () => {
+                return getNode(node);
+            },
+            getRestApiUrl: () => {
+                return additionalData.restApiUrl;
+            },
+            getTimezone: () => {
+                return getTimezone(workflow, additionalData);
+            },
+            getWorkflow: () => {
+                return getWorkflowMetadata(workflow);
+            },
+            getWorkflowDataProxy: (itemIndex) => {
+                const dataProxy = new workflow_1.WorkflowDataProxy(workflow, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, {}, mode, getAdditionalKeys(additionalData));
+                return dataProxy.getDataProxy();
+            },
+            getWorkflowStaticData(type) {
+                return workflow.getStaticData(type, node);
+            },
+            prepareOutputData: workflow_1.NodeHelpers.prepareOutputData,
+            async putExecutionToWait(waitTill) {
+                runExecutionData.waitTill = waitTill;
+            },
+            sendMessageToUI(...args) {
+                if (mode !== "manual") {
+                    return;
+                }
+                try {
+                    if (additionalData.sendMessageToUI) {
+                        additionalData.sendMessageToUI(node.name, args);
+                    }
+                }
+                catch (error) {
+                    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                    workflow_1.LoggerProxy.warn(`There was a problem sending messsage to UI: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+            async sendResponse(response) {
+                await additionalData.hooks?.executeHookFunctions("sendResponse", [
+                    response,
+                ]);
+            },
+            helpers: {
+                httpRequest,
+                async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    return requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
+                },
+                assertBinaryData(itemIndex, propertyName, inputIndex = 0) {
+                    const binaryKeyData = inputData["main"][inputIndex]?.[itemIndex].binary;
+                    if (binaryKeyData === undefined) {
+                        throw new workflow_1.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 workflow_1.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, filePath, mimeType) {
+                    return prepareBinaryData.call(this, binaryData, additionalData.executionId, filePath, mimeType);
+                },
+                async getBinaryDataBuffer(itemIndex, propertyName, inputIndex = 0) {
+                    return getBinaryDataBuffer.call(this, inputData, itemIndex, propertyName, inputIndex);
+                },
+                request: proxyRequestToAxios,
+                async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
+                    return requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
+                },
+                async requestOAuth1(credentialsType, requestOptions) {
+                    return requestOAuth1.call(this, credentialsType, requestOptions);
+                },
+                async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    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(connectionType, itemIndex) {
+                return await getInputConnectionData.call(this, workflow, runExecutionData, runIndex, connectionInputData, inputData, additionalData, connectionType, mode, itemIndex, nodeTypeData, closeFunctions);
+            },
+            addInputData(data, node) {
+                const nodeName = node.name;
+                const currentNodeRunIndex = 0;
+                runExecutionData = {
+                    startData: {
+                        destinationNode: nodeName,
+                    },
+                    resultData: {
+                        runData: {
+                            [nodeName]: [JSON.parse(JSON.stringify(data))],
+                        },
+                        lastNodeExecuted: nodeName,
+                    },
+                };
+                return {
+                    index: currentNodeRunIndex,
+                    inputExecutionData: runExecutionData,
+                };
+            },
+            addOutputData(data, node) {
+                const nodeName = node.name;
+                const outputExecutionData = {
+                    startData: {
+                        destinationNode: nodeName,
+                    },
+                    resultData: {
+                        error: typeof data === "object" && "error" in data
+                            ? data.error
+                            : undefined,
+                        runData: {
+                            [nodeName]: [JSON.parse(JSON.stringify(data))],
+                        },
+                        lastNodeExecuted: nodeName,
+                    },
+                };
+                return { outputExecutionData };
+            },
+            getExecutionCancelSignal: () => {
+                return undefined;
+            },
+        };
+    })(workflow, runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions);
+}
+/**
+ * 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}
+ */
+function getExecuteSingleFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, node, itemIndex, additionalData, mode) {
+    return ((workflow, runExecutionData, connectionInputData, inputData, node, itemIndex) => {
+        return {
+            continueOnFail: () => {
+                return continueOnFail(node);
+            },
+            evaluateExpression: (expression, evaluateItemIndex) => {
+                const resolvedItemIndex = evaluateItemIndex === undefined ? itemIndex : evaluateItemIndex;
+                return workflow.expression.resolveSimpleParameterValue(`=${expression}`, {}, runExecutionData, runIndex, resolvedItemIndex, node.name, connectionInputData, mode, getAdditionalKeys(additionalData));
+            },
+            getContext(type) {
+                return workflow_1.NodeHelpers.getContext(runExecutionData, type, node);
+            },
+            async getCredentials(type) {
+                return getCredentials(workflow, node, type, additionalData, mode, runExecutionData, runIndex, connectionInputData, itemIndex);
+            },
+            getInputData: (inputIndex = 0, inputName = "main") => {
+                if (!Object.hasOwn(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: () => {
+                return mode;
+            },
+            getNode: () => {
+                return getNode(node);
+            },
+            getRestApiUrl: () => {
+                return additionalData.restApiUrl;
+            },
+            getTimezone: () => {
+                return getTimezone(workflow, additionalData);
+            },
+            getNodeParameter: (parameterName, fallbackValue) => {
+                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData), fallbackValue);
+            },
+            getWorkflow: () => {
+                return getWorkflowMetadata(workflow);
+            },
+            getWorkflowDataProxy: () => {
+                const dataProxy = new workflow_1.WorkflowDataProxy(workflow, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, {}, mode, getAdditionalKeys(additionalData));
+                return dataProxy.getDataProxy();
+            },
+            getWorkflowStaticData(type) {
+                return workflow.getStaticData(type, node);
+            },
+            helpers: {
+                httpRequest,
+                async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    return requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
+                },
+                async prepareBinaryData(binaryData, filePath, mimeType) {
+                    return prepareBinaryData.call(this, binaryData, additionalData.executionId, filePath, mimeType);
+                },
+                request: proxyRequestToAxios,
+                async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
+                    return requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
+                },
+                async requestOAuth1(credentialsType, requestOptions) {
+                    return requestOAuth1.call(this, credentialsType, requestOptions);
+                },
+                async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    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);
+}
+function getCredentialTestFunctions() {
+    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}
+ */
+function getLoadOptionsFunctions(workflow, node, path, additionalData) {
+    return ((workflow, node, path) => {
+        const that = {
+            async getCredentials(type) {
+                return getCredentials(workflow, node, type, additionalData, "internal");
+            },
+            getCurrentNodeParameter: (parameterPath) => {
+                const nodeParameters = additionalData.currentNodeParameters;
+                const resolvedPath = parameterPath.charAt(0) === "&"
+                    ? `${path.split(".").slice(1, -1).join(".")}.${parameterPath.slice(1)}`
+                    : parameterPath;
+                return (0, lodash_1.get)(nodeParameters, resolvedPath);
+            },
+            getCurrentNodeParameters: () => {
+                return additionalData.currentNodeParameters;
+            },
+            getNode: () => {
+                return getNode(node);
+            },
+            getNodeParameter: (parameterName, fallbackValue) => {
+                const runExecutionData = null;
+                const itemIndex = 0;
+                const runIndex = 0;
+                const connectionInputData = [];
+                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, "internal", getAdditionalKeys(additionalData), fallbackValue);
+            },
+            getTimezone: () => {
+                return getTimezone(workflow, additionalData);
+            },
+            getRestApiUrl: () => {
+                return additionalData.restApiUrl;
+            },
+            helpers: {
+                httpRequest,
+                async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    return requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
+                },
+                request: proxyRequestToAxios,
+                async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
+                    return requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
+                },
+                async requestOAuth1(credentialsType, requestOptions) {
+                    return requestOAuth1.call(this, credentialsType, requestOptions);
+                },
+                async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    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);
+}
+/**
+ * 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}
+ */
+function getExecuteHookFunctions(workflow, node, additionalData, mode, activation, isTest, webhookData) {
+    return ((workflow, node) => {
+        const that = {
+            async getCredentials(type) {
+                return getCredentials(workflow, node, type, additionalData, mode);
+            },
+            getMode: () => {
+                return mode;
+            },
+            getActivationMode: () => {
+                return activation;
+            },
+            getNode: () => {
+                return getNode(node);
+            },
+            getNodeParameter: (parameterName, fallbackValue) => {
+                const runExecutionData = null;
+                const itemIndex = 0;
+                const runIndex = 0;
+                const connectionInputData = [];
+                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData), fallbackValue);
+            },
+            getNodeWebhookUrl: (name) => {
+                return getNodeWebhookUrl(name, workflow, node, additionalData, mode, getAdditionalKeys(additionalData), isTest);
+            },
+            getTimezone: () => {
+                return getTimezone(workflow, additionalData);
+            },
+            getWebhookName() {
+                if (webhookData === undefined) {
+                    throw new Error("Is only supported in webhook functions!");
+                }
+                return webhookData.webhookDescription.name;
+            },
+            getWebhookDescription(name) {
+                return getWebhookDescription(name, workflow, node);
+            },
+            getWorkflow: () => {
+                return getWorkflowMetadata(workflow);
+            },
+            getWorkflowStaticData(type) {
+                return workflow.getStaticData(type, node);
+            },
+            helpers: {
+                httpRequest,
+                async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    return requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
+                },
+                request: proxyRequestToAxios,
+                async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
+                    return requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
+                },
+                async requestOAuth1(credentialsType, requestOptions) {
+                    return requestOAuth1.call(this, credentialsType, requestOptions);
+                },
+                async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    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);
+}
+/**
+ * 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}
+ */
+function getExecuteWebhookFunctions(workflow, node, additionalData, mode, webhookData, initialRunExecutionData) {
+    let runExecutionData = initialRunExecutionData;
+    return ((workflow, node) => {
+        return {
+            logger: workflow_1.LoggerProxy,
+            evaluateExpression: (_expression, _itemIndex) => {
+                //TODO: Implement this EVALUATE EXPRESSION in get webhook execute function
+                return {};
+            },
+            getChildNodes: (_nodeName, _options) => {
+                return [];
+            },
+            getParentNodes: (_nodeName) => {
+                return [];
+            },
+            getBodyData() {
+                if (additionalData.httpRequest === undefined) {
+                    throw new Error("Request is missing!");
+                }
+                return additionalData.httpRequest.body;
+            },
+            async getCredentials(type) {
+                return getCredentials(workflow, node, type, additionalData, mode);
+            },
+            nodeHelpers: {
+                copyBinaryFile: async (filePath, _fileName, mimeType) => {
+                    // Use fs.promises.readFile instead of fsReadFileAsync
+                    const buffer = await node_fs_1.promises.readFile(filePath);
+                    return prepareBinaryData(buffer, workflow.id || "", filePath, mimeType);
+                },
+            },
+            getHeaderData() {
+                if (additionalData.httpRequest === undefined) {
+                    throw new Error("Request is missing!");
+                }
+                return additionalData.httpRequest.headers;
+            },
+            getMode: () => {
+                return mode;
+            },
+            getNode: () => {
+                return getNode(node);
+            },
+            getNodeParameter: (parameterName, fallbackValue, _options) => {
+                const itemIndex = 0;
+                const runIndex = 0;
+                let connectionInputData = [];
+                let executionData;
+                if (runExecutionData?.executionData !== undefined) {
+                    executionData = runExecutionData.executionData.nodeExecutionStack[0];
+                    if (executionData !== undefined) {
+                        connectionInputData = executionData.data["main"]?.[0] || [];
+                    }
+                }
+                return getNodeParameter(workflow, runExecutionData || null, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData), fallbackValue);
+            },
+            getParamsData() {
+                if (additionalData.httpRequest === undefined) {
+                    throw new Error("Request is missing!");
+                }
+                return additionalData.httpRequest.params;
+            },
+            getQueryData() {
+                if (additionalData.httpRequest === undefined) {
+                    throw new Error("Request is missing!");
+                }
+                return additionalData.httpRequest.query;
+            },
+            getRequestObject() {
+                if (additionalData.httpRequest === undefined) {
+                    throw new Error("Request is missing!");
+                }
+                return additionalData.httpRequest;
+            },
+            getResponseObject() {
+                if (additionalData.httpResponse === undefined) {
+                    throw new Error("Response is missing!");
+                }
+                return additionalData.httpResponse;
+            },
+            getNodeWebhookUrl: (name) => {
+                return getNodeWebhookUrl(name, workflow, node, additionalData, mode, getAdditionalKeys(additionalData));
+            },
+            getTimezone: () => {
+                return getTimezone(workflow, additionalData);
+            },
+            getWorkflow: () => {
+                return getWorkflowMetadata(workflow);
+            },
+            getWorkflowStaticData(type) {
+                return workflow.getStaticData(type, node);
+            },
+            getWebhookName() {
+                return webhookData.webhookDescription.name;
+            },
+            addInputData(data, node) {
+                const nodeName = node.name;
+                const 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, node) {
+                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, _data) => {
+                // Simple implementation for logAiEvent in webhook functions
+                return;
+            },
+            prepareOutputData: workflow_1.NodeHelpers.prepareOutputData,
+            helpers: {
+                httpRequest,
+                async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    return requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
+                },
+                async prepareBinaryData(binaryData, filePath, mimeType) {
+                    return prepareBinaryData.call(this, binaryData, additionalData.executionId, filePath, mimeType);
+                },
+                request: proxyRequestToAxios,
+                async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
+                    return requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
+                },
+                async requestOAuth1(credentialsType, requestOptions) {
+                    return requestOAuth1.call(this, credentialsType, requestOptions);
+                },
+                async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    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);
+}
+function getSupplyDataFunctions(workflow, runExecutionData, runIndex, connectionInputData, inputData, node, additionalData, mode, nodeTypeData, closeFunctions) {
+    return ((workflow, _runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions) => {
+        let runExecutionData = _runExecutionData;
+        return {
+            logger: workflow_1.LoggerProxy,
+            continueOnFail: () => {
+                return continueOnFail(node);
+            },
+            evaluateExpression: (expression, itemIndex) => {
+                return workflow.expression.resolveSimpleParameterValue(`=${expression}`, {}, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, getAdditionalKeys(additionalData));
+            },
+            async executeWorkflow(workflowInfo, inputData) {
+                return additionalData
+                    .executeWorkflow(workflowInfo, additionalData, inputData)
+                    .then(async (result) => BinaryDataManager_1.BinaryDataManager.getInstance().duplicateBinaryData(result, additionalData.executionId));
+            },
+            getContext(type) {
+                return workflow_1.NodeHelpers.getContext(runExecutionData, type, node);
+            },
+            async getCredentials(type, itemIndex) {
+                return getCredentials(workflow, node, type, additionalData, mode, runExecutionData, runIndex, connectionInputData, itemIndex);
+            },
+            getExecutionId: () => {
+                return additionalData.executionId;
+            },
+            getInputData: (inputIndex = 0, inputName = "main") => {
+                if (!Object.hasOwn(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];
+            },
+            getNodeParameter: (parameterName, itemIndex, fallbackValue) => {
+                return getNodeParameter(workflow, runExecutionData, runIndex, connectionInputData, node, parameterName, itemIndex, mode, getAdditionalKeys(additionalData), fallbackValue);
+            },
+            getMode: () => {
+                return mode;
+            },
+            getNode: () => {
+                return getNode(node);
+            },
+            getRestApiUrl: () => {
+                return additionalData.restApiUrl;
+            },
+            getTimezone: () => {
+                return getTimezone(workflow, additionalData);
+            },
+            getWorkflow: () => {
+                return getWorkflowMetadata(workflow);
+            },
+            getWorkflowDataProxy: (itemIndex) => {
+                const dataProxy = new workflow_1.WorkflowDataProxy(workflow, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, {}, mode, getAdditionalKeys(additionalData));
+                return dataProxy.getDataProxy();
+            },
+            getWorkflowStaticData(type) {
+                return workflow.getStaticData(type, node);
+            },
+            prepareOutputData: workflow_1.NodeHelpers.prepareOutputData,
+            async putExecutionToWait(waitTill) {
+                runExecutionData.waitTill = waitTill;
+            },
+            sendMessageToUI(...args) {
+                if (mode !== "manual") {
+                    return;
+                }
+                try {
+                    if (additionalData.sendMessageToUI) {
+                        additionalData.sendMessageToUI(node.name, args);
+                    }
+                }
+                catch (error) {
+                    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                    workflow_1.LoggerProxy.warn(`There was a problem sending messsage to UI: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+            async sendResponse(response) {
+                await additionalData.hooks?.executeHookFunctions("sendResponse", [
+                    response,
+                ]);
+            },
+            helpers: {
+                httpRequest,
+                async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    return requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
+                },
+                assertBinaryData(itemIndex, propertyName, inputIndex = 0) {
+                    const binaryKeyData = inputData["main"][inputIndex]?.[itemIndex].binary;
+                    if (binaryKeyData === undefined) {
+                        throw new workflow_1.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 workflow_1.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, filePath, mimeType) {
+                    return prepareBinaryData.call(this, binaryData, additionalData.executionId, filePath, mimeType);
+                },
+                async getBinaryDataBuffer(itemIndex, propertyName, inputIndex = 0) {
+                    return getBinaryDataBuffer.call(this, inputData, itemIndex, propertyName, inputIndex);
+                },
+                request: proxyRequestToAxios,
+                async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
+                    return requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
+                },
+                async requestOAuth1(credentialsType, requestOptions) {
+                    return requestOAuth1.call(this, credentialsType, requestOptions);
+                },
+                async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
+                    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, node) {
+                const nodeName = node.name;
+                const 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, node) {
+                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(connectionType, itemIndex) {
+                return await getInputConnectionData.call(this, workflow, runExecutionData, runIndex, connectionInputData, inputData, additionalData, connectionType, mode, itemIndex, nodeTypeData, closeFunctions);
+            },
+        };
+    })(workflow, runExecutionData, connectionInputData, inputData, node, nodeTypeData, closeFunctions);
+}
+async function getInputConnectionData(workflow, runExecutionData, runIndex, connectionInputData, inputData, additionalData, connectionType, mode, itemIndex, nodeTypeData, closeFunctions) {
+    const parentNode = this.getNode();
+    const startTime = Date.now();
+    const nodeInputs = getNodeInputs(workflow, parentNode, nodeTypeData.description).map((input) => typeof input === "string" ? { type: input } : input);
+    const inputConfiguration = nodeInputs.find((input) => input.type === connectionType);
+    if (inputConfiguration === undefined) {
+        throw new workflow_1.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 workflow_1.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 workflow_1.NodeOperationError(parentNode, `Only ${inputConfiguration.maxConnections} ${connectionType} sub-nodes are/is allowed to be connected`);
+    }
+    const nodes = [];
+    for (const connectedNode of connectedNodes) {
+        const connectedNodeType = workflow.nodeTypes.getByNameAndVersion(connectedNode.type, connectedNode.typeVersion);
+        if (!connectedNodeType) {
+            continue;
+        }
+        if (connectedNodeType && !connectedNodeType.supplyData) {
+            throw new workflow_1.NodeOperationError(connectedNode, "Node does not have a `supplyData` method defined", {
+                itemIndex,
+            });
+        }
+        try {
+            await additionalData.hooks?.executeHookFunctions("nodeExecuteBefore", [
+                connectedNode.name,
+                {
+                    startTime: startTime,
+                    executionTime: Date.now() - 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 = {
+                    startTime: startTime,
+                    executionTime: Date.now() - startTime,
+                };
+                if (!Object.hasOwn(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) {
+            const taskData = {
+                startTime: startTime,
+                executionTime: Date.now() - startTime,
+                error: error,
+            };
+            runExecutionData.resultData.runData[connectedNode.name][runIndex] =
+                taskData;
+            await additionalData.hooks?.executeHookFunctions("nodeExecuteAfter", [
+                connectedNode.name,
+                taskData,
+                runExecutionData,
+            ]);
+            throw new workflow_1.NodeOperationError(connectedNode, `Error in sub-node ${connectedNode.name}`, {
+                itemIndex,
+                description: error instanceof Error ? error.message : "Unknown error",
+            });
+        }
+    }
+    return inputConfiguration.maxConnections === 1
+        ? (nodes || [])[0]?.response
+        : nodes.map((node) => node.response);
+}
+function getNodeInputs(workflow, node, nodeTypeData) {
+    if (Array.isArray(nodeTypeData?.inputs)) {
+        return nodeTypeData.inputs;
+    }
+    // Calculate the outputs dynamically
+    try {
+        return (workflow.expression.getSimpleParameterValue(node, nodeTypeData.inputs, "internal", {}) || []);
+    }
+    catch (_e) {
+        console.warn("Could not calculate inputs dynamically for node: ", node.name);
+        return [];
+    }
+}
+function getConnectedNodes(workflow, node, connectionType) {
+    return workflow
+        .getParentNodes(node.name, connectionType, 1)
+        .map((nodeName) => workflow.getNode(nodeName))
+        .filter((node) => !!node)
+        .filter((node) => node.disabled !== true);
+}