got 11.0.0-beta.1 → 11.0.3

package/dist/source/core/index.js

@@ -22,6 +22,7 @@ const proxy_events_1 = require("./utils/proxy-events");
 const timed_out_1 = require("./utils/timed-out");
 const url_to_options_1 = require("./utils/url-to-options");
 const options_to_url_1 = require("./utils/options-to-url");
+const weakable_map_1 = require("./utils/weakable-map");
 const kRequest = Symbol('request');
 const kResponse = Symbol('response');
 const kResponseSize = Symbol('responseSize');
@@ -33,6 +34,10 @@ const kUnproxyEvents = Symbol('unproxyEvents');
 const kIsFromCache = Symbol('isFromCache');
 const kCancelTimeouts = Symbol('cancelTimeouts');
 const kStartedReading = Symbol('startedReading');
+const kStopReading = Symbol('stopReading');
+const kTriggerRead = Symbol('triggerRead');
+const kBody = Symbol('body');
+const kJobs = Symbol('jobs');
 exports.kIsNormalizedAlready = Symbol('isNormalizedAlready');
 const supportsBrotli = is_1.default.string(process.versions.brotli);
 exports.withoutBody = new Set(['GET', 'HEAD']);
@@ -49,26 +54,7 @@ function validateSearchParameters(searchParameters) {
 function isClientRequest(clientRequest) {
     return is_1.default.object(clientRequest) && !('statusCode' in clientRequest);
 }
-const cacheFn = async (url, options) => new Promise((resolve, reject) => {
-    // TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
-    Object.assign(options, url_to_options_1.default(url));
-    // `http-cache-semantics` checks this
-    delete options.url;
-    // TODO: `cacheable-request` is incorrectly typed
-    const cacheRequest = options.cacheableRequest(options, resolve);
-    // Restore options
-    options.url = url;
-    cacheRequest.once('error', (error) => {
-        if (error instanceof CacheableRequest.RequestError) {
-            // TODO: `options` should be `normalizedOptions`
-            reject(new RequestError(error.message, error, options));
-            return;
-        }
-        // TODO: `options` should be `normalizedOptions`
-        reject(new CacheError(error, options));
-    });
-    cacheRequest.once('request', resolve);
-});
+const cacheableStore = new weakable_map_1.default();
 const waitForOpenFile = async (file) => new Promise((resolve, reject) => {
     const onError = (error) => {
         reject(error);
@@ -109,36 +95,34 @@ const setNonEnumerableProperties = (sources, to) => {
     Object.defineProperties(to, properties);
 };
 class RequestError extends Error {
-    constructor(message, error, options, requestOrResponse) {
+    constructor(message, error, self) {
         var _a;
         super(message);
         Error.captureStackTrace(this, this.constructor);
         this.name = 'RequestError';
         this.code = error.code;
-        Object.defineProperty(this, 'options', {
-            // This fails because of TS 3.7.2 useDefineForClassFields
-            // Ref: https://github.com/microsoft/TypeScript/issues/34972
-            enumerable: false,
-            value: options
-        });
-        if (requestOrResponse instanceof http_1.IncomingMessage) {
-            Object.defineProperty(this, 'response', {
+        if (self instanceof Request) {
+            Object.defineProperty(this, 'request', {
                 enumerable: false,
-                value: requestOrResponse
+                value: self
             });
-            Object.defineProperty(this, 'request', {
+            Object.defineProperty(this, 'response', {
                 enumerable: false,
-                value: requestOrResponse.request
+                value: self[kResponse]
             });
-        }
-        else if (requestOrResponse instanceof Request) {
-            Object.defineProperty(this, 'request', {
+            Object.defineProperty(this, 'options', {
+                // This fails because of TS 3.7.2 useDefineForClassFields
+                // Ref: https://github.com/microsoft/TypeScript/issues/34972
                 enumerable: false,
-                value: requestOrResponse
+                value: self.options
             });
-            Object.defineProperty(this, 'response', {
+        }
+        else {
+            Object.defineProperty(this, 'options', {
+                // This fails because of TS 3.7.2 useDefineForClassFields
+                // Ref: https://github.com/microsoft/TypeScript/issues/34972
                 enumerable: false,
-                value: requestOrResponse[kResponse]
+                value: self
             });
         }
         this.timings = (_a = this.request) === null || _a === void 0 ? void 0 : _a.timings;
@@ -157,44 +141,36 @@ class RequestError extends Error {
 }
 exports.RequestError = RequestError;
 class MaxRedirectsError extends RequestError {
-    constructor(response, maxRedirects, options) {
-        super(`Redirected ${maxRedirects} times. Aborting.`, {}, options);
+    constructor(request) {
+        super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
         this.name = 'MaxRedirectsError';
-        Object.defineProperty(this, 'response', {
-            enumerable: false,
-            value: response
-        });
     }
 }
 exports.MaxRedirectsError = MaxRedirectsError;
 class HTTPError extends RequestError {
-    constructor(response, options) {
-        super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, options);
+    constructor(response) {
+        super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);
         this.name = 'HTTPError';
-        Object.defineProperty(this, 'response', {
-            enumerable: false,
-            value: response
-        });
     }
 }
 exports.HTTPError = HTTPError;
 class CacheError extends RequestError {
-    constructor(error, options) {
-        super(error.message, error, options);
+    constructor(error, request) {
+        super(error.message, error, request);
         this.name = 'CacheError';
     }
 }
 exports.CacheError = CacheError;
 class UploadError extends RequestError {
-    constructor(error, options, request) {
-        super(error.message, error, options, request);
+    constructor(error, request) {
+        super(error.message, error, request);
         this.name = 'UploadError';
     }
 }
 exports.UploadError = UploadError;
 class TimeoutError extends RequestError {
-    constructor(error, timings, options) {
-        super(error.message, error, options);
+    constructor(error, timings, request) {
+        super(error.message, error, request);
         this.name = 'TimeoutError';
         this.event = error.event;
         this.timings = timings;
@@ -202,8 +178,8 @@ class TimeoutError extends RequestError {
 }
 exports.TimeoutError = TimeoutError;
 class ReadError extends RequestError {
-    constructor(error, options, response) {
-        super(error.message, error, options, response);
+    constructor(error, request) {
+        super(error.message, error, request);
         this.name = 'ReadError';
     }
 }
@@ -232,10 +208,12 @@ class Request extends stream_1.Duplex {
         });
         this[kDownloadedSize] = 0;
         this[kUploadedSize] = 0;
-        this.finalized = false;
+        this.requestInitialized = false;
         this[kServerResponsesPiped] = new Set();
         this.redirects = [];
-        this.errored = false;
+        this[kStopReading] = false;
+        this[kTriggerRead] = false;
+        this[kJobs] = [];
         // TODO: Remove this when targeting Node.js >= 12
         this._progressCallbacks = [];
         const unlockWrite = () => this._unlockWrite();
@@ -265,6 +243,7 @@ class Request extends stream_1.Duplex {
             this._lockWrite();
         }
         (async (nonNormalizedOptions) => {
+            var _a;
             try {
                 if (nonNormalizedOptions.body instanceof fs_1.ReadStream) {
                     await waitForOpenFile(nonNormalizedOptions.body);
@@ -284,8 +263,15 @@ class Request extends stream_1.Duplex {
                 decodeURI(this.requestUrl);
                 await this._finalizeBody();
                 await this._makeRequest();
-                this.finalized = true;
-                this.emit('finalized');
+                if (this.destroyed) {
+                    (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.abort();
+                    return;
+                }
+                // Queued writes etc.
+                for (const job of this[kJobs]) {
+                    job();
+                }
+                this.requestInitialized = true;
             }
             catch (error) {
                 if (error instanceof RequestError) {
@@ -299,6 +285,8 @@ class Request extends stream_1.Duplex {
     static normalizeArguments(url, options, defaults) {
         var _a, _b, _c, _d;
         const rawOptions = options;
+        const searchParameters = options === null || options === void 0 ? void 0 : options.searchParams;
+        const hooks = options === null || options === void 0 ? void 0 : options.hooks;
         if (is_1.default.object(url) && !is_1.default.urlInstance(url)) {
             options = { ...defaults, ...url, ...options };
         }
@@ -311,6 +299,20 @@ class Request extends stream_1.Duplex {
                 options.url = url;
             }
         }
+        // Prevent duplicating default search params & hooks
+        if (searchParameters === undefined) {
+            delete options.searchParams;
+        }
+        else {
+            options.searchParams = searchParameters;
+        }
+        if (hooks === undefined) {
+            delete options.hooks;
+        }
+        else {
+            options.hooks = hooks;
+        }
+        // Setting options to `undefined` turns off its functionalities
         if (rawOptions && defaults) {
             for (const key in rawOptions) {
                 // @ts-ignore Dear TypeScript, all object keys are strings (or symbols which are NOT enumerable).
@@ -354,8 +356,11 @@ class Request extends stream_1.Duplex {
         if (is_1.default.undefined(options.headers)) {
             options.headers = {};
         }
+        else if (options.headers === (defaults === null || defaults === void 0 ? void 0 : defaults.headers)) {
+            options.headers = { ...options.headers };
+        }
         else {
-            options.headers = lowercaseKeys({ ...((_a = defaults) === null || _a === void 0 ? void 0 : _a.headers), ...options.headers });
+            options.headers = lowercaseKeys({ ...(defaults === null || defaults === void 0 ? void 0 : defaults.headers), ...options.headers });
         }
         // Disallow legacy `url.Url`
         if ('slashes' in options) {
@@ -365,6 +370,23 @@ class Request extends stream_1.Duplex {
         if ('auth' in options) {
             throw new TypeError('Parameter `auth` is deprecated. Use `username` / `password` instead.');
         }
+        // `options.searchParams`
+        if (options.searchParams) {
+            if (!is_1.default.string(options.searchParams) && !(options.searchParams instanceof url_1.URLSearchParams)) {
+                validateSearchParameters(options.searchParams);
+            }
+            options.searchParams = new url_1.URLSearchParams(options.searchParams);
+            // `normalizeArguments()` is also used to merge options
+            (_a = defaults === null || defaults === void 0 ? void 0 : defaults.searchParams) === null || _a === void 0 ? void 0 : _a.forEach((value, key) => {
+                options.searchParams.append(key, value);
+            });
+        }
+        else {
+            options.searchParams = defaults === null || defaults === void 0 ? void 0 : defaults.searchParams;
+        }
+        // `options.username` & `options.password`
+        options.username = (_b = options.username) !== null && _b !== void 0 ? _b : '';
+        options.password = (_c = options.password) !== null && _c !== void 0 ? _c : '';
         // `options.prefixUrl` & `options.url`
         if (options.prefixUrl) {
             options.prefixUrl = options.prefixUrl.toString();
@@ -398,65 +420,52 @@ class Request extends stream_1.Duplex {
                 },
                 get: () => prefixUrl
             });
-            // Protocol check
+            // Support UNIX sockets
             let { protocol } = options.url;
             if (protocol === 'unix:') {
                 protocol = 'http:';
                 options.url = new url_1.URL(`http://unix${options.url.pathname}${options.url.search}`);
             }
+            // Set search params
+            if (options.searchParams) {
+                options.url.search = options.searchParams.toString();
+            }
+            // Trigger search params normalization
             if (options.url.search) {
                 const triggerSearchParameters = '_GOT_INTERNAL_TRIGGER_NORMALIZATION';
                 options.url.searchParams.append(triggerSearchParameters, '');
                 options.url.searchParams.delete(triggerSearchParameters);
             }
+            // Protocol check
             if (protocol !== 'http:' && protocol !== 'https:') {
                 throw new UnsupportedProtocolError(options);
             }
-        }
-        // `options.username` & `options.password`
-        options.username = (_b = options.username, (_b !== null && _b !== void 0 ? _b : ''));
-        options.password = (_c = options.password, (_c !== null && _c !== void 0 ? _c : ''));
-        if (options.url) {
+            // Update `username` & `password`
             options.url.username = options.username;
             options.url.password = options.password;
         }
         // `options.cookieJar`
-        if (options.cookieJar) {
-            let { setCookie, getCookieString } = options.cookieJar;
-            // Horrible `tough-cookie` check
+        const { cookieJar } = options;
+        if (cookieJar) {
+            let { setCookie, getCookieString } = cookieJar;
+            is_1.assert.function_(setCookie);
+            is_1.assert.function_(getCookieString);
+            /* istanbul ignore next: Horrible `tough-cookie` v3 check */
             if (setCookie.length === 4 && getCookieString.length === 0) {
                 setCookie = util_1.promisify(setCookie.bind(options.cookieJar));
                 getCookieString = util_1.promisify(getCookieString.bind(options.cookieJar));
-            }
-            else if (setCookie.length !== 2) {
-                throw new TypeError('`options.cookieJar.setCookie` needs to be an async function with 2 arguments');
-            }
-            else if (getCookieString.length !== 1) {
-                throw new TypeError('`options.cookieJar.getCookieString` needs to be an async function with 1 argument');
-            }
-            options.cookieJar = { setCookie, getCookieString };
-        }
-        // `options.searchParams`
-        if (options.searchParams) {
-            if (!is_1.default.string(options.searchParams) && !(options.searchParams instanceof url_1.URLSearchParams)) {
-                validateSearchParameters(options.searchParams);
-            }
-            options.searchParams = new url_1.URLSearchParams(options.searchParams);
-            // `normalizeArguments()` is also used to merge options
-            const defaultsAsOptions = defaults;
-            if (defaultsAsOptions && defaultsAsOptions.searchParams instanceof url_1.URLSearchParams) {
-                defaultsAsOptions.searchParams.forEach((value, key) => {
-                    options.searchParams.append(key, value);
-                });
-            }
-            if (options.url) {
-                options.url.search = options.searchParams.toString();
+                options.cookieJar = {
+                    setCookie,
+                    getCookieString
+                };
             }
         }
         // `options.cache`
-        if (options.cache && !options.cacheableRequest) {
-            // Better memory management, so we don't have to generate a new object every time
-            options.cacheableRequest = new CacheableRequest(((requestOptions, handler) => requestOptions[kRequest](requestOptions, handler)), options.cache);
+        const { cache } = options;
+        if (cache) {
+            if (!cacheableStore.has(cache)) {
+                cacheableStore.set(cache, new CacheableRequest(((requestOptions, handler) => requestOptions[kRequest](requestOptions, handler)), cache));
+            }
         }
         // `options.dnsCache`
         if (options.dnsCache === true) {
@@ -469,7 +478,7 @@ class Request extends stream_1.Duplex {
         if (is_1.default.number(options.timeout)) {
             options.timeout = { request: options.timeout };
         }
-        else if (defaults) {
+        else if (defaults && options.timeout !== defaults.timeout) {
             options.timeout = {
                 ...defaults.timeout,
                 ...options.timeout
@@ -521,7 +530,7 @@ class Request extends stream_1.Duplex {
                 }
             }
         }
-        options.maxRedirects = (_d = options.maxRedirects, (_d !== null && _d !== void 0 ? _d : 0));
+        options.maxRedirects = (_d = options.maxRedirects) !== null && _d !== void 0 ? _d : 0;
         // Set non-enumerable properties
         setNonEnumerableProperties([defaults, options], options);
         return options;
@@ -571,20 +580,21 @@ class Request extends stream_1.Duplex {
                     if (is_form_data_1.default(options.body) && noContentType) {
                         headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
                     }
+                    this[kBody] = options.body;
                 }
                 else if (isForm) {
                     if (noContentType) {
                         headers['content-type'] = 'application/x-www-form-urlencoded';
                     }
-                    options.body = (new url_1.URLSearchParams(options.form)).toString();
+                    this[kBody] = (new url_1.URLSearchParams(options.form)).toString();
                 }
                 else {
                     if (noContentType) {
                         headers['content-type'] = 'application/json';
                     }
-                    options.body = JSON.stringify(options.json);
+                    this[kBody] = JSON.stringify(options.json);
                 }
-                const uploadBodySize = await get_body_size_1.default(options);
+                const uploadBodySize = await get_body_size_1.default(this[kBody], options.headers);
                 // See https://tools.ietf.org/html/rfc7230#section-3.3.2
                 // A user agent SHOULD send a Content-Length in a request message when
                 // no Transfer-Encoding is sent and the request method defines a meaning
@@ -617,7 +627,7 @@ class Request extends stream_1.Duplex {
         }
         const statusCode = response.statusCode;
         const typedResponse = response;
-        typedResponse.statusMessage = typedResponse.statusMessage === '' ? http.STATUS_CODES[statusCode] : typedResponse.statusMessage;
+        typedResponse.statusMessage = typedResponse.statusMessage ? typedResponse.statusMessage : http.STATUS_CODES[statusCode];
         typedResponse.url = options.url.toString();
         typedResponse.requestUrl = this.requestUrl;
         typedResponse.redirectUrls = this.redirects;
@@ -631,8 +641,17 @@ class Request extends stream_1.Duplex {
             this[kResponseSize] = this[kDownloadedSize];
             this.emit('downloadProgress', this.downloadProgress);
         });
-        response.on('error', (error) => {
-            this._beforeError(new ReadError(error, options, response));
+        response.once('error', (error) => {
+            this._beforeError(new ReadError(error, this));
+        });
+        response.once('aborted', () => {
+            if (this.aborted) {
+                return;
+            }
+            this._beforeError(new ReadError({
+                name: 'Error',
+                message: 'The server aborted the pending request'
+            }, this));
         });
         this.emit('downloadProgress', this.downloadProgress);
         const rawCookies = response.headers['set-cookie'];
@@ -676,7 +695,7 @@ class Request extends stream_1.Duplex {
                 }
             }
             if (this.redirects.length >= options.maxRedirects) {
-                this._beforeError(new MaxRedirectsError(typedResponse, options.maxRedirects, options));
+                this._beforeError(new MaxRedirectsError(this));
                 return;
             }
             try {
@@ -716,14 +735,13 @@ class Request extends stream_1.Duplex {
         const limitStatusCode = options.followRedirect ? 299 : 399;
         const isOk = (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
         if (options.throwHttpErrors && !isOk) {
-            await this._beforeError(new HTTPError(typedResponse, options));
+            await this._beforeError(new HTTPError(typedResponse));
             if (this.destroyed) {
                 return;
             }
         }
-        // We need to call `_read()` only when the Request stream is flowing
         response.on('readable', () => {
-            if (this.readableFlowing) {
+            if (this[kTriggerRead]) {
                 this._read();
             }
         });
@@ -762,10 +780,10 @@ class Request extends stream_1.Duplex {
         });
         request.once('error', (error) => {
             if (error instanceof timed_out_1.TimeoutError) {
-                error = new TimeoutError(error, this.timings, options);
+                error = new TimeoutError(error, this.timings, this);
             }
             else {
-                error = new RequestError(error.message, error, options, this);
+                error = new RequestError(error.message, error, this);
             }
             this._beforeError(error);
         });
@@ -773,20 +791,21 @@ class Request extends stream_1.Duplex {
         this[kRequest] = request;
         this.emit('uploadProgress', this.uploadProgress);
         // Send body
+        const body = this[kBody];
         const currentRequest = this.redirects.length === 0 ? this : request;
-        if (is_1.default.nodeStream(options.body)) {
-            options.body.pipe(currentRequest);
-            options.body.once('error', (error) => {
-                this._beforeError(new UploadError(error, options, this));
+        if (is_1.default.nodeStream(body)) {
+            body.pipe(currentRequest);
+            body.once('error', (error) => {
+                this._beforeError(new UploadError(error, this));
             });
-            options.body.once('end', () => {
+            body.once('end', () => {
                 delete options.body;
             });
         }
         else {
             this._unlockWrite();
-            if (!is_1.default.undefined(options.body)) {
-                this._writeRequest(options.body, null, () => { });
+            if (!is_1.default.undefined(body)) {
+                this._writeRequest(body, null, () => { });
                 currentRequest.end();
                 this._lockWrite();
             }
@@ -797,8 +816,28 @@ class Request extends stream_1.Duplex {
         }
         this.emit('request', request);
     }
+    async _createCacheableRequest(url, options) {
+        return new Promise((resolve, reject) => {
+            // TODO: Remove `utils/url-to-options.ts` when `cacheable-request` is fixed
+            Object.assign(options, url_to_options_1.default(url));
+            // `http-cache-semantics` checks this
+            delete options.url;
+            // This is ugly
+            const cacheRequest = cacheableStore.get(options.cache)(options, resolve);
+            // Restore options
+            options.url = url;
+            cacheRequest.once('error', (error) => {
+                if (error instanceof CacheableRequest.CacheError) {
+                    reject(new CacheError(error, this));
+                    return;
+                }
+                reject(error);
+            });
+            cacheRequest.once('request', resolve);
+        });
+    }
     async _makeRequest() {
-        var _a, _b;
+        var _a;
         const { options } = this;
         const { url, headers, request, agent, timeout } = options;
         for (const key in headers) {
@@ -835,7 +874,7 @@ class Request extends stream_1.Duplex {
         // UNIX sockets
         if (url.hostname === 'unix') {
             const matches = /(?<socketPath>.+?):(?<path>.+)/.exec(`${url.pathname}${url.search}`);
-            if ((_a = matches) === null || _a === void 0 ? void 0 : _a.groups) {
+            if (matches === null || matches === void 0 ? void 0 : matches.groups) {
                 const { socketPath, path } = matches.groups;
                 Object.assign(options, {
                     socketPath,
@@ -852,8 +891,8 @@ class Request extends stream_1.Duplex {
         else {
             fallbackFn = isHttps ? https.request : http.request;
         }
-        const realFn = (_b = options.request, (_b !== null && _b !== void 0 ? _b : fallbackFn));
-        const fn = options.cacheableRequest ? cacheFn : realFn;
+        const realFn = (_a = options.request) !== null && _a !== void 0 ? _a : fallbackFn;
+        const fn = options.cache ? this._createCacheableRequest.bind(this) : realFn;
         if (agent && !options.http2) {
             options.agent = agent[isHttps ? 'https' : 'http'];
         }
@@ -890,21 +929,20 @@ class Request extends stream_1.Duplex {
             if (error instanceof RequestError) {
                 throw error;
             }
-            throw new RequestError(error.message, error, options, this);
+            throw new RequestError(error.message, error, this);
         }
     }
     async _beforeError(error) {
-        this.errored = true;
+        this[kStopReading] = true;
         if (!(error instanceof RequestError)) {
-            error = new RequestError(error.message, error, this.options, this);
+            error = new RequestError(error.message, error, this);
         }
         try {
             const { response } = error;
-            if (response && is_1.default.undefined(response.body)) {
-                response.body = await getStream(response, {
-                    ...this.options,
-                    encoding: this._readableState.encoding
-                });
+            if (response) {
+                response.setEncoding(this._readableState.encoding);
+                response.rawBody = await getStream.buffer(response);
+                response.body = response.rawBody.toString();
             }
         }
         catch (_) { }
@@ -915,14 +953,21 @@ class Request extends stream_1.Duplex {
             }
         }
         catch (error_) {
-            error = new RequestError(error_.message, error_, this.options, this);
+            error = new RequestError(error_.message, error_, this);
         }
         this.destroy(error);
     }
     _read() {
-        if (kResponse in this && !this.errored) {
+        this[kTriggerRead] = true;
+        const response = this[kResponse];
+        if (response && !this[kStopReading]) {
+            // We cannot put this in the `if` above
+            // because `.read()` also triggers the `end` event
+            if (response.readableLength) {
+                this[kTriggerRead] = false;
+            }
             let data;
-            while ((data = this[kResponse].read()) !== null) {
+            while ((data = response.read()) !== null) {
                 this[kDownloadedSize] += data.length;
                 this[kStartedReading] = true;
                 const progress = this.downloadProgress;
@@ -937,11 +982,11 @@ class Request extends stream_1.Duplex {
         const write = () => {
             this._writeRequest(chunk, encoding, callback);
         };
-        if (this.finalized) {
+        if (this.requestInitialized) {
             write();
         }
         else {
-            this.once('finalized', write);
+            this[kJobs].push(write);
         }
     }
     _writeRequest(chunk, encoding, callback) {
@@ -952,6 +997,7 @@ class Request extends stream_1.Duplex {
                 this.emit('uploadProgress', progress);
             }
         });
+        // TODO: What happens if it's from cache? Then this[kRequest] won't be defined.
         this[kRequest].write(chunk, encoding, (error) => {
             if (!error && this._progressCallbacks.length !== 0) {
                 this._progressCallbacks.shift()();
@@ -980,26 +1026,26 @@ class Request extends stream_1.Duplex {
                 callback(error);
             });
         };
-        if (this.finalized) {
+        if (this.requestInitialized) {
             endRequest();
         }
         else {
-            this.once('finalized', endRequest);
+            this[kJobs].push(endRequest);
         }
     }
     _destroy(error, callback) {
+        var _a;
         if (kRequest in this) {
-            this[kRequest].abort();
-        }
-        else {
-            this.once('finalized', () => {
-                if (kRequest in this) {
-                    this[kRequest].abort();
-                }
-            });
+            this[kCancelTimeouts]();
+            // TODO: Remove the next `if` when these get fixed:
+            // - https://github.com/nodejs/node/issues/32851
+            // - https://github.com/nock/nock/issues/1981
+            if (!((_a = this[kResponse]) === null || _a === void 0 ? void 0 : _a.complete) && !this[kRequest].destroyed) {
+                this[kRequest].abort();
+            }
         }
         if (error !== null && !is_1.default.undefined(error) && !(error instanceof RequestError)) {
-            error = new RequestError(error.message, error, this.options, this);
+            error = new RequestError(error.message, error, this);
         }
         callback(error);
     }
@@ -1011,6 +1057,10 @@ class Request extends stream_1.Duplex {
         var _a;
         return Boolean((_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.aborted);
     }
+    get socket() {
+        var _a;
+        return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.socket;
+    }
     get downloadProgress() {
         let percent;
         if (this[kResponseSize]) {