n8n-core 2.25.2 → 2.26.1

package/dist/execution-engine/node-execution-context/utils/request-helper-functions.js

@@ -10,1064 +10,9 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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 };
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRequestHelperFunctions = exports.removeEmptyBody = void 0;
-exports.invokeAxios = invokeAxios;
-exports.parseRequestObject = parseRequestObject;
-exports.proxyRequestToAxios = proxyRequestToAxios;
-exports.convertN8nRequestToAxios = convertN8nRequestToAxios;
-exports.httpRequest = httpRequest;
-exports.applyPaginationRequestData = applyPaginationRequestData;
-exports.requestOAuth2 = requestOAuth2;
-exports.requestOAuth1 = requestOAuth1;
-exports.refreshOAuth2Token = refreshOAuth2Token;
-exports.httpRequestWithAuthentication = httpRequestWithAuthentication;
-exports.requestWithAuthentication = requestWithAuthentication;
-const backend_common_1 = require("@n8n/backend-common");
-const client_oauth2_1 = require("@n8n/client-oauth2");
-const di_1 = require("@n8n/di");
-const axios_1 = __importDefault(require("axios"));
-const crypto_1 = __importStar(require("crypto"));
-const http_1 = require("http");
-const get_1 = __importDefault(require("lodash/get"));
-const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
-const merge_1 = __importDefault(require("lodash/merge"));
-const pick_1 = __importDefault(require("lodash/pick"));
-const n8n_workflow_1 = require("n8n-workflow");
-const oauth_1_0a_1 = __importDefault(require("oauth-1.0a"));
-const qs_1 = require("qs");
-const stream_1 = require("stream");
-const eval_mock_helpers_1 = require("../../../execution-engine/eval-mock-helpers");
-const binary_helper_functions_1 = require("./binary-helper-functions");
-const outbound_user_agent_1 = require("./outbound-user-agent");
-const parse_incoming_message_1 = require("./parse-incoming-message");
-require("./request-helpers/axios-config");
-const request_helpers_1 = require("./request-helpers");
-const axios_utils_1 = require("./request-helpers/axios-utils");
-async function invokeAxios(axiosConfig, authOptions = {}) {
-    try {
-        return await (0, axios_1.default)(axiosConfig);
-    }
-    catch (error) {
-        if (authOptions.sendImmediately !== false || !(error instanceof axios_1.default.AxiosError))
-            throw error;
-        const { response } = error;
-        if (response?.status !== 401 || !response.headers['www-authenticate']?.includes('nonce')) {
-            throw error;
-        }
-        const { auth } = axiosConfig;
-        delete axiosConfig.auth;
-        axiosConfig = (0, request_helpers_1.digestAuthAxiosConfig)(axiosConfig, response, auth);
-        return await (0, axios_1.default)(axiosConfig);
-    }
-}
-async function parseRequestObject(requestObject, ssrfBridge) {
-    const axiosConfig = {};
-    if (requestObject.headers !== undefined) {
-        axiosConfig.headers = requestObject.headers;
-    }
-    const contentTypeHeaderKeyName = axiosConfig.headers &&
-        Object.keys(axiosConfig.headers).find((headerName) => headerName.toLowerCase() === 'content-type');
-    const contentType = contentTypeHeaderKeyName &&
-        axiosConfig.headers?.[contentTypeHeaderKeyName];
-    if (contentType === 'application/x-www-form-urlencoded' && requestObject.formData === undefined) {
-        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?.includes('multipart/form-data')) {
-        if (requestObject.formData !== undefined && (0, request_helpers_1.isFormDataInstance)(requestObject.formData)) {
-            axiosConfig.data = requestObject.formData;
-        }
-        else {
-            const allData = {
-                ...requestObject.body,
-                ...requestObject.formData,
-            };
-            axiosConfig.data = (0, request_helpers_1.createFormDataObject)(allData);
-        }
-        delete axiosConfig.headers?.[contentTypeHeaderKeyName];
-        const headers = axiosConfig.data.getHeaders();
-        axiosConfig.headers = Object.assign(axiosConfig.headers || {}, headers);
-        await (0, request_helpers_1.generateContentLengthHeader)(axiosConfig);
-    }
-    else {
-        if (requestObject.form !== undefined && requestObject.body === undefined) {
-            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 = (0, request_helpers_1.searchForHeader)(axiosConfig, '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) {
-            if (axiosConfig.headers !== undefined) {
-                const headers = Object.keys(axiosConfig.headers);
-                headers.forEach((header) => {
-                    if (header.toLowerCase() === 'content-type') {
-                        delete axiosConfig.headers?.[header];
-                    }
-                });
-            }
-            if ((0, request_helpers_1.isFormDataInstance)(requestObject.formData)) {
-                axiosConfig.data = requestObject.formData;
-            }
-            else {
-                axiosConfig.data = (0, request_helpers_1.createFormDataObject)(requestObject.formData);
-            }
-            const headers = axiosConfig.data.getHeaders();
-            axiosConfig.headers = Object.assign(axiosConfig.headers || {}, headers);
-            await (0, request_helpers_1.generateContentLengthHeader)(axiosConfig);
-        }
-        else if (requestObject.body !== undefined) {
-            if (requestObject.form !== undefined && requestObject.body) {
-                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;
-    }
-    function hasArrayFormatOptions(arg) {
-        if (typeof arg.qsStringifyOptions === 'object' &&
-            arg.qsStringifyOptions !== null &&
-            !Array.isArray(arg.qsStringifyOptions) &&
-            'arrayFormat' in arg.qsStringifyOptions) {
-            return true;
-        }
-        return false;
-    }
-    if (requestObject.useQuerystring === true ||
-        (hasArrayFormatOptions(requestObject) &&
-            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' });
-        };
-    }
-    if (hasArrayFormatOptions(requestObject) &&
-        requestObject.qsStringifyOptions.arrayFormat === 'brackets') {
-        axiosConfig.paramsSerializer = (params) => {
-            return (0, qs_1.stringify)(params, { arrayFormat: 'brackets' });
-        };
-    }
-    if (requestObject.auth !== undefined) {
-        if (requestObject.auth.bearer !== undefined) {
-            axiosConfig.headers = Object.assign(axiosConfig.headers || {}, {
-                Authorization: `Bearer ${requestObject.auth.bearer}`,
-            });
-        }
-        else {
-            const authObj = requestObject.auth;
-            axiosConfig.auth = {
-                username: (authObj.user || authObj.username),
-                password: (authObj.password || authObj.pass),
-            };
-        }
-    }
-    if (requestObject.json === true) {
-        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) {
-        axiosConfig.transformResponse = (res) => res;
-    }
-    const { method } = requestObject;
-    if ((requestObject.followRedirect !== false &&
-        (!method || method === 'GET' || method === 'HEAD')) ||
-        requestObject.followAllRedirects) {
-        axiosConfig.maxRedirects = requestObject.maxRedirects;
-    }
-    else {
-        axiosConfig.maxRedirects = 0;
-    }
-    const host = (0, request_helpers_1.getHostFromRequestObject)(requestObject);
-    const agentOptions = { ...requestObject.agentOptions };
-    if (host) {
-        agentOptions.servername = host;
-    }
-    if (requestObject.rejectUnauthorized === false) {
-        agentOptions.rejectUnauthorized = false;
-        agentOptions.secureOptions = crypto_1.default.constants.SSL_OP_LEGACY_SERVER_CONNECT;
-    }
-    if (requestObject.timeout !== undefined) {
-        axiosConfig.timeout = requestObject.timeout;
-    }
-    const secureLookup = ssrfBridge?.createSecureLookup();
-    (0, request_helpers_1.setAxiosAgents)(axiosConfig, agentOptions, requestObject.proxy, secureLookup);
-    axiosConfig.beforeRedirect = (0, request_helpers_1.getBeforeRedirectFn)(agentOptions, axiosConfig, requestObject.proxy, requestObject.sendCredentialsOnCrossOriginRedirect ?? true, requestObject.allowedDomains, ssrfBridge);
-    if (requestObject.useStream) {
-        axiosConfig.responseType = 'stream';
-    }
-    else if (requestObject.encoding === null) {
-        axiosConfig.responseType = 'arraybuffer';
-    }
-    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')) {
-        axiosConfig.headers = Object.assign(axiosConfig.headers || {}, {
-            'content-type': 'application/json',
-        });
-    }
-    if (requestObject.simple === false) {
-        axiosConfig.validateStatus = () => true;
-    }
-    (0, outbound_user_agent_1.applyDefaultOutboundUserAgent)(axiosConfig);
-    return axiosConfig;
-}
-async function proxyRequestToAxios(workflow, additionalData, node, uriOrObject, options) {
-    let axiosConfig = {
-        maxBodyLength: Infinity,
-        maxContentLength: -1,
-    };
-    let configObject;
-    if (typeof uriOrObject === 'string') {
-        configObject = { uri: uriOrObject, ...options };
-    }
-    else {
-        configObject = uriOrObject ?? {};
-    }
-    const ssrfBridge = additionalData?.ssrfBridge;
-    const url = resolveLegacyRequestUrl(configObject);
-    await validateUrlSsrf(url, ssrfBridge);
-    axiosConfig = Object.assign(axiosConfig, await parseRequestObject(configObject, ssrfBridge));
-    (0, axios_utils_1.throwIfDomainNotAllowed)(axiosConfig, configObject.allowedDomains);
-    try {
-        const response = await invokeAxios(axiosConfig, configObject.auth);
-        let body = response.data;
-        if (body instanceof http_1.IncomingMessage && axiosConfig.responseType === 'stream') {
-            (0, parse_incoming_message_1.parseIncomingMessage)(body);
-        }
-        else if (body === '') {
-            body = axiosConfig.responseType === 'arraybuffer' ? Buffer.alloc(0) : undefined;
-        }
-        await additionalData?.hooks?.runHook('nodeFetchedData', [workflow?.id, node]);
-        return configObject.resolveWithFullResponse
-            ? {
-                body,
-                headers: { ...response.headers },
-                statusCode: response.status,
-                statusMessage: response.statusText,
-                request: response.request,
-            }
-            : body;
-    }
-    catch (error) {
-        const { config, response } = error;
-        if (error.isAxiosError) {
-            error.config = error.request = undefined;
-            error.options = (0, pick_1.default)(config ?? {}, ['url', 'method', 'data', 'headers']);
-            if (response) {
-                di_1.Container.get(backend_common_1.Logger).debug('Request proxied to Axios failed', { status: response.status });
-                let responseData = response.data;
-                if (Buffer.isBuffer(responseData) || responseData instanceof stream_1.Readable) {
-                    responseData = await (0, binary_helper_functions_1.binaryToString)(responseData);
-                }
-                if (configObject.simple === false) {
-                    if (configObject.resolveWithFullResponse) {
-                        return {
-                            body: responseData,
-                            headers: response.headers,
-                            statusCode: response.status,
-                            statusMessage: response.statusText,
-                        };
-                    }
-                    else {
-                        return responseData;
-                    }
-                }
-                error.message = `${response.status} - ${JSON.stringify(responseData)}`;
-                throw Object.assign(error, {
-                    statusCode: response.status,
-                    status: response.status,
-                    error: responseData,
-                    response: (0, pick_1.default)(response, ['headers', 'status', 'statusText']),
-                });
-            }
-            else if ('rejectUnauthorized' in configObject && error.code?.includes('CERT')) {
-                throw new n8n_workflow_1.NodeSslError(error);
-            }
-        }
-        throw error;
-    }
-}
-function convertN8nRequestToAxios(n8nRequest, ssrfBridge) {
-    const { headers, method, timeout, auth, proxy, url } = n8nRequest;
-    const axiosRequest = {
-        headers: headers ?? {},
-        method,
-        timeout,
-        auth,
-        url,
-        maxBodyLength: Infinity,
-        maxContentLength: Infinity,
-    };
-    axiosRequest.params = n8nRequest.qs;
-    if (n8nRequest.abortSignal) {
-        axiosRequest.signal = n8nRequest.abortSignal;
-    }
-    if (n8nRequest.baseURL !== undefined) {
-        axiosRequest.baseURL = n8nRequest.baseURL;
-    }
-    if (n8nRequest.disableFollowRedirect === true) {
-        axiosRequest.maxRedirects = 0;
-    }
-    if (n8nRequest.encoding !== undefined) {
-        axiosRequest.responseType = n8nRequest.encoding;
-    }
-    const host = (0, request_helpers_1.getHostFromRequestObject)(n8nRequest);
-    const agentOptions = { ...n8nRequest.agentOptions };
-    if (host) {
-        agentOptions.servername = host;
-    }
-    if (n8nRequest.skipSslCertificateValidation === true) {
-        agentOptions.rejectUnauthorized = false;
-    }
-    const secureLookup = ssrfBridge?.createSecureLookup();
-    (0, request_helpers_1.setAxiosAgents)(axiosRequest, agentOptions, proxy, secureLookup);
-    axiosRequest.beforeRedirect = (0, request_helpers_1.getBeforeRedirectFn)(agentOptions, axiosRequest, n8nRequest.proxy, n8nRequest.sendCredentialsOnCrossOriginRedirect ?? true, n8nRequest.allowedDomains, ssrfBridge);
-    if (n8nRequest.arrayFormat !== undefined) {
-        axiosRequest.paramsSerializer = (params) => {
-            return (0, qs_1.stringify)(params, { arrayFormat: n8nRequest.arrayFormat });
-        };
-    }
-    const { body } = n8nRequest;
-    if (body) {
-        const existingContentTypeHeaderKey = (0, request_helpers_1.searchForHeader)(axiosRequest, 'content-type');
-        if (existingContentTypeHeaderKey === undefined) {
-            axiosRequest.headers = axiosRequest.headers || {};
-            if ((0, request_helpers_1.isFormDataInstance)(body)) {
-                axiosRequest.headers = {
-                    ...axiosRequest.headers,
-                    ...body.getHeaders(),
-                };
-            }
-            else if (body instanceof URLSearchParams) {
-                axiosRequest.headers['Content-Type'] = 'application/x-www-form-urlencoded';
-            }
-        }
-        else if (axiosRequest.headers?.[existingContentTypeHeaderKey] === 'application/x-www-form-urlencoded') {
-            axiosRequest.data = new URLSearchParams(n8nRequest.body);
-        }
-        if (typeof body === 'string' || (typeof body === 'object' && !(0, n8n_workflow_1.isObjectEmpty)(body))) {
-            axiosRequest.data = body;
-        }
-    }
-    if (n8nRequest.json) {
-        const key = (0, request_helpers_1.searchForHeader)(axiosRequest, 'accept');
-        if (!key) {
-            axiosRequest.headers = {
-                ...axiosRequest.headers,
-                Accept: 'application/json',
-            };
-        }
-    }
-    (0, outbound_user_agent_1.applyDefaultOutboundUserAgent)(axiosRequest);
-    if (n8nRequest.ignoreHttpStatusErrors) {
-        const ignoreHttpStatusErrors = n8nRequest.ignoreHttpStatusErrors;
-        if ((0, request_helpers_1.isIgnoreStatusErrorConfig)(ignoreHttpStatusErrors)) {
-            axiosRequest.validateStatus = (status) => {
-                return !ignoreHttpStatusErrors.except.includes(status);
-            };
-        }
-        else {
-            axiosRequest.validateStatus = () => true;
-        }
-    }
-    return axiosRequest;
-}
-async function validateUrlSsrf(url, ssrfBridge) {
-    if (!ssrfBridge || !url)
-        return;
-    const parsed = (0, request_helpers_1.tryParseUrl)(url);
-    if (!parsed)
-        return;
-    const result = await ssrfBridge.validateUrl(parsed);
-    if (!result.ok) {
-        throw result.error;
-    }
-}
-function resolveLegacyRequestUrl(requestObject) {
-    const rawUrl = requestObject.uri?.toString() ?? requestObject.url?.toString();
-    const baseURL = requestObject.baseURL?.toString();
-    return (0, request_helpers_1.buildTargetUrl)(rawUrl, baseURL) ?? rawUrl;
-}
-const NoBodyHttpMethods = ['GET', 'HEAD', 'OPTIONS'];
-const removeEmptyBody = (requestOptions) => {
-    const method = requestOptions.method || 'GET';
-    if (NoBodyHttpMethods.includes(method) && (0, isEmpty_1.default)(requestOptions.body)) {
-        delete requestOptions.body;
-    }
-};
-exports.removeEmptyBody = removeEmptyBody;
-async function httpRequest(requestOptions, ssrfBridge) {
-    (0, exports.removeEmptyBody)(requestOptions);
-    const url = (0, request_helpers_1.buildTargetUrl)(requestOptions.url, requestOptions.baseURL) ?? requestOptions.url;
-    await validateUrlSsrf(url, ssrfBridge);
-    const axiosRequest = convertN8nRequestToAxios(requestOptions, ssrfBridge);
-    if (axiosRequest.data === undefined ||
-        (axiosRequest.method !== undefined && axiosRequest.method.toUpperCase() === 'GET')) {
-        delete axiosRequest.data;
-    }
-    (0, axios_utils_1.throwIfDomainNotAllowed)(axiosRequest, requestOptions.allowedDomains);
-    const result = await invokeAxios(axiosRequest, requestOptions.auth);
-    if (requestOptions.returnFullResponse) {
-        return {
-            body: result.data,
-            headers: result.headers,
-            statusCode: result.status,
-            statusMessage: result.statusText,
-        };
-    }
-    return result.data;
-}
-function applyPaginationRequestData(requestData, paginationRequestData) {
-    const preparedPaginationData = {
-        ...paginationRequestData,
-        uri: paginationRequestData.url,
-    };
-    if ('formData' in requestData) {
-        preparedPaginationData.formData = paginationRequestData.body;
-        delete preparedPaginationData.body;
-    }
-    else if ('form' in requestData) {
-        preparedPaginationData.form = paginationRequestData.body;
-        delete preparedPaginationData.body;
-    }
-    return (0, merge_1.default)({}, requestData, preparedPaginationData);
-}
-function createOAuth2Client(credentials) {
-    const scopes = credentials.scope
-        ?.split(' ')
-        .map((s) => s.trim())
-        .filter(Boolean);
-    return new client_oauth2_1.ClientOAuth2({
-        clientId: credentials.clientId,
-        clientSecret: credentials.clientSecret,
-        accessTokenUri: credentials.accessTokenUrl,
-        scopes: scopes?.length ? scopes : undefined,
-        ignoreSSLIssues: credentials.ignoreSSLIssues,
-        authentication: credentials.authentication ?? 'header',
-        ...(credentials.additionalBodyProperties && {
-            additionalBodyProperties: (0, n8n_workflow_1.jsonParse)(credentials.additionalBodyProperties, {
-                fallbackValue: {},
-            }),
-        }),
-    });
-}
-function buildSigningToken(client, tokenData, oAuth2Options) {
-    const accessToken = (0, get_1.default)(tokenData, oAuth2Options?.property) || tokenData.accessToken;
-    const refreshToken = tokenData.refreshToken;
-    return client.createToken({
-        ...tokenData,
-        ...(accessToken ? { access_token: accessToken } : {}),
-        ...(refreshToken ? { refresh_token: refreshToken } : {}),
-    }, oAuth2Options?.tokenType || tokenData.tokenType);
-}
-async function decryptOAuth2TokenDataIfConfigured(additionalData, tokenData, jweEnabled) {
-    if (!jweEnabled)
-        return tokenData;
-    const proxy = additionalData['oauth-jwe']?.oauthJweProxyProvider;
-    if (!proxy || !tokenData)
-        return tokenData;
-    return await proxy.decryptOAuth2TokenData(tokenData);
-}
-async function refreshOrFetchToken(ctx) {
-    const { credentials, token, credentialsType, node, additionalData, oAuth2Options, logger, helpers, } = ctx;
-    const tokenRefreshOptions = {};
-    if (oAuth2Options?.includeCredentialsOnRefreshOnBody) {
-        const body = {
-            client_id: credentials.clientId,
-            ...(credentials.grantType === 'authorizationCode' && {
-                client_secret: credentials.clientSecret,
-            }),
-        };
-        tokenRefreshOptions.body = body;
-        tokenRefreshOptions.headers = { Authorization: '' };
-    }
-    logger.debug(`OAuth2 token for "${credentialsType}" used by node "${node.name}" expired. Revalidating.`);
-    let newToken;
-    if (credentials.grantType === 'clientCredentials') {
-        newToken = await token.client.credentials.getToken();
-    }
-    else {
-        newToken = await token.refresh(tokenRefreshOptions);
-    }
-    logger.debug(`OAuth2 token for "${credentialsType}" used by node "${node.name}" has been renewed.`);
-    const refreshedTokenData = await decryptOAuth2TokenDataIfConfigured(additionalData, newToken.data, credentials.jweEnabled === true);
-    credentials.oauthTokenData = refreshedTokenData;
-    const preAuthData = await additionalData.credentialsHelper.runPreAuthentication({ helpers }, credentials, credentialsType);
-    let signingToken = newToken;
-    if (preAuthData) {
-        Object.assign(credentials, preAuthData);
-        signingToken = buildSigningToken(token.client, credentials.oauthTokenData, oAuth2Options);
-    }
-    if (!node.credentials?.[credentialsType]) {
-        throw new n8n_workflow_1.ApplicationError('Node does not have credential type', {
-            extra: { nodeName: node.name, credentialType: credentialsType },
-        });
-    }
-    const nodeCredentials = node.credentials[credentialsType];
-    await additionalData.credentialsHelper.updateCredentialsOauthTokenData(nodeCredentials, credentialsType, credentials, additionalData);
-    return signingToken;
-}
-function resolveTokenExpiredStatusCode(oAuth2Options, credentials) {
-    return credentials?.tokenExpiredStatusCode ?? oAuth2Options?.tokenExpiredStatusCode ?? 401;
-}
-async function requestOAuth2(credentialsType, requestOptions, node, additionalData, oAuth2Options, isN8nRequest = false) {
-    (0, exports.removeEmptyBody)(requestOptions);
-    const credentials = (await this.getCredentials(credentialsType));
-    if (credentials.grantType === 'authorizationCode' && credentials.oauthTokenData === undefined) {
-        throw new n8n_workflow_1.ApplicationError('OAuth credentials not connected');
-    }
-    const oAuthClient = createOAuth2Client(credentials);
-    let oauthTokenData = credentials.oauthTokenData;
-    if (credentials.grantType === 'clientCredentials' &&
-        (oauthTokenData === undefined ||
-            Object.keys(oauthTokenData).length === 0 ||
-            oauthTokenData.access_token === '')) {
-        let tokenResult;
-        try {
-            tokenResult = await oAuthClient.credentials.getToken();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new n8n_workflow_1.ApplicationError(`Failed to acquire OAuth2 access token: ${message}`, {
-                cause: error,
-            });
-        }
-        const { data } = tokenResult;
-        if (!node.credentials?.[credentialsType]) {
-            throw new n8n_workflow_1.ApplicationError('Node does not have credential type', {
-                extra: { nodeName: node.name },
-                tags: { credentialType: credentialsType },
-            });
-        }
-        const nodeCredentials = node.credentials[credentialsType];
-        const initialTokenData = (await decryptOAuth2TokenDataIfConfigured(additionalData, data, credentials.jweEnabled === true));
-        credentials.oauthTokenData = initialTokenData;
-        await additionalData.credentialsHelper.updateCredentialsOauthTokenData(nodeCredentials, credentialsType, credentials, additionalData);
-        oauthTokenData = initialTokenData;
-    }
-    const preAuthData = await additionalData.credentialsHelper.runPreAuthentication({ helpers: this.helpers }, credentials, credentialsType);
-    if (preAuthData) {
-        Object.assign(credentials, preAuthData);
-        oauthTokenData = credentials.oauthTokenData;
-    }
-    const token = buildSigningToken(oAuthClient, oauthTokenData, oAuth2Options);
-    requestOptions.rejectUnauthorized = !credentials.ignoreSSLIssues;
-    const newRequestOptions = token.sign(requestOptions);
-    const newRequestHeaders = (newRequestOptions.headers = newRequestOptions.headers ?? {});
-    if (oAuth2Options?.keepBearer === false && typeof newRequestHeaders.Authorization === 'string') {
-        newRequestHeaders.Authorization = newRequestHeaders.Authorization.split(' ')[1];
-    }
-    if (oAuth2Options?.keyToIncludeInAccessTokenHeader) {
-        Object.assign(newRequestHeaders, {
-            [oAuth2Options.keyToIncludeInAccessTokenHeader]: token.accessToken,
-        });
-    }
-    const tokenExpiredStatusCode = resolveTokenExpiredStatusCode(oAuth2Options, credentials);
-    const shouldSkipTokenRefresh = oAuth2Options?.skipTokenRefresh === true;
-    const refreshCtx = {
-        credentials,
-        token,
-        credentialsType,
-        node,
-        additionalData,
-        oAuth2Options,
-        logger: this.logger,
-        helpers: this.helpers,
-    };
-    const retryWithNewToken = async (makeRequest) => {
-        const newToken = await refreshOrFetchToken(refreshCtx);
-        const refreshedRequestOptions = newToken.sign(requestOptions);
-        refreshedRequestOptions.headers = refreshedRequestOptions.headers ?? {};
-        if (oAuth2Options?.keyToIncludeInAccessTokenHeader) {
-            Object.assign(refreshedRequestOptions.headers, {
-                [oAuth2Options.keyToIncludeInAccessTokenHeader]: newToken.accessToken,
-            });
-        }
-        return await makeRequest(refreshedRequestOptions);
-    };
-    if (isN8nRequest) {
-        return await this.helpers.httpRequest(newRequestOptions).catch(async (error) => {
-            if (!shouldSkipTokenRefresh && error.response?.status === tokenExpiredStatusCode) {
-                return await retryWithNewToken(async (opts) => await this.helpers.httpRequest(opts));
-            }
-            throw error;
-        });
-    }
-    return await this.helpers
-        .request(newRequestOptions)
-        .then((response) => {
-        const requestOptions = newRequestOptions;
-        if (!shouldSkipTokenRefresh &&
-            requestOptions.resolveWithFullResponse === true &&
-            requestOptions.simple === false &&
-            response.statusCode === tokenExpiredStatusCode) {
-            throw response;
-        }
-        return response;
-    })
-        .catch(async (error) => {
-        if (!shouldSkipTokenRefresh && error.statusCode === tokenExpiredStatusCode) {
-            return await retryWithNewToken(async (opts) => await this.helpers.request(opts));
-        }
-        throw error;
-    });
-}
-async function requestOAuth1(credentialsType, requestOptions, isN8nRequest = false) {
-    (0, exports.removeEmptyBody)(requestOptions);
-    const credentials = await this.getCredentials(credentialsType);
-    if (credentials === undefined) {
-        throw new n8n_workflow_1.ApplicationError('No credentials were returned');
-    }
-    if (credentials.oauthTokenData === undefined) {
-        throw new n8n_workflow_1.ApplicationError('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) {
-            let algorithm;
-            switch (credentials.signatureMethod) {
-                case 'HMAC-SHA256':
-                    algorithm = 'sha256';
-                    break;
-                case 'HMAC-SHA512':
-                    algorithm = 'sha512';
-                    break;
-                default:
-                    algorithm = 'sha1';
-                    break;
-            }
-            return (0, crypto_1.createHmac)(algorithm, key).update(base).digest('base64');
-        },
-    });
-    const oauthTokenData = credentials.oauthTokenData;
-    const token = {
-        key: oauthTokenData.oauth_token,
-        secret: oauthTokenData.oauth_token_secret,
-    };
-    requestOptions.data = { ...requestOptions.qs, ...requestOptions.form };
-    if ('uri' in requestOptions && !requestOptions.url) {
-        requestOptions.url = requestOptions.uri;
-        delete requestOptions.uri;
-    }
-    requestOptions.headers = oauth.toHeader(oauth.authorize(requestOptions, token));
-    if (isN8nRequest) {
-        return await this.helpers.httpRequest(requestOptions);
-    }
-    return await this.helpers
-        .request(requestOptions)
-        .catch(async (error) => {
-        throw error;
-    });
-}
-async function refreshOAuth2Token(credentialsType, node, additionalData, oAuth2Options) {
-    const credentials = (await this.getCredentials(credentialsType));
-    if (credentials.grantType === 'authorizationCode' && credentials.oauthTokenData === undefined) {
-        throw new n8n_workflow_1.ApplicationError('OAuth credentials not connected');
-    }
-    const oAuthClient = createOAuth2Client(credentials);
-    const oauthTokenData = credentials.oauthTokenData;
-    const token = buildSigningToken(oAuthClient, oauthTokenData, oAuth2Options);
-    const newToken = await refreshOrFetchToken({
-        credentials,
-        token,
-        credentialsType,
-        node,
-        additionalData,
-        oAuth2Options,
-        logger: this.logger,
-        helpers: this.helpers,
-    });
-    return newToken.data;
-}
-async function httpRequestWithAuthentication(credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions) {
-    (0, exports.removeEmptyBody)(requestOptions);
-    if ('getExecutionCancelSignal' in this) {
-        requestOptions.abortSignal = this.getExecutionCancelSignal();
-    }
-    let credentialsDecrypted;
-    if (additionalData.evalLlmMockHandler) {
-        const evalMockResponse = await (0, eval_mock_helpers_1.callEvalMockHandler)(additionalData.evalLlmMockHandler, requestOptions, node, requestOptions.returnFullResponse);
-        if (evalMockResponse !== undefined)
-            return evalMockResponse;
-    }
-    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);
-        }
-        if (additionalCredentialOptions?.credentialsDecrypted) {
-            credentialsDecrypted = additionalCredentialOptions.credentialsDecrypted.data;
-        }
-        else {
-            credentialsDecrypted =
-                await this.getCredentials(credentialsType);
-        }
-        if (credentialsDecrypted === undefined) {
-            throw new n8n_workflow_1.NodeOperationError(node, `Node "${node.name}" does not have any credentials of type "${credentialsType}" set`, { level: 'warning' });
-        }
-        const data = await additionalData.credentialsHelper.preAuthentication({ helpers: this.helpers }, credentialsDecrypted, credentialsType, node, false);
-        if (data) {
-            Object.assign(credentialsDecrypted, data);
-        }
-        requestOptions = await additionalData.credentialsHelper.authenticate(credentialsDecrypted, credentialsType, requestOptions, workflow, node);
-        return await httpRequest(requestOptions, additionalData.ssrfBridge);
-    }
-    catch (error) {
-        if (error.response?.status === 401 &&
-            additionalData.credentialsHelper.preAuthentication !== undefined) {
-            try {
-                if (credentialsDecrypted !== undefined) {
-                    const data = await additionalData.credentialsHelper.preAuthentication({ helpers: this.helpers }, credentialsDecrypted, credentialsType, node, true);
-                    if (data) {
-                        Object.assign(credentialsDecrypted, data);
-                    }
-                    requestOptions = await additionalData.credentialsHelper.authenticate(credentialsDecrypted, credentialsType, requestOptions, workflow, node);
-                }
-                return await httpRequest(requestOptions, additionalData.ssrfBridge);
-            }
-            catch (error) {
-                throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
-            }
-        }
-        throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
-    }
-}
-async function requestWithAuthentication(credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions, itemIndex) {
-    (0, exports.removeEmptyBody)(requestOptions);
-    let credentialsDecrypted;
-    if (additionalData.evalLlmMockHandler) {
-        const evalMockResponse = await (0, eval_mock_helpers_1.callEvalMockHandler)(additionalData.evalLlmMockHandler, (0, eval_mock_helpers_1.normalizeLegacyRequest)(requestOptions), node, requestOptions.resolveWithFullResponse, 'legacy');
-        if (evalMockResponse !== undefined)
-            return evalMockResponse;
-    }
-    try {
-        const parentTypes = additionalData.credentialsHelper.getParentTypes(credentialsType);
-        if (credentialsType === 'oAuth1Api' || parentTypes.includes('oAuth1Api')) {
-            return await requestOAuth1.call(this, credentialsType, requestOptions, false);
-        }
-        if (credentialsType === 'oAuth2Api' || parentTypes.includes('oAuth2Api')) {
-            return await requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, additionalCredentialOptions?.oauth2, false);
-        }
-        if (additionalCredentialOptions?.credentialsDecrypted) {
-            credentialsDecrypted = additionalCredentialOptions.credentialsDecrypted.data;
-        }
-        else {
-            credentialsDecrypted = await this.getCredentials(credentialsType, itemIndex);
-        }
-        if (credentialsDecrypted === undefined) {
-            throw new n8n_workflow_1.NodeOperationError(node, `Node "${node.name}" does not have any credentials of type "${credentialsType}" set`, { level: 'warning' });
-        }
-        const data = await additionalData.credentialsHelper.preAuthentication({ helpers: this.helpers }, credentialsDecrypted, credentialsType, node, false);
-        if (data) {
-            Object.assign(credentialsDecrypted, data);
-        }
-        requestOptions = (await additionalData.credentialsHelper.authenticate(credentialsDecrypted, credentialsType, requestOptions, workflow, node));
-        return await proxyRequestToAxios(workflow, additionalData, node, requestOptions);
-    }
-    catch (error) {
-        try {
-            if (credentialsDecrypted !== undefined) {
-                const data = await additionalData.credentialsHelper.preAuthentication({ helpers: this.helpers }, credentialsDecrypted, credentialsType, node, true);
-                if (data) {
-                    Object.assign(credentialsDecrypted, data);
-                    requestOptions = (await additionalData.credentialsHelper.authenticate(credentialsDecrypted, credentialsType, requestOptions, workflow, node));
-                    return await proxyRequestToAxios(workflow, additionalData, node, requestOptions);
-                }
-            }
-            throw error;
-        }
-        catch (error) {
-            if (error instanceof n8n_workflow_1.ExecutionBaseError)
-                throw error;
-            throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
-        }
-    }
-}
-const getRequestHelperFunctions = (workflow, node, additionalData, runExecutionData = null, connectionInputData = []) => {
-    const getResolvedValue = (parameterValue, itemIndex, runIndex, executeData, additionalKeys, returnObjectAsString = false) => {
-        const mode = 'internal';
-        if (typeof parameterValue === 'object' ||
-            (typeof parameterValue === 'string' && parameterValue.charAt(0) === '=')) {
-            return workflow.expression.getParameterValue(parameterValue, runExecutionData, runIndex, itemIndex, node.name, connectionInputData, mode, additionalKeys ?? {}, executeData, returnObjectAsString);
-        }
-        return parameterValue;
-    };
-    async function requestWithAuthenticationPaginated(requestOptions, itemIndex, paginationOptions, credentialsType, additionalCredentialOptions) {
-        const responseData = [];
-        if (!requestOptions.qs) {
-            requestOptions.qs = {};
-        }
-        requestOptions.resolveWithFullResponse = true;
-        requestOptions.simple = false;
-        let tempResponseData;
-        let makeAdditionalRequest;
-        let paginateRequestData;
-        const runIndex = 0;
-        const additionalKeys = {
-            $request: requestOptions,
-            $response: {},
-            $version: node.typeVersion,
-            $pageCount: 0,
-        };
-        const executeData = {
-            data: {},
-            node,
-            source: null,
-        };
-        const hashData = {
-            identicalCount: 0,
-            previousLength: 0,
-            previousHash: '',
-        };
-        do {
-            paginateRequestData = getResolvedValue(paginationOptions.request, itemIndex, runIndex, executeData, additionalKeys, false);
-            const tempRequestOptions = applyPaginationRequestData(requestOptions, paginateRequestData);
-            if (!(0, request_helpers_1.tryParseUrl)(tempRequestOptions.uri)) {
-                throw new n8n_workflow_1.NodeOperationError(node, `'${paginateRequestData.url}' is not a valid URL.`, {
-                    itemIndex,
-                    runIndex,
-                    type: 'invalid_url',
-                });
-            }
-            if (credentialsType) {
-                tempResponseData = await this.helpers.requestWithAuthentication.call(this, credentialsType, tempRequestOptions, additionalCredentialOptions);
-            }
-            else {
-                tempResponseData = await this.helpers.request(tempRequestOptions);
-            }
-            const newResponse = Object.assign({
-                body: {},
-                headers: {},
-                statusCode: 0,
-            }, (0, pick_1.default)(tempResponseData, ['body', 'headers', 'statusCode']));
-            let contentBody;
-            if (newResponse.body instanceof stream_1.Readable && paginationOptions.binaryResult !== true) {
-                contentBody = await (0, binary_helper_functions_1.binaryToString)(newResponse.body);
-                const responseContentType = newResponse.headers['content-type']?.toString() ?? '';
-                if (responseContentType.includes('application/json')) {
-                    newResponse.body = (0, n8n_workflow_1.jsonParse)(contentBody, { fallbackValue: {} });
-                }
-                else {
-                    newResponse.body = contentBody;
-                }
-                tempResponseData.__bodyResolved = true;
-                tempResponseData.body = newResponse.body;
-            }
-            else {
-                contentBody = newResponse.body;
-            }
-            if (paginationOptions.binaryResult !== true || tempResponseData.headers.etag) {
-                let contentLength = 0;
-                if ('content-length' in tempResponseData.headers) {
-                    contentLength = parseInt(tempResponseData.headers['content-length']) || 0;
-                }
-                if (hashData.previousLength === contentLength) {
-                    let hash;
-                    if (tempResponseData.headers.etag) {
-                        hash = tempResponseData.headers.etag;
-                    }
-                    else {
-                        if (typeof contentBody !== 'string') {
-                            contentBody = JSON.stringify(contentBody);
-                        }
-                        hash = crypto_1.default.createHash('md5').update(contentBody).digest('base64');
-                    }
-                    if (hashData.previousHash === hash) {
-                        hashData.identicalCount += 1;
-                        if (hashData.identicalCount > 2) {
-                            throw new n8n_workflow_1.NodeOperationError(node, 'The returned response was identical 5x, so requests got stopped', {
-                                itemIndex,
-                                description: 'Check if "Pagination Completed When" has been configured correctly.',
-                            });
-                        }
-                    }
-                    else {
-                        hashData.identicalCount = 0;
-                    }
-                    hashData.previousHash = hash;
-                }
-                else {
-                    hashData.identicalCount = 0;
-                }
-                hashData.previousLength = contentLength;
-            }
-            responseData.push(tempResponseData);
-            additionalKeys.$response = newResponse;
-            additionalKeys.$pageCount = (additionalKeys.$pageCount ?? 0) + 1;
-            const maxRequests = getResolvedValue(paginationOptions.maxRequests, itemIndex, runIndex, executeData, additionalKeys, false);
-            if (maxRequests && additionalKeys.$pageCount >= maxRequests) {
-                break;
-            }
-            makeAdditionalRequest = getResolvedValue(paginationOptions.continue, itemIndex, runIndex, executeData, additionalKeys, false);
-            if (makeAdditionalRequest) {
-                if (paginationOptions.requestInterval) {
-                    const requestInterval = getResolvedValue(paginationOptions.requestInterval, itemIndex, runIndex, executeData, additionalKeys, false);
-                    await (0, n8n_workflow_1.sleep)(requestInterval);
-                }
-                if (tempResponseData.statusCode < 200 || tempResponseData.statusCode >= 300) {
-                    let data = tempResponseData.body;
-                    if (data instanceof stream_1.Readable && paginationOptions.binaryResult !== true) {
-                        data = await (0, binary_helper_functions_1.binaryToString)(data);
-                    }
-                    else if (typeof data === 'object') {
-                        data = JSON.stringify(data);
-                    }
-                    throw Object.assign(new Error(`${tempResponseData.statusCode} - "${data?.toString()}"`), {
-                        statusCode: tempResponseData.statusCode,
-                        error: data,
-                        isAxiosError: true,
-                        response: {
-                            headers: tempResponseData.headers,
-                            status: tempResponseData.statusCode,
-                            statusText: tempResponseData.statusMessage,
-                        },
-                    });
-                }
-            }
-        } while (makeAdditionalRequest);
-        return responseData;
-    }
-    const evalLlmMock = additionalData.evalLlmMockHandler;
-    return {
-        httpRequest: async (requestOptions) => {
-            if (evalLlmMock) {
-                const evalMockResponse = await (0, eval_mock_helpers_1.callEvalMockHandler)(evalLlmMock, requestOptions, node, requestOptions.returnFullResponse);
-                if (evalMockResponse !== undefined)
-                    return evalMockResponse;
-            }
-            if (additionalData.otel?.injectTraceHeaders) {
-                requestOptions.headers ??= {};
-                additionalData.otel.injectTraceHeaders(additionalData.executionId, node.name, requestOptions.headers);
-            }
-            return await httpRequest(requestOptions, additionalData.ssrfBridge);
-        },
-        requestWithAuthenticationPaginated,
-        async httpRequestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions) {
-            return await httpRequestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions);
-        },
-        async refreshOAuth2Token(credentialsType, oAuth2Options) {
-            return await refreshOAuth2Token.call(this, credentialsType, node, additionalData, oAuth2Options);
-        },
-        request: async (uriOrObject, options) => {
-            if (evalLlmMock) {
-                const wantsFull = typeof uriOrObject !== 'string' && uriOrObject.resolveWithFullResponse;
-                const evalMockResponse = await (0, eval_mock_helpers_1.callEvalMockHandler)(evalLlmMock, (0, eval_mock_helpers_1.normalizeLegacyRequest)(uriOrObject, options), node, wantsFull, 'legacy');
-                if (evalMockResponse !== undefined)
-                    return evalMockResponse;
-            }
-            if (additionalData.otel?.injectTraceHeaders) {
-                const target = typeof uriOrObject === 'string' ? (options ??= {}) : uriOrObject;
-                target.headers ??= {};
-                additionalData.otel.injectTraceHeaders(additionalData.executionId, node.name, target.headers);
-            }
-            return await proxyRequestToAxios(workflow, additionalData, node, uriOrObject, options);
-        },
-        async requestWithAuthentication(credentialsType, requestOptions, additionalCredentialOptions, itemIndex) {
-            return await requestWithAuthentication.call(this, credentialsType, requestOptions, workflow, node, additionalData, additionalCredentialOptions, itemIndex);
-        },
-        async requestOAuth1(credentialsType, requestOptions) {
-            if (evalLlmMock) {
-                const evalMockResponse = await (0, eval_mock_helpers_1.callEvalMockHandler)(evalLlmMock, (0, eval_mock_helpers_1.normalizeLegacyRequest)(requestOptions), node, requestOptions.resolveWithFullResponse, 'legacy');
-                if (evalMockResponse !== undefined)
-                    return evalMockResponse;
-            }
-            return await requestOAuth1.call(this, credentialsType, requestOptions);
-        },
-        async requestOAuth2(credentialsType, requestOptions, oAuth2Options) {
-            if (evalLlmMock) {
-                const evalMockResponse = await (0, eval_mock_helpers_1.callEvalMockHandler)(evalLlmMock, (0, eval_mock_helpers_1.normalizeLegacyRequest)(requestOptions), node, requestOptions.resolveWithFullResponse, 'legacy');
-                if (evalMockResponse !== undefined)
-                    return evalMockResponse;
-            }
-            return await requestOAuth2.call(this, credentialsType, requestOptions, node, additionalData, oAuth2Options);
-        },
-    };
-};
-exports.getRequestHelperFunctions = getRequestHelperFunctions;
+__exportStar(require("./request-helpers"), exports);
 //# sourceMappingURL=request-helper-functions.js.map