@coolio/http/dist/esm/requestHandlers/http.requestHandler.js

HTTP networking client

import * as http from 'http';
import * as url from 'url';
import * as https from 'https';
import { encodeText, getEncodingFromHeaders } from '../helpers/encoder.helper';
import { HttpResponseHeaders } from '../httpResponseHeaders';
import { HttpStatusText } from '../httpCodes';
import { HttpRequestError } from '../httpRequestError';
import { CFormData } from '../formData';
export const httpRequestHandler = (requestHandlerOptions = {}) => {
    return (requestOptions) => new Promise((resolve, reject) => {
        const { url: urlString, method, headers, body, timeout, } = requestOptions;
        const { protocol, auth, hostname, port, path, } = url.parse(urlString);
        const requestModule = protocol === 'https:' ? https : http;
        const request = requestModule.request(Object.assign(Object.assign({}, requestHandlerOptions.defaultRequestOptions), { path,
            method,
            port,
            hostname,
            protocol,
            auth,
            timeout }), (response) => {
            const status = response.statusCode || -1;
            const statusText = response.statusMessage || HttpStatusText[status] || '';
            const ok = status > 0 && status < 400;
            const headers = new HttpResponseHeaders(response.headers);
            const bodyPromise = new Promise((resolve, reject) => {
                const chunks = [];
                response.on('data', data => chunks.push(data));
                response.on('error', error => reject(error));
                response.on('end', () => {
                    const body = Buffer.concat(chunks);
                    resolve(body);
                });
            });
            resolve({
                arrayBuffer: () => bodyPromise,
                text: () => bodyPromise.then(buffer => encodeText(buffer, getEncodingFromHeaders(headers))),
                ok,
                headers,
                redirected: false,
                status,
                statusText,
                url: response.url || urlString,
                abort: () => request.abort(),
            });
        }).once('error', (error) => {
            reject(error);
        }).once('timeout', () => {
            reject(new HttpRequestError(requestOptions, `Request timed out after ${timeout}ms.`));
        });
        for (const key in headers) {
            if (headers.hasOwnProperty(key)) {
                request.setHeader(key, headers[key]);
            }
        }
        if (CFormData.isFormData(body)) {
            const formData = new CFormData(body);
            const formHeaders = formData.getHeaders();
            for (const key in formHeaders) {
                if (formHeaders.hasOwnProperty(key)) {
                    request.setHeader(key, formHeaders[key]);
                }
            }
            formData.pipe(request);
            return;
        }
        if (body) {
            if (typeof body === 'string') {
                request.write(body);
            }
            else {
                request.write(Buffer.from(body));
            }
        }
        request.end();
    });
};
//# sourceMappingURL=http.requestHandler.js.map