got 11.0.0-beta.1 → 11.0.0

package/dist/source/as-promise/core.d.ts

@@ -1,14 +1,13 @@
 /// <reference types="node" />
 import { URL } from 'url';
-import { Options, NormalizedOptions, Defaults, ResponseType } from './types';
-import Request, { RequestError } from '../core';
+import { Options, NormalizedOptions, Defaults, ResponseType, Response } from './types';
+import Request from '../core';
 export declare const knownBodyTypes: string[];
-export declare const parseBody: (body: Buffer, responseType: ResponseType, encoding?: string | undefined) => unknown;
+export declare const parseBody: (response: Response<unknown>, responseType: ResponseType, encoding?: string | undefined) => unknown;
 export default class PromisableRequest extends Request {
     ['constructor']: typeof PromisableRequest;
     options: NormalizedOptions;
-    _throwHttpErrors: boolean;
     static normalizeArguments(url?: string | URL, nonNormalizedOptions?: Options, defaults?: Defaults): NormalizedOptions;
     static mergeOptions(...sources: Options[]): NormalizedOptions;
-    _beforeError(error: RequestError): Promise<void>;
+    _beforeError(error: Error): Promise<void>;
 }

package/dist/source/as-promise/core.js

@@ -1,24 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_1 = require("@sindresorhus/is");
+const types_1 = require("./types");
 const core_1 = require("../core");
 if (!core_1.knownHookEvents.includes('beforeRetry')) {
     core_1.knownHookEvents.push('beforeRetry', 'afterResponse');
 }
 exports.knownBodyTypes = ['json', 'buffer', 'text'];
 // @ts-ignore The error is: Not all code paths return a value.
