n8n-nodes-better-http-request 0.1.0

package/dist/nodes/BetterHttpRequest/BetterHttpRequest.node.js

@@ -0,0 +1,1032 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterHttpRequest = void 0;
+const set_1 = __importDefault(require("lodash/set"));
+const n8n_workflow_1 = require("n8n-workflow");
+const Description_1 = require("./Description");
+const helpers_1 = require("./helpers");
+function toText(data) {
+    if (typeof data === 'object' && data !== null) {
+        return JSON.stringify(data);
+    }
+    return data;
+}
+function parseJsonParameter(node, jsonString, fieldName, itemIndex) {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (e) {
+        const error = (0, n8n_workflow_1.ensureError)(e);
+        throw new n8n_workflow_1.NodeOperationError(node, `The value in the "${fieldName}" field is not valid JSON`, {
+            itemIndex,
+            description: error.message,
+        });
+    }
+}
+function isDomainAllowedLocal(url, opts) {
+    try {
+        const parsedUrl = new URL(url);
+        const hostname = parsedUrl.hostname.toLowerCase();
+        const allowedDomains = opts.allowedDomains
+            .split(',')
+            .map((d) => d.trim().toLowerCase())
+            .filter((d) => d.length > 0);
+        return allowedDomains.some((domain) => hostname === domain || hostname.endsWith('.' + domain));
+    }
+    catch {
+        return false;
+    }
+}
+class BetterHttpRequest {
+    constructor() {
+        this.description = {
+            displayName: 'Better HTTP Request',
+            name: 'betterHttpRequest',
+            icon: 'file:betterhttp.svg',
+            group: ['output'],
+            subtitle: '={{$parameter["method"] + ": " + $parameter["url"]}}',
+            version: 1,
+            defaults: {
+                name: 'Better HTTP Request',
+                color: '#0004F5',
+            },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'httpSslAuth',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            provideSslCertificates: [true],
+                        },
+                    },
+                },
+            ],
+            description: 'Enhanced HTTP Request with retry-only-failed-items support',
+            properties: Description_1.mainProperties,
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3;
+        const items = this.getInputData();
+        const nodeVersion = this.getNode().typeVersion;
+        const fullResponseProperties = ['body', 'headers', 'statusCode', 'statusMessage'];
+        let authentication;
+        try {
+            authentication = this.getNodeParameter('authentication', 0);
+        }
+        catch { }
+        let httpBasicAuth;
+        let httpBearerAuth;
+        let httpDigestAuth;
+        let httpHeaderAuth;
+        let httpQueryAuth;
+        let httpCustomAuth;
+        let oAuth1Api;
+        let oAuth2Api;
+        let sslCertificates;
+        let nodeCredentialType;
+        let genericCredentialType;
+        let requestOptions = {
+            uri: '',
+        };
+        let returnItems = [];
+        const errorItems = {};
+        const requestPromises = [];
+        let fullResponse = false;
+        let autoDetectResponseFormat = false;
+        let responseFileName;
+        const pagination = this.getNodeParameter('options.pagination.pagination', 0, null, {
+            rawExpressions: true,
+        });
+        const requests = [];
+        const updadeQueryParameter = (0, helpers_1.updadeQueryParameterConfig)(nodeVersion);
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                if (authentication === 'genericCredentialType') {
+                    genericCredentialType = this.getNodeParameter('genericAuthType', 0);
+                    if (genericCredentialType === 'httpBasicAuth') {
+                        httpBasicAuth = await this.getCredentials('httpBasicAuth', itemIndex);
+                    }
+                    else if (genericCredentialType === 'httpBearerAuth') {
+                        httpBearerAuth = await this.getCredentials('httpBearerAuth', itemIndex);
+                    }
+                    else if (genericCredentialType === 'httpDigestAuth') {
+                        httpDigestAuth = await this.getCredentials('httpDigestAuth', itemIndex);
+                    }
+                    else if (genericCredentialType === 'httpHeaderAuth') {
+                        httpHeaderAuth = await this.getCredentials('httpHeaderAuth', itemIndex);
+                    }
+                    else if (genericCredentialType === 'httpQueryAuth') {
+                        httpQueryAuth = await this.getCredentials('httpQueryAuth', itemIndex);
+                    }
+                    else if (genericCredentialType === 'httpCustomAuth') {
+                        httpCustomAuth = await this.getCredentials('httpCustomAuth', itemIndex);
+                    }
+                    else if (genericCredentialType === 'oAuth1Api') {
+                        oAuth1Api = await this.getCredentials('oAuth1Api', itemIndex);
+                    }
+                    else if (genericCredentialType === 'oAuth2Api') {
+                        oAuth2Api = await this.getCredentials('oAuth2Api', itemIndex);
+                    }
+                }
+                else if (authentication === 'predefinedCredentialType') {
+                    nodeCredentialType = this.getNodeParameter('nodeCredentialType', itemIndex);
+                }
+                const url = this.getNodeParameter('url', itemIndex);
+                if (typeof url !== 'string') {
+                    const actualType = url === null ? 'null' : typeof url;
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `URL parameter must be a string, got ${actualType}`);
+                }
+                if (!url.startsWith('http://') && !url.startsWith('https://')) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid URL: ${url}. URL must start with "http" or "https".`);
+                }
+                const checkDomainRestrictions = async (credentialData, requestUrl, credentialType) => {
+                    if (credentialData.allowedHttpRequestDomains === 'domains') {
+                        const allowedDomains = credentialData.allowedDomains;
+                        if (!allowedDomains || allowedDomains.trim() === '') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No allowed domains specified. Configure allowed domains or change restriction setting.');
+                        }
+                        if (!isDomainAllowedLocal(requestUrl, { allowedDomains })) {
+                            const credentialInfo = credentialType ? ` (${credentialType})` : '';
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Domain not allowed: This credential${credentialInfo} is restricted from accessing ${requestUrl}. ` +
+                                `Only the following domains are allowed: ${allowedDomains}`);
+                        }
+                    }
+                    else if (credentialData.allowedHttpRequestDomains === 'none') {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This credential is configured to prevent use within an HTTP Request node');
+                    }
+                };
+                if (httpBasicAuth)
+                    await checkDomainRestrictions(httpBasicAuth, url);
+                if (httpBearerAuth)
+                    await checkDomainRestrictions(httpBearerAuth, url);
+                if (httpDigestAuth)
+                    await checkDomainRestrictions(httpDigestAuth, url);
+                if (httpHeaderAuth)
+                    await checkDomainRestrictions(httpHeaderAuth, url);
+                if (httpQueryAuth)
+                    await checkDomainRestrictions(httpQueryAuth, url);
+                if (httpCustomAuth)
+                    await checkDomainRestrictions(httpCustomAuth, url);
+                if (oAuth1Api)
+                    await checkDomainRestrictions(oAuth1Api, url);
+                if (oAuth2Api)
+                    await checkDomainRestrictions(oAuth2Api, url);
+                if (nodeCredentialType) {
+                    try {
+                        const credentialData = await this.getCredentials(nodeCredentialType, itemIndex);
+                        await checkDomainRestrictions(credentialData, url, nodeCredentialType);
+                    }
+                    catch (error) {
+                        if (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('Domain not allowed')) ||
+                            ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('configured to prevent')) ||
+                            ((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('No allowed domains specified'))) {
+                            throw error;
+                        }
+                    }
+                }
+                const provideSslCertificates = this.getNodeParameter('provideSslCertificates', itemIndex, false);
+                if (provideSslCertificates) {
+                    sslCertificates = (await this.getCredentials('httpSslAuth', itemIndex));
+                }
+                const requestMethod = this.getNodeParameter('method', itemIndex);
+                const sendQuery = this.getNodeParameter('sendQuery', itemIndex, false);
+                const queryParameters = this.getNodeParameter('queryParameters.parameters', itemIndex, []);
+                const specifyQuery = this.getNodeParameter('specifyQuery', itemIndex, 'keypair');
+                const jsonQueryParameter = this.getNodeParameter('jsonQuery', itemIndex, '');
+                const sendBody = this.getNodeParameter('sendBody', itemIndex, false);
+                const bodyContentType = this.getNodeParameter('contentType', itemIndex, '');
+                const specifyBody = this.getNodeParameter('specifyBody', itemIndex, '');
+                const bodyParameters = this.getNodeParameter('bodyParameters.parameters', itemIndex, []);
+                const jsonBodyParameter = this.getNodeParameter('jsonBody', itemIndex, '');
+                const body = this.getNodeParameter('body', itemIndex, '');
+                const sendHeaders = this.getNodeParameter('sendHeaders', itemIndex, false);
+                const headerParameters = this.getNodeParameter('headerParameters.parameters', itemIndex, []);
+                const specifyHeaders = this.getNodeParameter('specifyHeaders', itemIndex, 'keypair');
+                const jsonHeadersParameter = this.getNodeParameter('jsonHeaders', itemIndex, '');
+                const { redirect, batching, proxy, timeout, allowUnauthorizedCerts, queryParameterArrays, response, lowercaseHeaders, sendCredentialsOnCrossOriginRedirect, } = this.getNodeParameter('options', itemIndex, {});
+                responseFileName = (_d = response === null || response === void 0 ? void 0 : response.response) === null || _d === void 0 ? void 0 : _d.outputPropertyName;
+                const responseFormat = ((_e = response === null || response === void 0 ? void 0 : response.response) === null || _e === void 0 ? void 0 : _e.responseFormat) || 'autodetect';
+                fullResponse = ((_f = response === null || response === void 0 ? void 0 : response.response) === null || _f === void 0 ? void 0 : _f.fullResponse) || false;
+                autoDetectResponseFormat = responseFormat === 'autodetect';
+                const batchSize = ((_g = batching === null || batching === void 0 ? void 0 : batching.batch) === null || _g === void 0 ? void 0 : _g.batchSize) > 0 ? (_h = batching === null || batching === void 0 ? void 0 : batching.batch) === null || _h === void 0 ? void 0 : _h.batchSize : 1;
+                const batchInterval = (_j = batching === null || batching === void 0 ? void 0 : batching.batch) === null || _j === void 0 ? void 0 : _j.batchInterval;
+                if (itemIndex > 0 && batchSize >= 0 && batchInterval > 0) {
+                    if (itemIndex % batchSize === 0) {
+                        await (0, n8n_workflow_1.sleep)(batchInterval);
+                    }
+                }
+                requestOptions = {
+                    headers: {},
+                    method: requestMethod,
+                    uri: url,
+                    gzip: true,
+                    rejectUnauthorized: !allowUnauthorizedCerts || false,
+                    followRedirect: false,
+                    resolveWithFullResponse: true,
+                    sendCredentialsOnCrossOriginRedirect: sendCredentialsOnCrossOriginRedirect !== null && sendCredentialsOnCrossOriginRedirect !== void 0 ? sendCredentialsOnCrossOriginRedirect : false,
+                };
+                if (requestOptions.method !== 'GET' && nodeVersion >= 4.1) {
+                    requestOptions = { ...requestOptions, followAllRedirects: false };
+                }
+                const defaultRedirect = redirect === undefined;
+                if (((_k = redirect === null || redirect === void 0 ? void 0 : redirect.redirect) === null || _k === void 0 ? void 0 : _k.followRedirects) || defaultRedirect) {
+                    requestOptions.followRedirect = true;
+                    requestOptions.followAllRedirects = true;
+                }
+                if (((_l = redirect === null || redirect === void 0 ? void 0 : redirect.redirect) === null || _l === void 0 ? void 0 : _l.maxRedirects) || defaultRedirect) {
+                    requestOptions.maxRedirects = (_m = redirect === null || redirect === void 0 ? void 0 : redirect.redirect) === null || _m === void 0 ? void 0 : _m.maxRedirects;
+                }
+                if ((_o = response === null || response === void 0 ? void 0 : response.response) === null || _o === void 0 ? void 0 : _o.neverError) {
+                    requestOptions.simple = false;
+                }
+                if (proxy) {
+                    requestOptions.proxy = proxy;
+                }
+                if (timeout) {
+                    requestOptions.timeout = timeout;
+                }
+                else {
+                    requestOptions.timeout = 300000;
+                }
+                if (sendQuery && queryParameterArrays) {
+                    Object.assign(requestOptions, {
+                        qsStringifyOptions: { arrayFormat: queryParameterArrays },
+                    });
+                }
+                const parametersToKeyValue = async (accumulator, cur) => {
+                    if (cur.parameterType === 'formBinaryData') {
+                        if (!cur.inputDataFieldName)
+                            return accumulator;
+                        const binaryData = this.helpers.assertBinaryData(itemIndex, cur.inputDataFieldName);
+                        let uploadData;
+                        if (binaryData.id) {
+                            uploadData = await this.helpers.getBinaryStream(binaryData.id);
+                        }
+                        else {
+                            uploadData = Buffer.from(binaryData.data, n8n_workflow_1.BINARY_ENCODING);
+                        }
+                        accumulator[cur.name] = {
+                            value: uploadData,
+                            options: {
+                                filename: binaryData.fileName,
+                                contentType: binaryData.mimeType,
+                            },
+                        };
+                        return accumulator;
+                    }
+                    updadeQueryParameter(accumulator, cur.name, cur.value);
+                    return accumulator;
+                };
+                if (sendBody && bodyParameters) {
+                    if (specifyBody === 'keypair' || bodyContentType === 'multipart-form-data') {
+                        requestOptions.body = await (0, helpers_1.prepareRequestBody)(bodyParameters, bodyContentType, nodeVersion, parametersToKeyValue);
+                    }
+                    else if (specifyBody === 'json') {
+                        if (typeof jsonBodyParameter !== 'object' &&
+                            jsonBodyParameter !== null) {
+                            requestOptions.body = parseJsonParameter(this.getNode(), jsonBodyParameter, 'JSON Body', itemIndex);
+                        }
+                        else {
+                            requestOptions.body = jsonBodyParameter;
+                        }
+                    }
+                    else if (specifyBody === 'string') {
+                        requestOptions.body = Object.fromEntries(new URLSearchParams(body));
+                    }
+                }
+                if (sendBody && ['PATCH', 'POST', 'PUT', 'GET'].includes(requestMethod)) {
+                    if (bodyContentType === 'multipart-form-data') {
+                        requestOptions.formData = requestOptions.body;
+                        delete requestOptions.body;
+                    }
+                    else if (bodyContentType === 'form-urlencoded') {
+                        requestOptions.form = requestOptions.body;
+                        delete requestOptions.body;
+                    }
+                    else if (bodyContentType === 'binaryData') {
+                        const inputDataFieldName = this.getNodeParameter('inputDataFieldName', itemIndex);
+                        let uploadData;
+                        let contentLength;
+                        const itemBinaryData = this.helpers.assertBinaryData(itemIndex, inputDataFieldName);
+                        if (itemBinaryData.id) {
+                            uploadData = await this.helpers.getBinaryStream(itemBinaryData.id);
+                            const metadata = await this.helpers.getBinaryMetadata(itemBinaryData.id);
+                            contentLength = metadata.fileSize;
+                        }
+                        else {
+                            uploadData = Buffer.from(itemBinaryData.data, n8n_workflow_1.BINARY_ENCODING);
+                            contentLength = uploadData.length;
+                        }
+                        requestOptions.body = uploadData;
+                        requestOptions.headers = {
+                            ...requestOptions.headers,
+                            'content-length': contentLength,
+                            'content-type': (_p = itemBinaryData.mimeType) !== null && _p !== void 0 ? _p : 'application/octet-stream',
+                        };
+                    }
+                    else if (bodyContentType === 'raw') {
+                        requestOptions.body = body;
+                    }
+                }
+                if (sendQuery && queryParameters) {
+                    if (specifyQuery === 'keypair') {
+                        requestOptions.qs = await (0, helpers_1.reduceAsync)(queryParameters, parametersToKeyValue);
+                    }
+                    else if (specifyQuery === 'json') {
+                        requestOptions.qs = parseJsonParameter(this.getNode(), jsonQueryParameter, 'JSON Query Parameters', itemIndex);
+                    }
+                }
+                if (sendHeaders && headerParameters) {
+                    let additionalHeaders = {};
+                    if (specifyHeaders === 'keypair') {
+                        additionalHeaders = await (0, helpers_1.reduceAsync)(headerParameters.filter((header) => header.name), parametersToKeyValue);
+                    }
+                    else if (specifyHeaders === 'json') {
+                        additionalHeaders = parseJsonParameter(this.getNode(), jsonHeadersParameter, 'JSON Headers', itemIndex);
+                    }
+                    requestOptions.headers = {
+                        ...requestOptions.headers,
+                        ...(lowercaseHeaders === undefined || lowercaseHeaders
+                            ? (0, helpers_1.keysToLowercase)(additionalHeaders)
+                            : additionalHeaders),
+                    };
+                }
+                if (autoDetectResponseFormat || responseFormat === 'file') {
+                    requestOptions.encoding = null;
+                    requestOptions.json = false;
+                    requestOptions.useStream = true;
+                }
+                else if (bodyContentType === 'raw') {
+                    requestOptions.json = false;
+                    requestOptions.useStream = true;
+                }
+                else {
+                    requestOptions.json = true;
+                }
+                if (bodyContentType === 'raw') {
+                    if (requestOptions.headers === undefined) {
+                        requestOptions.headers = {};
+                    }
+                    const rawContentType = this.getNodeParameter('rawContentType', itemIndex);
+                    requestOptions.headers['content-type'] = rawContentType;
+                }
+                const authDataKeys = {};
+                (0, helpers_1.setAgentOptions)(requestOptions, sslCertificates);
+                if (requestOptions.agentOptions) {
+                    authDataKeys.agentOptions = Object.keys(requestOptions.agentOptions);
+                }
+                if (httpBasicAuth !== undefined) {
+                    requestOptions.auth = {
+                        user: httpBasicAuth.user,
+                        pass: httpBasicAuth.password,
+                    };
+                    authDataKeys.auth = ['pass'];
+                }
+                if (httpBearerAuth !== undefined) {
+                    requestOptions.headers = (_q = requestOptions.headers) !== null && _q !== void 0 ? _q : {};
+                    requestOptions.headers.Authorization = `Bearer ${String(httpBearerAuth.token)}`;
+                    authDataKeys.headers = ['Authorization'];
+                }
+                if (httpHeaderAuth !== undefined) {
+                    requestOptions.headers[httpHeaderAuth.name] =
+                        httpHeaderAuth.value;
+                    authDataKeys.headers = [httpHeaderAuth.name];
+                }
+                if (httpQueryAuth !== undefined) {
+                    if (!requestOptions.qs) {
+                        requestOptions.qs = {};
+                    }
+                    requestOptions.qs[httpQueryAuth.name] = httpQueryAuth.value;
+                    authDataKeys.qs = [httpQueryAuth.name];
+                }
+                if (httpDigestAuth !== undefined) {
+                    requestOptions.auth = {
+                        user: httpDigestAuth.user,
+                        pass: httpDigestAuth.password,
+                        sendImmediately: false,
+                    };
+                    authDataKeys.auth = ['pass'];
+                }
+                if (httpCustomAuth !== undefined) {
+                    const customAuth = (0, n8n_workflow_1.jsonParse)(httpCustomAuth.json || '{}', { errorMessage: 'Invalid Custom Auth JSON' });
+                    if (customAuth.headers) {
+                        requestOptions.headers = {
+                            ...requestOptions.headers,
+                            ...customAuth.headers,
+                        };
+                        authDataKeys.headers = Object.keys(customAuth.headers);
+                    }
+                    if (customAuth.body) {
+                        requestOptions.body = {
+                            ...requestOptions.body,
+                            ...customAuth.body,
+                        };
+                        authDataKeys.body = Object.keys(customAuth.body);
+                    }
+                    if (customAuth.qs) {
+                        requestOptions.qs = { ...requestOptions.qs, ...customAuth.qs };
+                        authDataKeys.qs = Object.keys(customAuth.qs);
+                    }
+                }
+                if (requestOptions.headers.accept === undefined) {
+                    if (responseFormat === 'json') {
+                        requestOptions.headers.accept = 'application/json,text/*;q=0.99';
+                    }
+                    else if (responseFormat === 'text') {
+                        requestOptions.headers.accept =
+                            'application/json,text/html,application/xhtml+xml,application/xml,text/*;q=0.9, */*;q=0.1';
+                    }
+                    else {
+                        requestOptions.headers.accept =
+                            'application/json,text/html,application/xhtml+xml,application/xml,text/*;q=0.9, image/*;q=0.8, */*;q=0.7';
+                    }
+                }
+                requests.push({
+                    options: requestOptions,
+                    authKeys: authDataKeys,
+                    credentialType: nodeCredentialType,
+                });
+                if (pagination && pagination.paginationMode !== 'off') {
+                    let continueExpression = '={{false}}';
+                    if (pagination.paginationCompleteWhen === 'receiveSpecificStatusCodes') {
+                        const statusCodesWhenCompleted = pagination.statusCodesWhenComplete
+                            .split(',')
+                            .map((item) => parseInt(item.trim()));
+                        continueExpression = `={{ !${JSON.stringify(statusCodesWhenCompleted)}.includes($response.statusCode) }}`;
+                    }
+                    else if (pagination.paginationCompleteWhen === 'responseIsEmpty') {
+                        continueExpression =
+                            '={{ Array.isArray($response.body) ? $response.body.length : !!$response.body }}';
+                    }
+                    else {
+                        if (!pagination.completeExpression.length ||
+                            pagination.completeExpression[0] !== '=') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid or empty Complete Expression');
+                        }
+                        const completionExpression = pagination.completeExpression
+                            .trim()
+                            .slice(3, -2);
+                        if ((_r = response === null || response === void 0 ? void 0 : response.response) === null || _r === void 0 ? void 0 : _r.neverError) {
+                            continueExpression = `={{ !(${completionExpression}) }}`;
+                        }
+                        else {
+                            continueExpression = `={{ !(${completionExpression}) || ($response.statusCode < 200 || $response.statusCode >= 300) }}`;
+                        }
+                    }
+                    const paginationData = {
+                        continue: continueExpression,
+                        request: {},
+                        requestInterval: pagination.requestInterval,
+                    };
+                    if (pagination.paginationMode ===
+                        'updateAParameterInEachRequest') {
+                        paginationData.request = {};
+                        const { parameters } = pagination.parameters;
+                        if (parameters.length === 1 &&
+                            parameters[0].name === '' &&
+                            parameters[0].value === '') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "At least one entry with 'Name' and 'Value' filled must be included in 'Parameters' to use 'Update a Parameter in Each Request' mode ");
+                        }
+                        pagination.parameters.parameters.forEach((parameter, index) => {
+                            if (!paginationData.request[parameter.type]) {
+                                paginationData.request[parameter.type] = {};
+                            }
+                            const parameterName = parameter.name;
+                            if (parameterName === '') {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Parameter name must be set for parameter [${index + 1}] in pagination settings`);
+                            }
+                            const parameterValue = parameter.value;
+                            if (parameterValue === '') {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Some value must be provided for parameter [${index + 1}] in pagination settings, omitting it will result in an infinite loop`);
+                            }
+                            paginationData.request[parameter.type][parameterName] = parameterValue;
+                        });
+                    }
+                    else if (pagination.paginationMode === 'responseContainsNextURL') {
+                        paginationData.request.url = pagination.nextURL;
+                    }
+                    if (pagination.limitPagesFetched) {
+                        paginationData.maxRequests = pagination.maxRequests;
+                    }
+                    if (responseFormat === 'file') {
+                        paginationData.binaryResult = true;
+                    }
+                    const requestPromise = this.helpers.requestWithAuthenticationPaginated
+                        .call(this, requestOptions, itemIndex, paginationData, nodeCredentialType !== null && nodeCredentialType !== void 0 ? nodeCredentialType : genericCredentialType)
+                        .catch((error) => {
+                        if (error instanceof n8n_workflow_1.NodeOperationError &&
+                            error.type === 'invalid_url') {
+                            const urlParameterName = pagination.paginationMode ===
+                                'responseContainsNextURL'
+                                ? 'Next URL'
+                                : 'URL';
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, {
+                                description: `Make sure the "${urlParameterName}" parameter evaluates to a valid URL.`,
+                            });
+                        }
+                        throw error;
+                    });
+                    requestPromises.push(requestPromise);
+                }
+                else if (authentication === 'genericCredentialType' ||
+                    authentication === 'none') {
+                    if (oAuth1Api) {
+                        const requestOAuth1 = this.helpers.requestOAuth1.call(this, 'oAuth1Api', requestOptions);
+                        requestOAuth1.catch(() => { });
+                        requestPromises.push(requestOAuth1);
+                    }
+                    else if (oAuth2Api) {
+                        const requestOAuth2 = this.helpers.requestOAuth2.call(this, 'oAuth2Api', requestOptions, { tokenType: 'Bearer' });
+                        requestOAuth2.catch(() => { });
+                        requestPromises.push(requestOAuth2);
+                    }
+                    else {
+                        const request = this.helpers.request(requestOptions);
+                        request.catch(() => { });
+                        requestPromises.push(request);
+                    }
+                }
+                else if (authentication === 'predefinedCredentialType' &&
+                    nodeCredentialType) {
+                    const additionalOAuth2Options = (0, helpers_1.getOAuth2AdditionalParameters)(nodeCredentialType);
+                    const requestWithAuthentication = this.helpers.requestWithAuthentication.call(this, nodeCredentialType, requestOptions, additionalOAuth2Options && {
+                        oauth2: additionalOAuth2Options,
+                    }, itemIndex);
+                    requestWithAuthentication.catch(() => { });
+                    requestPromises.push(requestWithAuthentication);
+                }
+            }
+            catch (error) {
+                if (!this.continueOnFail())
+                    throw error;
+                requestPromises.push(Promise.reject(error).catch(() => { }));
+                errorItems[itemIndex] = error.message;
+                continue;
+            }
+        }
+        const sanitizedRequests = [];
+        const promisesResponses = await Promise.allSettled(requestPromises.map(async (requestPromise, itemIndex) => await requestPromise
+            .then((response) => response)
+            .finally(async () => {
+            if (errorItems[itemIndex])
+                return;
+            try {
+                const { options, authKeys, credentialType } = requests[itemIndex];
+                let secrets = [];
+                if (credentialType) {
+                    const properties = this.getCredentialsProperties(credentialType);
+                    const credentials = await this.getCredentials(credentialType, itemIndex);
+                    secrets = (0, helpers_1.getSecrets)(properties, credentials);
+                }
+                const sanitizedRequestOptions = (0, helpers_1.sanitizeUiMessage)(options, authKeys, secrets);
+                sanitizedRequests.push(sanitizedRequestOptions);
+                this.sendMessageToUI(sanitizedRequestOptions);
+            }
+            catch { }
+        })));
+        let responseData;
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                responseData = promisesResponses.shift();
+                if (errorItems[itemIndex]) {
+                    returnItems.push({
+                        json: { error: errorItems[itemIndex] },
+                        pairedItem: { item: itemIndex },
+                    });
+                    continue;
+                }
+                if (responseData.status !== 'fulfilled') {
+                    if (responseData.reason.statusCode === 429) {
+                        responseData.reason.message =
+                            "Try spacing your requests out using the batching settings under 'Options'";
+                    }
+                    if (!this.continueOnFail()) {
+                        if (autoDetectResponseFormat &&
+                            responseData.reason.error instanceof Buffer) {
+                            responseData.reason.error = Buffer.from(responseData.reason.error).toString();
+                        }
+                        let error;
+                        if ((responseData === null || responseData === void 0 ? void 0 : responseData.reason) instanceof n8n_workflow_1.NodeApiError) {
+                            error = responseData.reason;
+                            (0, set_1.default)(error, 'context.itemIndex', itemIndex);
+                        }
+                        else {
+                            const errorData = (responseData.reason
+                                ? responseData.reason
+                                : responseData);
+                            error = new n8n_workflow_1.NodeApiError(this.getNode(), errorData, {
+                                itemIndex,
+                            });
+                        }
+                        (0, set_1.default)(error, 'context.request', sanitizedRequests[itemIndex]);
+                        throw error;
+                    }
+                    else {
+                        const reason = responseData.reason;
+                        let safeError;
+                        if (reason instanceof Error) {
+                            safeError = {
+                                message: reason.message,
+                                name: reason.name,
+                                ...(reason.statusCode !== undefined ? { statusCode: reason.statusCode } : {}),
+                                ...(reason.httpCode !== undefined ? { httpCode: reason.httpCode } : {}),
+                                ...(reason.code !== undefined ? { code: reason.code } : {}),
+                                ...(reason.description !== undefined ? { description: reason.description } : {}),
+                                ...(reason.headers ? { headers: reason.headers } : {}),
+                                ...(((_s = reason.response) === null || _s === void 0 ? void 0 : _s.headers) ? { response: { headers: reason.response.headers } } : {}),
+                            };
+                        }
+                        else if (typeof reason === 'object' && reason !== null) {
+                            try {
+                                (0, n8n_workflow_1.removeCircularRefs)(reason);
+                                safeError = reason;
+                            }
+                            catch {
+                                safeError = { message: String(reason) };
+                            }
+                        }
+                        else {
+                            safeError = { message: String(reason) };
+                        }
+                        returnItems.push({
+                            json: { error: safeError },
+                            pairedItem: { item: itemIndex },
+                        });
+                        continue;
+                    }
+                }
+                let responses;
+                if (Array.isArray(responseData.value)) {
+                    responses = responseData.value;
+                }
+                else {
+                    responses = [responseData.value];
+                }
+                let responseFormat = this.getNodeParameter('options.response.response.responseFormat', 0, 'autodetect');
+                fullResponse = this.getNodeParameter('options.response.response.fullResponse', 0, false);
+                for (let [index, response] of Object.entries(responses)) {
+                    if (((_t = response === null || response === void 0 ? void 0 : response.request) === null || _t === void 0 ? void 0 : _t.constructor.name) === 'ClientRequest')
+                        delete response.request;
+                    if (this.getMode() === 'manual' && index === '0') {
+                        const nodeContext = this.getContext('node');
+                        if (pagination && pagination.paginationMode !== 'off') {
+                            nodeContext.response = responseData.value[0];
+                        }
+                        else {
+                            nodeContext.response = responseData.value;
+                        }
+                    }
+                    const responseContentType = (_v = (_u = response.headers) === null || _u === void 0 ? void 0 : _u['content-type']) !== null && _v !== void 0 ? _v : '';
+                    if (autoDetectResponseFormat) {
+                        if (responseContentType.includes('application/json')) {
+                            responseFormat = 'json';
+                            if (!response.__bodyResolved) {
+                                const neverError = this.getNodeParameter('options.response.response.neverError', 0, false);
+                                const data = await (0, helpers_1.binaryToStringWithEncodingDetection)(response.body, responseContentType, this.helpers);
+                                response.body = (0, n8n_workflow_1.jsonParse)(data, {
+                                    ...(neverError
+                                        ? { fallbackValue: {} }
+                                        : {
+                                            errorMessage: 'Invalid JSON in response body',
+                                        }),
+                                });
+                            }
+                        }
+                        else if (helpers_1.binaryContentTypes.some((e) => responseContentType.includes(e))) {
+                            responseFormat = 'file';
+                        }
+                        else {
+                            responseFormat = 'text';
+                            if (!response.__bodyResolved) {
+                                const data = await (0, helpers_1.binaryToStringWithEncodingDetection)(response.body, responseContentType, this.helpers);
+                                response.body = !data ? undefined : data;
+                            }
+                        }
+                    }
+                    const optimizeResponse = (0, helpers_1.configureResponseOptimizer)(this, itemIndex);
+                    if (autoDetectResponseFormat && !fullResponse) {
+                        delete response.headers;
+                        delete response.statusCode;
+                        delete response.statusMessage;
+                    }
+                    if (!fullResponse) {
+                        response = optimizeResponse(response.body);
+                    }
+                    else {
+                        response.body = optimizeResponse(response.body);
+                    }
+                    if (responseFormat === 'file') {
+                        const outputPropertyName = this.getNodeParameter('options.response.response.outputPropertyName', 0, 'data');
+                        const newItem = {
+                            json: {},
+                            binary: {},
+                            pairedItem: { item: itemIndex },
+                        };
+                        if (items[itemIndex].binary !== undefined) {
+                            Object.assign(newItem.binary, items[itemIndex].binary);
+                        }
+                        let binaryData;
+                        if (fullResponse) {
+                            const returnItem = {};
+                            for (const property of fullResponseProperties) {
+                                if (property === 'body')
+                                    continue;
+                                returnItem[property] = response[property];
+                            }
+                            newItem.json = returnItem;
+                            binaryData = response === null || response === void 0 ? void 0 : response.body;
+                        }
+                        else {
+                            newItem.json = items[itemIndex].json;
+                            binaryData = response;
+                        }
+                        const preparedBinaryData = await this.helpers.prepareBinaryData(binaryData, undefined, (0, helpers_1.mimeTypeFromResponse)(responseContentType));
+                        preparedBinaryData.fileName = (0, helpers_1.setFilename)(preparedBinaryData, requestOptions, responseFileName);
+                        newItem.binary[outputPropertyName] =
+                            preparedBinaryData;
+                        returnItems.push(newItem);
+                    }
+                    else if (responseFormat === 'text') {
+                        const outputPropertyName = this.getNodeParameter('options.response.response.outputPropertyName', 0, 'data');
+                        if (fullResponse) {
+                            const returnItem = {};
+                            for (const property of fullResponseProperties) {
+                                if (property === 'body') {
+                                    returnItem[outputPropertyName] = toText(response[property]);
+                                    continue;
+                                }
+                                returnItem[property] = response[property];
+                            }
+                            returnItems.push({
+                                json: returnItem,
+                                pairedItem: { item: itemIndex },
+                            });
+                        }
+                        else {
+                            returnItems.push({
+                                json: {
+                                    [outputPropertyName]: toText(response),
+                                },
+                                pairedItem: { item: itemIndex },
+                            });
+                        }
+                    }
+                    else {
+                        if (fullResponse) {
+                            const returnItem = {};
+                            for (const property of fullResponseProperties) {
+                                returnItem[property] = response[property];
+                            }
+                            if (responseFormat === 'json' &&
+                                typeof returnItem.body === 'string') {
+                                try {
+                                    returnItem.body = JSON.parse(returnItem.body);
+                                }
+                                catch {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Response body is not valid JSON. Change "Response Format" to "Text"', { itemIndex });
+                                }
+                            }
+                            returnItems.push({
+                                json: returnItem,
+                                pairedItem: { item: itemIndex },
+                            });
+                        }
+                        else {
+                            if (responseFormat === 'json' &&
+                                typeof response === 'string') {
+                                try {
+                                    if (typeof response !== 'object') {
+                                        response = JSON.parse(response);
+                                    }
+                                }
+                                catch {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Response body is not valid JSON. Change "Response Format" to "Text"', { itemIndex });
+                                }
+                            }
+                            if (Array.isArray(response)) {
+                                response.forEach((item) => returnItems.push({
+                                    json: item,
+                                    pairedItem: { item: itemIndex },
+                                }));
+                            }
+                            else {
+                                returnItems.push({
+                                    json: response,
+                                    pairedItem: { item: itemIndex },
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (!this.continueOnFail())
+                    throw error;
+                returnItems.push({
+                    json: { error: error.message },
+                    pairedItem: { item: itemIndex },
+                });
+                continue;
+            }
+        }
+        const retryOnFail = this.getNodeParameter('options.retryOnFail', 0, false);
+        if (retryOnFail && this.continueOnFail()) {
+            const maxRetries = this.getNodeParameter('options.maxRetries', 0, 3);
+            const retryDelay = this.getNodeParameter('options.retryDelay', 0, 1000);
+            const retryOnStatusCodesStr = this.getNodeParameter('options.retryOnStatusCodes', 0, '429,500,502,503,504');
+            const retryOnStatusCodes = new Set(retryOnStatusCodesStr
+                .split(',')
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((n) => !isNaN(n)));
+            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                const failedIndices = [];
+                for (let i = 0; i < returnItems.length; i++) {
+                    const item = returnItems[i];
+                    if (item.json && item.json.error) {
+                        const errObj = item.json.error;
+                        let statusCode;
+                        if (typeof errObj === 'object' && errObj !== null) {
+                            statusCode =
+                                (_x = (_w = errObj.statusCode) !== null && _w !== void 0 ? _w : errObj.httpCode) !== null && _x !== void 0 ? _x : errObj.code;
+                        }
+                        if (statusCode !== undefined &&
+                            retryOnStatusCodes.has(statusCode)) {
+                            failedIndices.push(i);
+                        }
+                    }
+                }
+                if (failedIndices.length === 0)
+                    break;
+                let effectiveDelay = retryDelay;
+                for (const idx of failedIndices) {
+                    const errObj = returnItems[idx].json.error;
+                    if (typeof errObj === 'object' && errObj !== null) {
+                        const sc = errObj.statusCode;
+                        if (sc === 429) {
+                            const retryAfterHeader = (_z = (_y = errObj.headers) === null || _y === void 0 ? void 0 : _y['retry-after']) !== null && _z !== void 0 ? _z : (_1 = (_0 = errObj.response) === null || _0 === void 0 ? void 0 : _0.headers) === null || _1 === void 0 ? void 0 : _1['retry-after'];
+                            if (retryAfterHeader) {
+                                const retryAfterSeconds = parseInt(retryAfterHeader, 10);
+                                if (!isNaN(retryAfterSeconds)) {
+                                    effectiveDelay = Math.max(effectiveDelay, retryAfterSeconds * 1000);
+                                }
+                            }
+                        }
+                    }
+                }
+                if (effectiveDelay > 0) {
+                    await (0, n8n_workflow_1.sleep)(effectiveDelay);
+                }
+                const retryPromises = [];
+                for (const idx of failedIndices) {
+                    const originalItemIndex = returnItems[idx].pairedItem &&
+                        typeof returnItems[idx].pairedItem === 'object' &&
+                        !Array.isArray(returnItems[idx].pairedItem)
+                        ? returnItems[idx].pairedItem
+                            .item
+                        : idx;
+                    if (requests[originalItemIndex]) {
+                        const { options } = requests[originalItemIndex];
+                        const retryRequest = this.helpers
+                            .request(options)
+                            .catch(() => { });
+                        retryPromises.push({
+                            index: idx,
+                            promise: retryRequest,
+                        });
+                    }
+                }
+                const retryResults = await Promise.allSettled(retryPromises.map((r) => r.promise));
+                for (let ri = 0; ri < retryResults.length; ri++) {
+                    const result = retryResults[ri];
+                    const idx = retryPromises[ri].index;
+                    const originalItemIndex = returnItems[idx].pairedItem &&
+                        typeof returnItems[idx].pairedItem === 'object' &&
+                        !Array.isArray(returnItems[idx].pairedItem)
+                        ? returnItems[idx].pairedItem
+                            .item
+                        : idx;
+                    if (result.status === 'fulfilled' && result.value != null) {
+                        const response = result.value;
+                        if (typeof response === 'object' &&
+                            response !== null &&
+                            response.body !== undefined) {
+                            let responseFormat = this.getNodeParameter('options.response.response.responseFormat', 0, 'autodetect');
+                            const currentFullResponse = this.getNodeParameter('options.response.response.fullResponse', 0, false);
+                            if (responseFormat === 'autodetect') {
+                                const ct = (_3 = (_2 = response.headers) === null || _2 === void 0 ? void 0 : _2['content-type']) !== null && _3 !== void 0 ? _3 : '';
+                                if (ct.includes('application/json')) {
+                                    responseFormat = 'json';
+                                }
+                                else {
+                                    responseFormat = 'text';
+                                }
+                            }
+                            if (currentFullResponse) {
+                                returnItems[idx] = {
+                                    json: {
+                                        body: typeof response.body === 'string'
+                                            ? (0, n8n_workflow_1.jsonParse)(response.body, {
+                                                fallbackValue: response.body,
+                                            })
+                                            : response.body,
+                                        headers: response.headers,
+                                        statusCode: response.statusCode,
+                                        statusMessage: response.statusMessage,
+                                    },
+                                    pairedItem: {
+                                        item: originalItemIndex,
+                                    },
+                                };
+                            }
+                            else {
+                                let bodyData = response.body;
+                                if (Buffer.isBuffer(bodyData)) {
+                                    const bodyStr = bodyData.toString('utf-8');
+                                    try {
+                                        bodyData = JSON.parse(bodyStr);
+                                    }
+                                    catch {
+                                        bodyData = bodyStr;
+                                    }
+                                }
+                                else if (typeof bodyData === 'string') {
+                                    try {
+                                        bodyData = JSON.parse(bodyData);
+                                    }
+                                    catch { }
+                                }
+                                if (typeof bodyData === 'object' &&
+                                    bodyData !== null) {
+                                    returnItems[idx] = {
+                                        json: bodyData,
+                                        pairedItem: {
+                                            item: originalItemIndex,
+                                        },
+                                    };
+                                }
+                                else {
+                                    returnItems[idx] = {
+                                        json: { data: bodyData },
+                                        pairedItem: {
+                                            item: originalItemIndex,
+                                        },
+                                    };
+                                }
+                            }
+                        }
+                        else if (typeof response === 'object' &&
+                            response !== null) {
+                            returnItems[idx] = {
+                                json: response,
+                                pairedItem: { item: originalItemIndex },
+                            };
+                        }
+                        else {
+                            try {
+                                const parsed = JSON.parse(response);
+                                returnItems[idx] = {
+                                    json: parsed,
+                                    pairedItem: {
+                                        item: originalItemIndex,
+                                    },
+                                };
+                            }
+                            catch {
+                                returnItems[idx] = {
+                                    json: { data: response },
+                                    pairedItem: {
+                                        item: originalItemIndex,
+                                    },
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        returnItems = returnItems.map(helpers_1.replaceNullValues);
+        if (returnItems.length === 1 &&
+            returnItems[0].json.data &&
+            Array.isArray(returnItems[0].json.data)) {
+            const message = "To split the contents of 'data' into separate items for easier processing, add a 'Split Out' node after this one";
+            if (this.addExecutionHints) {
+                this.addExecutionHints({
+                    message,
+                    location: 'outputPane',
+                });
+            }
+            else {
+                this.logger.info(message);
+            }
+        }
+        return [returnItems];
+    }
+}
+exports.BetterHttpRequest = BetterHttpRequest;
+//# sourceMappingURL=BetterHttpRequest.node.js.map