public static makeRequest()

in Library/Util.ts [298:372]
68 lines of code
22 McCabe index (conditional complexity)

    public static makeRequest(
        config: Config,
        requestUrl: string,
        requestOptions: http.RequestOptions | https.RequestOptions,
        requestCallback: (res: http.IncomingMessage) => void,
        useProxy = true,
        useAgent = true): http.ClientRequest {

        if (requestUrl && requestUrl.indexOf('//') === 0) {
            requestUrl = 'https:' + requestUrl;
        }

        var requestUrlParsed = new url.URL(requestUrl);
        var options = {
            ...requestOptions,
            host: requestUrlParsed.hostname,
            port: requestUrlParsed.port,
            path: requestUrlParsed.pathname,
        };

        var proxyUrl: string = undefined;
        if (useProxy) {
            if (requestUrlParsed.protocol === 'https:') {
                proxyUrl = config.proxyHttpsUrl || undefined;
            }
            if (requestUrlParsed.protocol === 'http:') {
                proxyUrl = config.proxyHttpUrl || undefined;
            }
            if (proxyUrl) {
                if (proxyUrl.indexOf('//') === 0) {
                    proxyUrl = 'http:' + proxyUrl;
                }
                try {
                    var proxyUrlParsed = new url.URL(proxyUrl);
                    // https is not supported at the moment
                    if (proxyUrlParsed.protocol === 'https:') {
                        Logging.info("Proxies that use HTTPS are not supported");
                        proxyUrl = undefined;
                    } else {
                        options = {
                            ...options,
                            host: proxyUrlParsed.hostname,
                            port: proxyUrlParsed.port || "80",
                            path: requestUrl,
                            headers: {
                                ...options.headers,
                                Host: requestUrlParsed.hostname,
                            },
                        };
                    }
                }
                catch (err) {
                    Logging.warn("Wrong proxy URL provided");
                }
            }
        }

        var isHttps = requestUrlParsed.protocol === 'https:' && !proxyUrl;
        if (useAgent) {
            if (isHttps && config.httpsAgent !== undefined) {
                options.agent = config.httpsAgent;
            } else if (!isHttps && config.httpAgent !== undefined) {
                options.agent = config.httpAgent;
            } else if (isHttps) {
                // HTTPS without a passed in agent. Use one that enforces our TLS rules
                options.agent = Util._useKeepAlive ? Util.keepAliveAgent : Util.tlsRestrictedAgent;
            }
        }
        if (isHttps) {
            return https.request(<any>options, requestCallback);
        } else {
            return http.request(<any>options, requestCallback);
        }

    };