-exports.parseBody = (body, responseType, encoding) => {
-    if (responseType === 'text') {
-        return body.toString(encoding);
-    }
-    if (responseType === 'json') {
-        return body.length === 0 ? '' : JSON.parse(body.toString());
-    }
-    if (responseType === 'buffer') {
-        return Buffer.from(body);
+exports.parseBody = (response, responseType, encoding) => {
+    const { rawBody } = response;
+    try {
+        if (responseType === 'text') {
+            return rawBody.toString(encoding);
+        }
+        if (responseType === 'json') {
+            return rawBody.length === 0 ? '' : JSON.parse(rawBody.toString());
+        }
+        if (responseType === 'buffer') {
+            return Buffer.from(rawBody);
+        }
+        if (!exports.knownBodyTypes.includes(responseType)) {
+            throw new TypeError(`Unknown body type '${responseType}'`);
+        }
     }
-    if (!exports.knownBodyTypes.includes(responseType)) {
-        throw new TypeError(`Unknown body type '${responseType}'`);
+    catch (error) {
+        throw new types_1.ParseError(error, response);
     }
 };
 class PromisableRequest extends core_1.default {
@@ -83,6 +90,10 @@ class PromisableRequest extends core_1.default {
                 throw new Error('`options.pagination.paginate` must be implemented');
             }
         }
+        // JSON mode
+        if (options.responseType === 'json' && options.headers.accept === undefined) {
+            options.headers.accept = 'application/json';
+        }
         return options;
     }
     static mergeOptions(...sources) {
@@ -93,7 +104,9 @@ class PromisableRequest extends core_1.default {
         return mergedOptions;
     }
     async _beforeError(error) {
-        const isHTTPError = error instanceof core_1.HTTPError;
+        if (!(error instanceof core_1.RequestError)) {
+            error = new core_1.RequestError(error.message, error, this);
+        }
         try {
             for (const hook of this.options.hooks.beforeError) {
                 // eslint-disable-next-line no-await-in-loop
@@ -101,15 +114,11 @@ class PromisableRequest extends core_1.default {
             }
         }
         catch (error_) {
-            this.destroy(error_);
+            this.destroy(new core_1.RequestError(error_.message, error_, this));
             return;
         }
-        if (this._throwHttpErrors && !isHTTPError) {
-            this.destroy(error);
-        }
-        else {
-            this.emit('error', error);
-        }
+        // Let the promise decide whether to abort or not
+        this.emit('error', error);
     }
 }
 exports.default = PromisableRequest;

package/dist/source/as-promise/index.js

@@ -20,22 +20,23 @@ const proxiedRequestEvents = [
 ];
 function asPromise(options) {
     let retryCount = 0;
-    let body;
+    let globalRequest;
+    let globalResponse;
     const emitter = new events_1.EventEmitter();
     const promise = new PCancelable((resolve, reject, onCancel) => {
         const makeRequest = () => {
-            if (options.responseType === 'json' && options.headers.accept === undefined) {
-                options.headers.accept = 'application/json';
-            }
             // Support retries
+            // `options.throwHttpErrors` needs to be always true,
+            // so the HTTP errors are caught and the request is retried.
+            // The error is **eventually** thrown if the user value is true.
             const { throwHttpErrors } = options;
             if (!throwHttpErrors) {
                 options.throwHttpErrors = true;
             }
             const request = new core_1.default(options.url, options);
-            request._throwHttpErrors = throwHttpErrors;
             request._noPipe = true;
             onCancel(() => request.destroy());
+            globalRequest = request;
             request.once('response', async (response) => {
                 response.retryCount = retryCount;
                 if (response.request.aborted) {
@@ -48,23 +49,24 @@ function asPromise(options) {
                     return (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
                 };
                 // Download body
+                let rawBody;
                 try {
-                    body = await getStream.buffer(request);
+                    rawBody = await getStream.buffer(request);
+                    response.rawBody = rawBody;
                 }
                 catch (error) {
-                    request._beforeError(new types_1.ReadError(error, options, response));
+                    request._beforeError(new types_1.ReadError(error, request));
                     return;
                 }
                 // Parse body
                 try {
-                    response.body = core_1.parseBody(body, options.responseType, options.encoding);
+                    response.body = core_1.parseBody(response, options.responseType, options.encoding);
                 }
                 catch (error) {
                     // Fallback to `utf8`
-                    response.body = body.toString('utf8');
+                    response.body = rawBody.toString();
                     if (isOk()) {
-                        const parseError = new types_1.ParseError(error, response, options);
-                        request._beforeError(parseError);
+                        request._beforeError(error);
                         return;
                     }
                 }
@@ -103,9 +105,10 @@ function asPromise(options) {
                     return;
                 }
                 if (throwHttpErrors && !isOk()) {
-                    reject(new types_1.HTTPError(response, options));
+                    reject(new types_1.HTTPError(response));
                     return;
                 }
+                globalResponse = response;
                 resolve(options.resolveBodyOnly ? response.body : response);
             });
             request.once('error', (error) => {
@@ -134,7 +137,7 @@ function asPromise(options) {
                 catch (error_) {
                     // Don't emit the `response` event
                     request.destroy();
-                    reject(new types_1.RequestError(error_.message, error, request.options));
+                    reject(new types_1.RequestError(error_.message, error, request));
                     return;
                 }
                 if (backoff) {
@@ -151,7 +154,7 @@ function asPromise(options) {
                         catch (error_) {
                             // Don't emit the `response` event
                             request.destroy();
-                            reject(new types_1.RequestError(error_.message, error, request.options));
+                            reject(new types_1.RequestError(error_.message, error, request));
                             return;
                         }
                         makeRequest();
@@ -179,14 +182,15 @@ function asPromise(options) {
     };
     const shortcut = (responseType) => {
         const newPromise = (async () => {
+            // Wait until downloading has ended
             await promise;
-            return core_1.parseBody(body, responseType);
+            return core_1.parseBody(globalResponse, responseType, options.encoding);
         })();
         Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
         return newPromise;
     };
     promise.json = () => {
-        if (body === undefined && options.headers.accept === undefined) {
+        if (!globalRequest.writableFinished && options.headers.accept === undefined) {
             options.headers.accept = 'application/json';
         }
         return shortcut('json');

package/dist/source/as-promise/types.d.ts

@@ -64,7 +64,7 @@ export interface Defaults extends RequestDefaults {
 }
 export declare class ParseError extends RequestError {
     readonly response: Response;
-    constructor(error: Error, response: Response, options: NormalizedOptions);
+    constructor(error: Error, response: Response);
 }
 export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
     json<ReturnType>(): CancelableRequest<ReturnType>;

package/dist/source/as-promise/types.js

@@ -14,8 +14,9 @@ exports.HTTPError = core_1.HTTPError;
 exports.ReadError = core_1.ReadError;
 exports.UnsupportedProtocolError = core_1.UnsupportedProtocolError;
 class ParseError extends core_1.RequestError {
-    constructor(error, response, options) {
-        super(`${error.message} in "${options.url.toString()}"`, error, options);
+    constructor(error, response) {
+        const { options } = response.request;
+        super(`${error.message} in "${options.url.toString()}"`, error, response.request);
         this.name = 'ParseError';
         Object.defineProperty(this, 'response', {
             enumerable: false,

package/dist/source/core/index.d.ts

@@ -25,6 +25,8 @@ declare const kUnproxyEvents: unique symbol;
 declare const kIsFromCache: unique symbol;
 declare const kCancelTimeouts: unique symbol;
 declare const kStartedReading: unique symbol;
+declare const kStopReading: unique symbol;
+declare const kTriggerRead: unique symbol;
 export declare const kIsNormalizedAlready: unique symbol;
 export interface Agents {
     http?: http.Agent;
@@ -120,7 +122,6 @@ export interface NormalizedOptions extends Options {
     cache?: string | CacheableRequest.StorageAdapter;
     throwHttpErrors: boolean;
     dnsCache?: CacheableLookup;
-    cacheableRequest?: (options: string | URL | http.RequestOptions, callback?: (response: http.ServerResponse | ResponseLike) => void) => CacheableRequest.Emitter;
     http2: boolean;
     allowGetBody: boolean;
     rejectUnauthorized: boolean;
@@ -174,6 +175,7 @@ export interface PlainResponse extends IncomingMessageWithTimings {
 }
 export interface Response<T = unknown> extends PlainResponse {
     body: T;
+    rawBody: Buffer;
     retryCount: number;
 }
 export interface RequestEvents<T> {
@@ -191,29 +193,29 @@ export declare class RequestError extends Error {
     readonly timings?: Timings;
     constructor(message: string, error: Partial<Error & {
         code?: string;
-    }>, options: NormalizedOptions, requestOrResponse?: Request | Response);
+    }>, self: Request | NormalizedOptions);
 }
 export declare class MaxRedirectsError extends RequestError {
     readonly response: Response;
-    constructor(response: Response, maxRedirects: number, options: NormalizedOptions);
+    constructor(request: Request);
 }
 export declare class HTTPError extends RequestError {
     readonly response: Response;
-    constructor(response: Response, options: NormalizedOptions);
+    constructor(response: Response);
 }
 export declare class CacheError extends RequestError {
-    constructor(error: Error, options: NormalizedOptions);
+    constructor(error: Error, request: Request);
 }
 export declare class UploadError extends RequestError {
-    constructor(error: Error, options: NormalizedOptions, request: Request);
+    constructor(error: Error, request: Request);
 }
 export declare class TimeoutError extends RequestError {
     readonly timings: Timings;
     readonly event: string;
-    constructor(error: TimedOutTimeoutError, timings: Timings, options: NormalizedOptions);
+    constructor(error: TimedOutTimeoutError, timings: Timings, request: Request);
 }
 export declare class ReadError extends RequestError {
-    constructor(error: Error, options: NormalizedOptions, response: Response);
+    constructor(error: Error, request: Request);
 }
 export declare class UnsupportedProtocolError extends RequestError {
     constructor(options: NormalizedOptions);
@@ -224,6 +226,8 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     _cannotHaveBody: boolean;
     [kDownloadedSize]: number;
     [kUploadedSize]: number;
+    [kStopReading]: boolean;
+    [kTriggerRead]: boolean;
     [kBodySize]?: number;
     [kServerResponsesPiped]: Set<ServerResponse>;
     [kIsFromCache]?: boolean;
@@ -238,7 +242,6 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     requestUrl: string;
     finalized: boolean;
     redirects: string[];
-    errored: boolean;
     constructor(url: string | URL, options?: Options, defaults?: Defaults);
     static normalizeArguments(url?: string | URL, options?: Options, defaults?: Defaults): NormalizedOptions;
     _lockWrite(): void;
@@ -246,6 +249,7 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     _finalizeBody(): Promise<void>;
     _onResponse(response: IncomingMessage): Promise<void>;
     _onRequest(request: ClientRequest): void;
+    _createCacheableRequest(url: URL, options: RequestOptions): Promise<ClientRequest | ResponseLike>;
     _makeRequest(): Promise<void>;
     _beforeError(error: Error): Promise<void>;
     _read(): void;
@@ -255,6 +259,7 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     _destroy(error: Error | null, callback: (error: Error | null) => void): void;
     get ip(): string | undefined;
     get aborted(): boolean;
+    get socket(): Socket | undefined;
     get downloadProgress(): Progress;
     get uploadProgress(): Progress;
     get timings(): Timings | undefined;

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,8 @@ const kUnproxyEvents = Symbol('unproxyEvents');
 const kIsFromCache = Symbol('isFromCache');
 const kCancelTimeouts = Symbol('cancelTimeouts');
 const kStartedReading = Symbol('startedReading');
+const kStopReading = Symbol('stopReading');
+const kTriggerRead = Symbol('triggerRead');
 exports.kIsNormalizedAlready = Symbol('isNormalizedAlready');
 const supportsBrotli = is_1.default.string(process.versions.brotli);
 exports.withoutBody = new Set(['GET', 'HEAD']);
@@ -49,26 +52,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 +93,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 +139,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 +176,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';
     }
 }
@@ -235,7 +209,8 @@ class Request extends stream_1.Duplex {
         this.finalized = false;
         this[kServerResponsesPiped] = new Set();
         this.redirects = [];
-        this.errored = false;
+        this[kStopReading] = false;
+        this[kTriggerRead] = false;
         // TODO: Remove this when targeting Node.js >= 12
         this._progressCallbacks = [];
         const unlockWrite = () => this._unlockWrite();
@@ -421,20 +396,20 @@ class Request extends stream_1.Duplex {
             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));
+                options.cookieJar = {
+                    setCookie: setCookie.bind(cookieJar),
+                    getCookieString: getCookieString.bind(getCookieString)
+                };
             }
-            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) {
@@ -454,9 +429,11 @@ class Request extends stream_1.Duplex {
             }
         }
         // `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) {
@@ -632,7 +609,16 @@ class Request extends stream_1.Duplex {
             this.emit('downloadProgress', this.downloadProgress);
         });
         response.on('error', (error) => {
-            this._beforeError(new ReadError(error, options, response));
+            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 +662,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 +702,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 +747,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);
         });
@@ -777,7 +762,7 @@ class Request extends stream_1.Duplex {
         if (is_1.default.nodeStream(options.body)) {
             options.body.pipe(currentRequest);
             options.body.once('error', (error) => {
-                this._beforeError(new UploadError(error, options, this));
+                this._beforeError(new UploadError(error, this));
             });
             options.body.once('end', () => {
                 delete options.body;
@@ -797,6 +782,26 @@ 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;
         const { options } = this;
@@ -853,7 +858,7 @@ class Request extends stream_1.Duplex {
             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 fn = options.cache ? this._createCacheableRequest.bind(this) : realFn;
         if (agent && !options.http2) {
             options.agent = agent[isHttps ? 'https' : 'http'];
         }
@@ -890,21 +895,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 +919,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;
@@ -988,8 +999,12 @@ class Request extends stream_1.Duplex {
         }
     }
     _destroy(error, callback) {
+        var _a;
         if (kRequest in this) {
-            this[kRequest].abort();
+            // TODO: Remove the next `if` when https://github.com/nodejs/node/issues/32851 gets fixed
+            if (!((_a = this[kResponse]) === null || _a === void 0 ? void 0 : _a.complete)) {
+                this[kRequest].abort();
+            }
         }
         else {
             this.once('finalized', () => {
@@ -999,7 +1014,7 @@ class Request extends stream_1.Duplex {
             });
         }
         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 +1026,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]) {

package/dist/source/core/utils/weakable-map.d.ts

@@ -0,0 +1,8 @@
+export default class WeakableMap<K, V> {
+    weakMap: WeakMap<object, V>;
+    map: Map<K, V>;
+    constructor();
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+}

package/dist/source/core/utils/weakable-map.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class WeakableMap {
+    constructor() {
+        this.weakMap = new WeakMap();
+        this.map = new Map();
+    }
+    set(key, value) {
+        if (typeof key === 'object') {
+            this.weakMap.set(key, value);
+        }
+        else {
+            this.map.set(key, value);
+        }
+    }
+    get(key) {
+        if (typeof key === 'object') {
+            return this.weakMap.get(key);
+        }
+        return this.map.get(key);
+    }
+    has(key) {
+        if (typeof key === 'object') {
+            return this.weakMap.has(key);
+        }
+        return this.map.has(key);
+    }
+}
+exports.default = WeakableMap;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "got",
-	"version": "11.0.0-beta.1",
+	"version": "11.0.0",
 	"description": "Human-friendly and powerful HTTP request library for Node.js",
 	"license": "MIT",
 	"repository": "sindresorhus/got",
@@ -66,7 +66,7 @@
 		"@types/node-fetch": "^2.5.5",
 		"@types/request": "^2.48.4",
 		"@types/sinon": "^9.0.0",
-		"@types/tough-cookie": "^2.3.5",
+		"@types/tough-cookie": "^4.0.0",
 		"@typescript-eslint/eslint-plugin": "^2.27.0",
 		"@typescript-eslint/parser": "^2.27.0",
 		"ava": "^3.6.0",
@@ -89,7 +89,7 @@
 		"slow-stream": "0.0.4",
 		"tempy": "^0.5.0",
 		"to-readable-stream": "^2.1.0",
-		"tough-cookie": "^3.0.0",
+		"tough-cookie": "^4.0.0",
 		"typescript": "3.7.5",
 		"xo": "^0.29.0"
 	},

package/readme.md

@@ -784,6 +784,12 @@ Type: `string | object | Buffer` *(Depending on `options.responseType`)*
 
 The result of the request.
 
+##### rawBody
+
+Type: `Buffer`
+
+The raw result of the request.
+
 ##### url
 
 Type: `string`
@@ -934,6 +940,10 @@ The same as `response.timings`.
 
 The same as `response.isFromCache`.
 
+##### .socket
+
+The same as `response.socket`.
+
 ##### .on('error', error)
 
 The emitted `error` is an instance of [`RequestError`](#got.requesterror).
@@ -1039,7 +1049,7 @@ const mergedHandlers = got.extend({
 
 ```js
 const handler = (options, next) => {
-	if (options.stream) {
+	if (options.isStream) {
 		// It's a Stream
 		return next(options);
 	}
@@ -1311,7 +1321,7 @@ stream.destroy();
 <a name="cache-adapters"></a>
 ## Cache
 
-Got implements [RFC 7234](http://httpwg.org/specs/rfc7234.html) compliant HTTP caching which works out of the box in-memory and is easily pluggable with a wide range of storage adapters. Fresh cache entries are served directly from the cache, and stale cache entries are revalidated with `If-None-Match`/`If-Modified-Since` headers. You can read more about the underlying cache behavior in the [`cacheable-request` documentation](https://github.com/lukechilds/cacheable-request). For DNS cache, Got uses [`cacheable-lookup`](https://github.com/szmarczak/cacheable-lookup).
+Got implements [RFC 7234](https://httpwg.org/specs/rfc7234.html) compliant HTTP caching which works out of the box in-memory and is easily pluggable with a wide range of storage adapters. Fresh cache entries are served directly from the cache, and stale cache entries are revalidated with `If-None-Match`/`If-Modified-Since` headers. You can read more about the underlying cache behavior in the [`cacheable-request` documentation](https://github.com/lukechilds/cacheable-request). For DNS cache, Got uses [`cacheable-lookup`](https://github.com/szmarczak/cacheable-lookup).
 
 You can use the JavaScript `Map` type as an in-memory cache: