@api-client/core 0.9.25 → 0.10.1

package/build/cjs/src/runtime/http-engine/HttpEngine.js

@@ -0,0 +1,809 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpEngine = exports.mainPromiseSymbol = void 0;
+/* eslint-disable no-redeclare */
+/* eslint-disable no-unused-vars */
+const url_1 = require("url");
+const zlib_1 = __importDefault(require("zlib"));
+const tls_1 = __importDefault(require("tls"));
+const events_1 = require("events");
+const HttpRequest_js_1 = require("../../models/HttpRequest.js");
+const HostRule_js_1 = require("../../models/HostRule.js");
+const SentRequest_js_1 = require("../../models/SentRequest.js");
+const Response_js_1 = require("../../models/Response.js");
+const ErrorResponse_js_1 = require("../../models/ErrorResponse.js");
+const RequestsSize_js_1 = require("../../models/RequestsSize.js");
+const HttpResponse_js_1 = require("../../models/HttpResponse.js");
+const ResponseRedirect_js_1 = require("../../models/ResponseRedirect.js");
+const RequestLog_js_1 = require("../../models/RequestLog.js");
+const RequestTime_js_1 = require("../../models/RequestTime.js");
+const SerializableError_js_1 = require("../../models/SerializableError.js");
+const ResponseAuthorization_js_1 = require("../../models/ResponseAuthorization.js");
+const DefaultLogger_js_1 = require("../../lib/logging/DefaultLogger.js");
+const Headers_js_1 = require("../../lib/headers/Headers.js");
+const RequestUtils = __importStar(require("./RequestUtils.js"));
+// import { Cookies } from '../../lib/cookies/Cookies.js';
+const HttpErrorCodes_js_1 = require("./HttpErrorCodes.js");
+const CookieParser_js_1 = require("../../cookies/CookieParser.js");
+exports.mainPromiseSymbol = Symbol('mainPromise');
+/**
+ * The base class to make HTTP requests in API Client.
+ * This can be extended to support particular implementations.
+ */
+class HttpEngine extends events_1.EventEmitter {
+    request;
+    opts;
+    logger;
+    /**
+     * The current sent request
+     */
+    sentRequest;
+    redirects = [];
+    /**
+     * When true the request has been aborted.
+     */
+    aborted = false;
+    /**
+     * Parsed value of the request URL.
+     */
+    uri;
+    socket;
+    /**
+     * Host header can be different than registered URL because of
+     * `hosts` rules.
+     * If a rule changes host value of the URL the original URL host value
+     * is used when generating the request and not overwritten one.
+     * This way virtual hosts can be tested using hosts.
+     */
+    hostHeader;
+    hostTestReg = /^\s*host\s*:/im;
+    /**
+     * Set when the request is redirected.
+     */
+    redirecting = false;
+    /**
+     * The response headers.
+     * The object may be empty when the response is not set.
+     */
+    currentHeaders = new Headers_js_1.Headers();
+    /**
+     * The response object build during the execution.
+     */
+    currentResponse;
+    /**
+     * @return True if following redirects is allowed.
+     */
+    get followRedirects() {
+        const { opts } = this;
+        if (typeof opts.followRedirects === 'boolean') {
+            return opts.followRedirects;
+        }
+        return true;
+    }
+    /**
+     * The request timeout.
+     */
+    get timeout() {
+        const { opts } = this;
+        if (typeof opts.timeout === 'number') {
+            return opts.timeout;
+        }
+        return 0;
+    }
+    /**
+     * Keeps the raw body in a temporary buffer while processing the response.
+     */
+    _rawBody;
+    stats = {};
+    auth;
+    mainResolver;
+    mainRejecter;
+    [exports.mainPromiseSymbol];
+    _signal;
+    /**
+     * The abort signal to set on this request.
+     * Aborts the request when the signal fires.
+     * @type {(AbortSignal | undefined)}
+     */
+    get signal() {
+        return this._signal;
+    }
+    set signal(value) {
+        const old = this._signal;
+        if (old === value) {
+            return;
+        }
+        this._signal = value;
+        if (old) {
+            old.removeEventListener('abort', this._abortHandler);
+        }
+        if (value) {
+            value.addEventListener('abort', this._abortHandler);
+        }
+    }
+    constructor(request, opts = {}) {
+        super();
+        this.request = new HttpRequest_js_1.HttpRequest({ ...request });
+        this.opts = opts;
+        this.logger = this.setupLogger(opts);
+        this.sentRequest = new SentRequest_js_1.SentRequest({ ...request, startTime: Date.now() });
+        this.uri = this.readUrl(request.url);
+        this.hostHeader = RequestUtils.getHostHeader(request.url);
+        this._abortHandler = this._abortHandler.bind(this);
+        if (opts.signal) {
+            this.signal = opts.signal;
+        }
+    }
+    /**
+     * Creates a logger object to log debug output.
+     */
+    setupLogger(opts = {}) {
+        if (opts.logger) {
+            return opts.logger;
+        }
+        return new DefaultLogger_js_1.DefaultLogger();
+    }
+    /**
+     * Updates the `uri` property from current request URL
+     * @param value The request URL
+     */
+    readUrl(value) {
+        const { hosts = [] } = this.opts;
+        const instances = hosts.map(i => new HostRule_js_1.HostRule(i));
+        value = HostRule_js_1.HostRule.applyHosts(value, instances);
+        try {
+            return new url_1.URL(value);
+        }
+        catch (e) {
+            throw new Error(`Unable to parse the URL: ${value}`);
+        }
+    }
+    /**
+     * Aborts current request.
+     * It emits `error` event
+     */
+    abort() {
+        this.aborted = true;
+        if (!this.socket) {
+            return;
+        }
+        this.socket.removeAllListeners();
+        if (this.socket.destroyed) {
+            this.socket = undefined;
+            return;
+        }
+        this.socket.pause();
+        this.socket.destroy();
+        this.socket = undefined;
+    }
+    /**
+     * Handler for the `abort` event on the `AbortSignal`.
+     */
+    _abortHandler() {
+        const e = new SerializableError_js_1.SerializableError('Request aborted', 3);
+        this._errorRequest(e);
+        this.abort();
+    }
+    /**
+     * Decompresses received body if `content-encoding` header is set.
+     *
+     * @param body A body buffer to decompress.
+     * @return Promise resolved to parsed body
+     */
+    async decompress(body) {
+        const { aborted, currentHeaders } = this;
+        if (aborted || !currentHeaders || !body) {
+            return;
+        }
+        const ce = currentHeaders.get('content-encoding');
+        if (!ce) {
+            return body;
+        }
+        if (ce.indexOf('deflate') !== -1) {
+            return this.inflate(body);
+        }
+        if (ce.indexOf('gzip') !== -1) {
+            return this.gunzip(body);
+        }
+        if (ce.indexOf('br') !== -1) {
+            return this.brotli(body);
+        }
+        return body;
+    }
+    /**
+     * Decompress body with Inflate.
+     * @param body Received response payload
+     * @return Promise resolved to decompressed buffer.
+     */
+    inflate(body) {
+        body = Buffer.from(body);
+        return new Promise((resolve, reject) => {
+            zlib_1.default.inflate(body, (err, buffer) => {
+                if (err) {
+                    reject(new Error(err.message || String(err)));
+                }
+                else {
+                    resolve(buffer);
+                }
+            });
+        });
+    }
+    /**
+     * Decompress body with ZLib.
+     * @param body Received response payload
+     * @return Promise resolved to decompressed buffer.
+     */
+    gunzip(body) {
+        body = Buffer.from(body);
+        return new Promise((resolve, reject) => {
+            zlib_1.default.gunzip(body, (err, buffer) => {
+                if (err) {
+                    reject(new Error(err.message || String(err)));
+                }
+                else {
+                    resolve(buffer);
+                }
+            });
+        });
+    }
+    /**
+     * Decompress Brotli.
+     * @param body Received response payload
+     * @return Promise resolved to decompressed buffer.
+     */
+    brotli(body) {
+        body = Buffer.from(body);
+        return new Promise((resolve, reject) => {
+            zlib_1.default.brotliDecompress(body, (err, buffer) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(buffer);
+                }
+            });
+        });
+    }
+    /**
+     * Prepares headers list to be send to the remote machine.
+     * If `defaultHeaders` option is set then it adds `user-agent` and `accept`
+     * headers.
+     * @param headers Parsed headers
+     * @param withPayload Whether the request should send a body message
+     */
+    prepareHeaders(headers, withPayload = false) {
+        if (this.opts.defaultHeaders) {
+            if (!headers.has('user-agent')) {
+                if (this.opts.defaultUserAgent) {
+                    headers.set('user-agent', this.opts.defaultUserAgent);
+                }
+                else {
+                    headers.set('user-agent', 'api client');
+                }
+            }
+            if (!headers.has('accept')) {
+                if (this.opts.defaultAccept) {
+                    headers.set('accept', this.opts.defaultAccept);
+                }
+                else {
+                    headers.set('accept', '*/*');
+                }
+            }
+        }
+        if (withPayload) {
+            if (!headers.has('content-type') && this.request.payloadOptions) {
+                if (this.request.payloadOptions.mime) {
+                    headers.set('content-type', this.request.payloadOptions.mime);
+                }
+            }
+        }
+    }
+    /**
+     * Cleans the state after finished.
+     */
+    _cleanUp() {
+        this.redirects = [];
+        this.currentHeaders = new Headers_js_1.Headers();
+        this.currentResponse = undefined;
+        this._rawBody = undefined;
+        this.redirecting = false;
+        this.stats = {};
+        this.mainRejecter = undefined;
+        this.mainResolver = undefined;
+        this._clearSocketEventListeners();
+    }
+    /**
+     * Cleans up the state for redirect.
+     */
+    _cleanUpRedirect() {
+        this.currentHeaders = new Headers_js_1.Headers();
+        this.currentResponse = undefined;
+        this._rawBody = undefined;
+        this.stats = {};
+        this._clearSocketEventListeners();
+    }
+    /**
+     * Reports response when redirected.
+     * @param status Received status code
+     * @return True if the request has been redirected.
+     */
+    _reportRedirect(status) {
+        const { request, currentHeaders } = this;
+        if (!currentHeaders) {
+            return false;
+        }
+        const rerUrl = currentHeaders.get('location');
+        // https://github.com/jarrodek/socket-fetch/issues/13
+        const redirectOptions = RequestUtils.redirectOptions(status, request.method, rerUrl);
+        if (!redirectOptions.redirect) {
+            return false;
+        }
+        this.redirecting = true;
+        setTimeout(() => this._redirectRequest(redirectOptions));
+        return true;
+    }
+    /**
+     * Creates a response and adds it to the redirects list and redirects
+     * the request to the new location.
+     */
+    async _redirectRequest(options) {
+        if (this.followRedirects === false) {
+            this._publishResponse();
+            return;
+        }
+        const location = options.location && RequestUtils.getRedirectLocation(options.location, this.request.url);
+        if (!location) {
+            this._errorRequest({ code: 302 });
+            return;
+        }
+        // check if this is infinite loop
+        if (RequestUtils.isRedirectLoop(location, this.redirects)) {
+            this._errorRequest({ code: 310 });
+            return;
+        }
+        const detail = {
+            location,
+            returnValue: true,
+        };
+        this.emit('beforeredirect', detail);
+        if (!detail.returnValue) {
+            this._publishResponse();
+            return;
+        }
+        try {
+            const responseCookies = this.currentHeaders.get('set-cookie');
+            const response = await this._createRedirectResponse(location);
+            this.redirects.push(response);
+            this._cleanUpRedirect();
+            if (responseCookies) {
+                this._processRedirectCookies(responseCookies, location);
+            }
+            this.redirecting = false;
+            this.request.url = location;
+            this.sentRequest.url = location;
+            if (options.forceGet) {
+                this.request.method = 'GET';
+            }
+            this.uri = this.readUrl(location);
+            this.hostHeader = RequestUtils.getHostHeader(location);
+            // No idea why but without setTimeout the program loses it's
+            // scope after calling the function.
+            setTimeout(() => this.send());
+        }
+        catch (e) {
+            const error = e;
+            this._errorRequest({
+                message: (error && error.message) || 'Unknown error occurred',
+            });
+        }
+    }
+    /**
+     * @param location The redirect location.
+     * @return Redirect response object
+     */
+    async _createRedirectResponse(location) {
+        const { currentResponse = new Response_js_1.Response() } = this;
+        const response = HttpResponse_js_1.HttpResponse.fromValues(currentResponse.status, currentResponse.statusText, currentResponse.headers);
+        if (currentResponse.payload) {
+            response.payload = currentResponse.payload;
+        }
+        const body = await this.decompress(this._rawBody);
+        if (body) {
+            await response.writePayload(body);
+            currentResponse.payload = response.payload;
+        }
+        const redirect = ResponseRedirect_js_1.ResponseRedirect.fromValues(location, response.toJSON(), this.stats.startTime, this.stats.responseTime);
+        redirect.timings = this._computeStats(this.stats);
+        return redirect;
+    }
+    /**
+     * Creates a response object
+     *
+     * @return A response object.
+     */
+    async _createResponse() {
+        if (this.aborted) {
+            return;
+        }
+        const { currentResponse } = this;
+        if (!currentResponse) {
+            throw new Error(`Tried to create a response but no response data is set.`);
+        }
+        const { status } = currentResponse;
+        if (status === undefined) {
+            throw new Error(`The response status is empty.
+It means that the successful connection wasn't made.
+Check your request parameters.`);
+        }
+        const body = await this.decompress(this._rawBody);
+        const response = Response_js_1.Response.fromValues(status, currentResponse.statusText, currentResponse.headers);
+        response.timings = this._computeStats(this.stats);
+        response.loadingTime = response.timings.total();
+        if (body) {
+            await response.writePayload(body);
+            currentResponse.payload = response.payload;
+        }
+        if (status === 401) {
+            response.auth = this._getAuth();
+        }
+        return response;
+    }
+    /**
+     * Finishes the response with error message.
+     */
+    _errorRequest(opts) {
+        const { currentResponse } = this;
+        this.aborted = true;
+        let message;
+        if (opts.code && !opts.message) {
+            message = HttpErrorCodes_js_1.HttpErrorCodes.getCodeMessage(opts.code);
+        }
+        else if (opts.message) {
+            message = opts.message;
+        }
+        message = message || 'Unknown error occurred';
+        const error = new SerializableError_js_1.SerializableError(message, opts.code);
+        const log = RequestLog_js_1.RequestLog.fromRequest(this.sentRequest.toJSON());
+        const response = ErrorResponse_js_1.ErrorResponse.fromError(error);
+        log.response = response;
+        if (currentResponse && currentResponse.status) {
+            response.status = currentResponse.status;
+            response.statusText = currentResponse.statusText;
+            response.headers = currentResponse.headers;
+            response.payload = currentResponse.payload;
+        }
+        this.finalizeRequest(log);
+        this._cleanUp();
+    }
+    /**
+     * Generates authorization info object from response.
+     */
+    _getAuth() {
+        let auth = this.currentHeaders.get('www-authenticate');
+        const result = new ResponseAuthorization_js_1.ResponseAuthorization();
+        if (auth) {
+            auth = auth.toLowerCase();
+            if (auth.indexOf('ntlm') !== -1) {
+                result.method = 'ntlm';
+            }
+            else if (auth.indexOf('basic') !== -1) {
+                result.method = 'basic';
+            }
+            else if (auth.indexOf('digest') !== -1) {
+                result.method = 'digest';
+            }
+        }
+        return result;
+    }
+    /**
+     * Generate response object and publish it to the listeners.
+     */
+    async _publishResponse() {
+        if (this.aborted) {
+            return;
+        }
+        try {
+            const response = await this._createResponse();
+            if (!response) {
+                return;
+            }
+            const result = RequestLog_js_1.RequestLog.fromRequestResponse(this.sentRequest.toJSON(), response.toJSON());
+            if (this.redirects.length) {
+                result.redirects = this.redirects;
+            }
+            result.size = new RequestsSize_js_1.RequestsSize();
+            if (this.sentRequest.httpMessage) {
+                result.size.request = Buffer.from(this.sentRequest.httpMessage).length;
+            }
+            if (response.payload) {
+                if (typeof response.payload === 'string') {
+                    result.size.response = response.payload.length;
+                }
+                else {
+                    result.size.response = response.payload.data.length;
+                }
+            }
+            this.finalizeRequest(result);
+        }
+        catch (e) {
+            const error = e;
+            // eslint-disable-next-line no-console
+            console.error(error);
+            this._errorRequest({
+                message: (error && error.message) || 'Unknown error occurred',
+            });
+        }
+        this.abort();
+        this._cleanUp();
+    }
+    /**
+     * Creates HAR 1.2 timings object from stats.
+     * @param stats Timings object
+     */
+    _computeStats(stats) {
+        const { sentTime, messageStart, connectionTime = 0, lookupTime = 0, connectedTime, secureStartTime, secureConnectedTime, lastReceivedTime, firstReceiveTime, receivingTime, } = stats;
+        // in case the `send` event was not handled we use the `messageStart` as this is set when the request is created.
+        const adjustedSentTime = sentTime || messageStart;
+        // when there was no body we check when the end time.
+        const adjustedLastReceivedTime = lastReceivedTime || receivingTime;
+        const adjustedLookupTime = lookupTime || messageStart;
+        let send = adjustedSentTime && messageStart ? adjustedSentTime - messageStart : -1;
+        if (send < 0) {
+            send = 0;
+        }
+        const dns = lookupTime ? lookupTime - connectionTime : -1;
+        const connect = connectedTime && adjustedLookupTime ? connectedTime - adjustedLookupTime : -1;
+        let receive = adjustedLastReceivedTime && firstReceiveTime ? adjustedLastReceivedTime - firstReceiveTime : -1;
+        if (receive < 0) {
+            receive = 0;
+        }
+        let wait = firstReceiveTime && adjustedSentTime ? firstReceiveTime - adjustedSentTime : -1;
+        if (wait < 0) {
+            wait = 0;
+        }
+        let ssl = -1;
+        if (typeof secureStartTime === 'number' && typeof secureConnectedTime === 'number') {
+            ssl = secureConnectedTime - secureStartTime;
+        }
+        const result = new RequestTime_js_1.RequestTime();
+        result.blocked = 0;
+        result.connect = connect;
+        result.receive = receive;
+        result.send = send;
+        result.wait = wait;
+        result.dns = dns;
+        result.ssl = ssl;
+        return result;
+    }
+    /**
+     * Handles cookie exchange when redirecting the request.
+     * @param responseCookies Cookies received in the response
+     * @param location Redirect destination
+     */
+    _processRedirectCookies(responseCookies, location) {
+        const received = CookieParser_js_1.CookieParser.parse(this.request.url, responseCookies);
+        const forwardCookies = CookieParser_js_1.CookieParser.filterCookies(received, location);
+        const headers = new Headers_js_1.Headers(this.request.toHeadersString());
+        headers.delete('cookie');
+        if (forwardCookies.length) {
+            const parts = [];
+            forwardCookies.forEach((cookie) => {
+                parts.push(cookie.toString());
+            });
+            headers.set('cookie', parts.join('; '));
+        }
+        this.request.headers = headers.toString();
+        // let newParser = new Cookies(responseCookies, location);
+        // newParser.filter();
+        // const expired = newParser.clearExpired();
+        // const hasCookie = headers.has('cookie');
+        // if (hasCookie) {
+        //   const oldCookies = headers.get('cookie');
+        //   const oldParser = new Cookies(oldCookies, location);
+        //   oldParser.filter();
+        //   oldParser.clearExpired();
+        //   oldParser.merge(newParser);
+        //   newParser = oldParser;
+        //   // remove expired from the new response.
+        //   newParser.cookies = newParser.cookies.filter((c) => {
+        //     for (let i = 0, len = expired.length; i < len; i++) {
+        //       if (expired[i].name === c.name) {
+        //         return false;
+        //       }
+        //     }
+        //     return true;
+        //   });
+        // }
+        // const str = newParser.toString(true);
+        // if (str) {
+        //   headers.set('cookie', str);
+        // } else if (hasCookie) {
+        //   headers.delete('cookie');
+        // }
+        // this.request.headers = headers.toString();
+    }
+    /**
+     * Checks certificate identity using TLS api.
+     *
+     * @param host Request host name
+     * @param cert TLS certificate info object
+     */
+    _checkServerIdentity(host, cert) {
+        const err = tls_1.default.checkServerIdentity(host, cert);
+        if (err) {
+            return err;
+        }
+    }
+    /**
+     * Clears event listeners of the socket object,
+     */
+    _clearSocketEventListeners() {
+        if (!this.socket) {
+            return;
+        }
+        this.socket.removeAllListeners('error');
+        this.socket.removeAllListeners('timeout');
+        this.socket.removeAllListeners('end');
+    }
+    /**
+     * Adds client certificate to the request configuration options.
+     *
+     * @param certificate List of certificate configurations.
+     * @param options Request options. Cert agent options are added to this object.
+     */
+    _addClientCertificate(certificate, options) {
+        if (!certificate) {
+            return;
+        }
+        const cert = { ...certificate };
+        if (cert.type === 'p12') {
+            if (!options.pfx) {
+                options.pfx = [];
+            }
+            const struct = {
+                buf: Buffer.from(cert.cert.data),
+            };
+            if (cert.cert.passphrase) {
+                struct.passphrase = cert.cert.passphrase;
+            }
+            if (!Array.isArray(options.pfx)) {
+                if (options.pfx) {
+                    options.pfx = [options.pfx];
+                }
+                else {
+                    options.pfx = [];
+                }
+            }
+            options.pfx.push(struct);
+        }
+        else if (cert.type === 'pem') {
+            const typed = cert;
+            if (!options.cert) {
+                options.cert = [];
+            }
+            if (!Array.isArray(options.cert)) {
+                if (options.cert) {
+                    options.cert = [options.cert];
+                }
+                else {
+                    options.cert = [];
+                }
+            }
+            const added = Buffer.from(typed.cert.data);
+            options.cert.push(added);
+            if (typed.certKey) {
+                if (!Array.isArray(options.key)) {
+                    if (options.key) {
+                        options.key = [options.key];
+                    }
+                    else {
+                        options.key = [];
+                    }
+                }
+                const struct = {
+                    pem: Buffer.from(typed.certKey.data),
+                };
+                if (typed.certKey.passphrase) {
+                    struct.passphrase = typed.certKey.passphrase;
+                }
+                options.key.push(struct);
+            }
+        }
+    }
+    /**
+     * @return Proxy authorization header value, when defined.
+     */
+    _proxyAuthHeader() {
+        const { proxyUsername, proxyPassword = '' } = this.opts;
+        if (!proxyUsername) {
+            return undefined;
+        }
+        const auth = `${proxyUsername}:${proxyPassword}`;
+        const hash = Buffer.from(auth).toString('base64');
+        return `Basic ${hash}`;
+    }
+    /**
+     * Reads the raw headers from the node response and transforms them into the internal headers.
+     */
+    computeResponseHeaders(res) {
+        const headers = {};
+        for (let i = 0, len = res.rawHeaders.length; i < len; i += 2) {
+            const name = res.rawHeaders[i];
+            const value = res.rawHeaders[i + 1];
+            if (headers[name]) {
+                headers[name] += `; ${value}`;
+            }
+            else {
+                headers[name] = value;
+            }
+        }
+        return new Headers_js_1.Headers(headers);
+    }
+    /**
+     * Called with the `send()` function to initialize the main promise returned by the send function.
+     * The send function returns a promise that is resolved when the request finish.
+     */
+    wrapExecution() {
+        let promise;
+        if (this[exports.mainPromiseSymbol]) {
+            promise = this[exports.mainPromiseSymbol];
+        }
+        else {
+            promise = new Promise((resolve, reject) => {
+                this.mainResolver = resolve;
+                this.mainRejecter = reject;
+            });
+            this[exports.mainPromiseSymbol] = promise;
+        }
+        return promise;
+    }
+    /**
+     * Called by the request finalizer or error finalized to report the response.
+     *
+     * @param log Either the request execution log or an error.
+     */
+    finalizeRequest(log) {
+        const { mainRejecter, mainResolver } = this;
+        if (!mainRejecter || !mainResolver) {
+            // console.error(`Trying to finalize the request but the main resolver is not set.`);
+            return;
+        }
+        if (log instanceof SerializableError_js_1.SerializableError) {
+            mainRejecter(log);
+        }
+        else {
+            mainResolver(log.toJSON());
+        }
+        this.mainRejecter = undefined;
+        this.mainResolver = undefined;
+        this[exports.mainPromiseSymbol] = undefined;
+    }
+}
+exports.HttpEngine = HttpEngine;
+//# sourceMappingURL=HttpEngine.js.map