n8n-nodes-base 1.68.0 → 1.70.0

package/dist/nodes/HttpRequest/V3/HttpRequestV3.node.js

@@ -64,6 +64,7 @@ class HttpRequestV3 {
             uri: '',
         };
         let returnItems = [];
+        const errorItems = {};
         const requestPromises = [];
         let fullResponse = false;
         let autoDetectResponseFormat = false;
@@ -72,400 +73,415 @@ class HttpRequestV3 {
         });
         const requests = [];
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-            if (authentication === 'genericCredentialType') {
-                genericCredentialType = this.getNodeParameter('genericAuthType', 0);
-                if (genericCredentialType === 'httpBasicAuth') {
-                    httpBasicAuth = await this.getCredentials('httpBasicAuth', itemIndex);
+            try {
+                if (authentication === 'genericCredentialType') {
+                    genericCredentialType = this.getNodeParameter('genericAuthType', 0);
+                    if (genericCredentialType === 'httpBasicAuth') {
+                        httpBasicAuth = await this.getCredentials('httpBasicAuth', 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 (genericCredentialType === 'httpDigestAuth') {
-                    httpDigestAuth = await this.getCredentials('httpDigestAuth', itemIndex);
+                else if (authentication === 'predefinedCredentialType') {
+                    nodeCredentialType = this.getNodeParameter('nodeCredentialType', itemIndex);
+                }
+                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, } = this.getNodeParameter('options', itemIndex, {});
+                const url = this.getNodeParameter('url', itemIndex);
+                const responseFormat = response?.response?.responseFormat || 'autodetect';
+                fullResponse = response?.response?.fullResponse || false;
+                autoDetectResponseFormat = responseFormat === 'autodetect';
+                const batchSize = batching?.batch?.batchSize > 0 ? batching?.batch?.batchSize : 1;
+                const batchInterval = batching?.batch.batchInterval;
+                if (itemIndex > 0 && batchSize >= 0 && batchInterval > 0) {
+                    if (itemIndex % batchSize === 0) {
+                        await (0, n8n_workflow_1.sleep)(batchInterval);
+                    }
                 }
-                else if (genericCredentialType === 'httpHeaderAuth') {
-                    httpHeaderAuth = await this.getCredentials('httpHeaderAuth', itemIndex);
+                requestOptions = {
+                    headers: {},
+                    method: requestMethod,
+                    uri: url,
+                    gzip: true,
+                    rejectUnauthorized: !allowUnauthorizedCerts || false,
+                    followRedirect: false,
+                    resolveWithFullResponse: true,
+                };
+                if (requestOptions.method !== 'GET' && nodeVersion >= 4.1) {
+                    requestOptions = { ...requestOptions, followAllRedirects: false };
                 }
-                else if (genericCredentialType === 'httpQueryAuth') {
-                    httpQueryAuth = await this.getCredentials('httpQueryAuth', itemIndex);
+                const defaultRedirect = nodeVersion >= 4 && redirect === undefined;
+                if (redirect?.redirect?.followRedirects || defaultRedirect) {
+                    requestOptions.followRedirect = true;
+                    requestOptions.followAllRedirects = true;
                 }
-                else if (genericCredentialType === 'httpCustomAuth') {
-                    httpCustomAuth = await this.getCredentials('httpCustomAuth', itemIndex);
+                if (redirect?.redirect?.maxRedirects || defaultRedirect) {
+                    requestOptions.maxRedirects = redirect?.redirect?.maxRedirects;
                 }
-                else if (genericCredentialType === 'oAuth1Api') {
-                    oAuth1Api = await this.getCredentials('oAuth1Api', itemIndex);
+                if (response?.response?.neverError) {
+                    requestOptions.simple = false;
                 }
-                else if (genericCredentialType === 'oAuth2Api') {
-                    oAuth2Api = await this.getCredentials('oAuth2Api', itemIndex);
+                if (proxy) {
+                    requestOptions.proxy = proxy;
                 }
-            }
-            else if (authentication === 'predefinedCredentialType') {
-                nodeCredentialType = this.getNodeParameter('nodeCredentialType', itemIndex);
-            }
-            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, } = this.getNodeParameter('options', itemIndex, {});
-            const url = this.getNodeParameter('url', itemIndex);
-            const responseFormat = response?.response?.responseFormat || 'autodetect';
-            fullResponse = response?.response?.fullResponse || false;
-            autoDetectResponseFormat = responseFormat === 'autodetect';
-            const batchSize = batching?.batch?.batchSize > 0 ? batching?.batch?.batchSize : 1;
-            const batchInterval = batching?.batch.batchInterval;
-            if (itemIndex > 0 && batchSize >= 0 && batchInterval > 0) {
-                if (itemIndex % batchSize === 0) {
-                    await (0, n8n_workflow_1.sleep)(batchInterval);
+                if (timeout) {
+                    requestOptions.timeout = timeout;
                 }
-            }
-            requestOptions = {
-                headers: {},
-                method: requestMethod,
-                uri: url,
-                gzip: true,
-                rejectUnauthorized: !allowUnauthorizedCerts || false,
-                followRedirect: false,
-                resolveWithFullResponse: true,
-            };
-            if (requestOptions.method !== 'GET' && nodeVersion >= 4.1) {
-                requestOptions = { ...requestOptions, followAllRedirects: false };
-            }
-            const defaultRedirect = nodeVersion >= 4 && redirect === undefined;
-            if (redirect?.redirect?.followRedirects || defaultRedirect) {
-                requestOptions.followRedirect = true;
-                requestOptions.followAllRedirects = true;
-            }
-            if (redirect?.redirect?.maxRedirects || defaultRedirect) {
-                requestOptions.maxRedirects = redirect?.redirect?.maxRedirects;
-            }
-            if (response?.response?.neverError) {
-                requestOptions.simple = false;
-            }
-            if (proxy) {
-                requestOptions.proxy = proxy;
-            }
-            if (timeout) {
-                requestOptions.timeout = timeout;
-            }
-            else {
-                requestOptions.timeout = 300_000;
-            }
-            if (sendQuery && queryParameterArrays) {
-                Object.assign(requestOptions, {
-                    qsStringifyOptions: { arrayFormat: queryParameterArrays },
-                });
-            }
-            const parametersToKeyValue = async (accumulator, cur) => {
-                if (cur.parameterType === 'formBinaryData') {
-                    if (!cur.inputDataFieldName)
+                else {
+                    requestOptions.timeout = 300_000;
+                }
+                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;
+                        const itemBinaryData = items[itemIndex].binary[cur.inputDataFieldName];
+                        if (itemBinaryData.id) {
+                            uploadData = await this.helpers.getBinaryStream(itemBinaryData.id);
+                        }
+                        else {
+                            uploadData = Buffer.from(itemBinaryData.data, n8n_workflow_1.BINARY_ENCODING);
+                        }
+                        accumulator[cur.name] = {
+                            value: uploadData,
+                            options: {
+                                filename: binaryData.fileName,
+                                contentType: binaryData.mimeType,
+                            },
+                        };
                         return accumulator;
-                    const binaryData = this.helpers.assertBinaryData(itemIndex, cur.inputDataFieldName);
-                    let uploadData;
-                    const itemBinaryData = items[itemIndex].binary[cur.inputDataFieldName];
-                    if (itemBinaryData.id) {
-                        uploadData = await this.helpers.getBinaryStream(itemBinaryData.id);
-                    }
-                    else {
-                        uploadData = Buffer.from(itemBinaryData.data, n8n_workflow_1.BINARY_ENCODING);
                     }
-                    accumulator[cur.name] = {
-                        value: uploadData,
-                        options: {
-                            filename: binaryData.fileName,
-                            contentType: binaryData.mimeType,
-                        },
-                    };
+                    accumulator[cur.name] = cur.value;
                     return accumulator;
+                };
+                if (sendBody && bodyParameters) {
+                    if (specifyBody === 'keypair' || bodyContentType === 'multipart-form-data') {
+                        requestOptions.body = await (0, GenericFunctions_1.prepareRequestBody)(bodyParameters, bodyContentType, nodeVersion, parametersToKeyValue);
+                    }
+                    else if (specifyBody === 'json') {
+                        if (typeof jsonBodyParameter !== 'object' && jsonBodyParameter !== null) {
+                            try {
+                                JSON.parse(jsonBodyParameter);
+                            }
+                            catch {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'JSON parameter needs to be valid JSON', {
+                                    itemIndex,
+                                });
+                            }
+                            requestOptions.body = (0, n8n_workflow_1.jsonParse)(jsonBodyParameter);
+                        }
+                        else {
+                            requestOptions.body = jsonBodyParameter;
+                        }
+                    }
+                    else if (specifyBody === 'string') {
+                        requestOptions.body = Object.fromEntries(new URLSearchParams(body));
+                    }
                 }
-                accumulator[cur.name] = cur.value;
-                return accumulator;
-            };
-            if (sendBody && bodyParameters) {
-                if (specifyBody === 'keypair' || bodyContentType === 'multipart-form-data') {
-                    requestOptions.body = await (0, GenericFunctions_1.prepareRequestBody)(bodyParameters, bodyContentType, nodeVersion, parametersToKeyValue);
+                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': itemBinaryData.mimeType ?? 'application/octet-stream',
+                        };
+                    }
+                    else if (bodyContentType === 'raw') {
+                        requestOptions.body = body;
+                    }
                 }
-                else if (specifyBody === 'json') {
-                    if (typeof jsonBodyParameter !== 'object' && jsonBodyParameter !== null) {
+                if (sendQuery && queryParameters) {
+                    if (specifyQuery === 'keypair') {
+                        requestOptions.qs = await (0, GenericFunctions_1.reduceAsync)(queryParameters, parametersToKeyValue);
+                    }
+                    else if (specifyQuery === 'json') {
                         try {
-                            JSON.parse(jsonBodyParameter);
+                            JSON.parse(jsonQueryParameter);
                         }
                         catch {
                             throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'JSON parameter needs to be valid JSON', {
                                 itemIndex,
                             });
                         }
-                        requestOptions.body = (0, n8n_workflow_1.jsonParse)(jsonBodyParameter);
-                    }
-                    else {
-                        requestOptions.body = jsonBodyParameter;
+                        requestOptions.qs = (0, n8n_workflow_1.jsonParse)(jsonQueryParameter);
                     }
                 }
-                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;
+                if (sendHeaders && headerParameters) {
+                    let additionalHeaders = {};
+                    if (specifyHeaders === 'keypair') {
+                        additionalHeaders = await (0, GenericFunctions_1.reduceAsync)(headerParameters.filter((header) => header.name), parametersToKeyValue);
                     }
-                    else {
-                        uploadData = Buffer.from(itemBinaryData.data, n8n_workflow_1.BINARY_ENCODING);
-                        contentLength = uploadData.length;
+                    else if (specifyHeaders === 'json') {
+                        try {
+                            JSON.parse(jsonHeadersParameter);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'JSON parameter needs to be valid JSON', {
+                                itemIndex,
+                            });
+                        }
+                        additionalHeaders = (0, n8n_workflow_1.jsonParse)(jsonHeadersParameter);
                     }
-                    requestOptions.body = uploadData;
                     requestOptions.headers = {
                         ...requestOptions.headers,
-                        'content-length': contentLength,
-                        'content-type': itemBinaryData.mimeType ?? 'application/octet-stream',
+                        ...(lowercaseHeaders === undefined || lowercaseHeaders
+                            ? (0, utilities_1.keysToLowercase)(additionalHeaders)
+                            : additionalHeaders),
                     };
                 }
-                else if (bodyContentType === 'raw') {
-                    requestOptions.body = body;
+                if (autoDetectResponseFormat || responseFormat === 'file') {
+                    requestOptions.encoding = null;
+                    requestOptions.json = false;
+                    requestOptions.useStream = true;
                 }
-            }
-            if (sendQuery && queryParameters) {
-                if (specifyQuery === 'keypair') {
-                    requestOptions.qs = await (0, GenericFunctions_1.reduceAsync)(queryParameters, parametersToKeyValue);
+                else if (bodyContentType === 'raw') {
+                    requestOptions.json = false;
+                    requestOptions.useStream = true;
                 }
-                else if (specifyQuery === 'json') {
-                    try {
-                        JSON.parse(jsonQueryParameter);
-                    }
-                    catch {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'JSON parameter needs to be valid JSON', {
-                            itemIndex,
-                        });
-                    }
-                    requestOptions.qs = (0, n8n_workflow_1.jsonParse)(jsonQueryParameter);
+                else {
+                    requestOptions.json = true;
                 }
-            }
-            if (sendHeaders && headerParameters) {
-                let additionalHeaders = {};
-                if (specifyHeaders === 'keypair') {
-                    additionalHeaders = await (0, GenericFunctions_1.reduceAsync)(headerParameters.filter((header) => header.name), parametersToKeyValue);
-                }
-                else if (specifyHeaders === 'json') {
-                    try {
-                        JSON.parse(jsonHeadersParameter);
-                    }
-                    catch {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'JSON parameter needs to be valid JSON', {
-                            itemIndex,
-                        });
+                if (bodyContentType === 'raw') {
+                    if (requestOptions.headers === undefined) {
+                        requestOptions.headers = {};
                     }
-                    additionalHeaders = (0, n8n_workflow_1.jsonParse)(jsonHeadersParameter);
-                }
-                requestOptions.headers = {
-                    ...requestOptions.headers,
-                    ...(lowercaseHeaders === undefined || lowercaseHeaders
-                        ? (0, utilities_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, GenericFunctions_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 (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);
+                    const rawContentType = this.getNodeParameter('rawContentType', itemIndex);
+                    requestOptions.headers['content-type'] = rawContentType;
+                }
+                const authDataKeys = {};
+                (0, GenericFunctions_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 (requestOptions.headers.accept === undefined) {
-                if (responseFormat === 'json') {
-                    requestOptions.headers.accept = 'application/json,text/*;q=0.99';
+                if (httpHeaderAuth !== undefined) {
+                    requestOptions.headers[httpHeaderAuth.name] = httpHeaderAuth.value;
+                    authDataKeys.headers = [httpHeaderAuth.name];
                 }
-                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';
+                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'];
                 }
-            }
-            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 }}';
+                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);
+                    }
                 }
-                else {
-                    if (!pagination.completeExpression.length || pagination.completeExpression[0] !== '=') {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid or empty Complete Expression');
+                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';
                     }
-                    continueExpression = `={{ !(${pagination.completeExpression.trim().slice(3, -2)}) }}`;
                 }
-                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] = {};
+                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 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`);
+                        continueExpression = `={{ !(${pagination.completeExpression.trim().slice(3, -2)}) }}`;
+                    }
+                    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 ");
                         }
-                        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`);
+                        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 ?? 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.`,
+                            });
                         }
-                        paginationData.request[parameter.type][parameterName] = parameterValue;
+                        throw error;
                     });
+                    requestPromises.push(requestPromise);
                 }
-                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 ?? 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.`,
+                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);
                     }
-                    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, GenericFunctions_1.getOAuth2AdditionalParameters)(nodeCredentialType);
+                    const requestWithAuthentication = this.helpers.requestWithAuthentication.call(this, nodeCredentialType, requestOptions, additionalOAuth2Options && { oauth2: additionalOAuth2Options }, itemIndex);
+                    requestWithAuthentication.catch(() => { });
+                    requestPromises.push(requestWithAuthentication);
                 }
             }
-            else if (authentication === 'predefinedCredentialType' && nodeCredentialType) {
-                const additionalOAuth2Options = (0, GenericFunctions_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.finally(async () => {
+        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 = [];
@@ -483,6 +499,13 @@ class HttpRequestV3 {
         let responseData;
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
             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 =