function handleRequestAsync()

in src/Sfx-Standalone/modules/http/request-handlers/electron.ts [56:153]
78 lines of code
12 McCabe index (conditional complexity)

function handleRequestAsync(
    serverCertValidator: ServerCertValidator,
    pipeline: IHttpPipeline,
    request: IHttpRequest): Promise<IHttpResponse> {
    return new Promise((resolve, reject) => {
        try {
            const session = electron.session.fromPartition(uuidv4(), {
                cache: false
            });

            if (serverCertValidator) {
                session.setCertificateVerifyProc((request, callback) => {
                    if (request.errorCode === 0) {
                        callback(request.errorCode);

                    } else if (serverCertValidator(request.hostname, toCertificateInfo(request.certificate))) {
                        callback(0);

                    } else {
                        callback(-2);
                    }
                });
            }

            session.allowNTLMCredentialsForDomains("*");
            session.webRequest.onErrorOccurred((details) => {
                if (details.error === "net::ERR_SSL_CLIENT_AUTH_CERT_NEEDED") {
                    resolve({
                        httpVersion: "1.1",
                        statusCode: 403,
                        statusMessage: "Client certificate required",
                        data: undefined,
                        headers: [],
                        body: undefined
                    });
                    return;
                }

                reject(new Error(details.error));
            });

            const options: any = Object.assign(Object.create(null));
            let body: string | Buffer;

            if (Buffer.isBuffer(request.body) || typeof request.body === "string") {
                body = request.body;

            } else {
                body = JSON.stringify(request.body);

                const headerIndex = request.headers.findIndex((value) => value.name === "Content-Type");
                const contentTypeHeader: IHttpHeader = headerIndex < 0 ? Object.create(null) : request.headers[headerIndex];

                contentTypeHeader.name = "Content-Type";
                contentTypeHeader.value = "application/json; charset=utf-8";

                if (headerIndex >= 0) {
                    request.headers[headerIndex] = contentTypeHeader;
                } else {
                    request.headers.push(contentTypeHeader);
                }
            }

            options.url = request.url;
            options.method = request.method;
            options.session = session;
            options.redirect = "manual";

            const httpRequest = electron.net.request(options);

            if (request.headers) {
                applyHeaders(httpRequest, request.headers);
            }

            httpRequest.on("response", async (response: electron.IncomingMessage & NodeJS.ReadableStream) => {
                const httpResponse: IHttpResponse = Object.create(null);

                httpResponse.httpVersion = response.httpVersion;
                httpResponse.statusCode = response.statusCode;
                httpResponse.statusMessage = response.statusMessage;
                httpResponse.headers = generateHeaders(response.headers);
                httpResponse.body = await generateBodyAsync(response);

                resolve(httpResponse);
            });

            httpRequest.on("error", (error) => reject(error));

            if (body) {
                httpRequest.write(body);
            }

            httpRequest.end();
        } catch (err) {
            reject(err);
        }
    });
}