got 11.5.2 → 11.6.0

package/dist/source/core/index.js

@@ -25,7 +25,10 @@ const options_to_url_1 = require("./utils/options-to-url");
 const weakable_map_1 = require("./utils/weakable-map");
 const get_buffer_1 = require("./utils/get-buffer");
 const dns_ip_version_1 = require("./utils/dns-ip-version");
+const is_response_ok_1 = require("./utils/is-response-ok");
 const deprecation_warning_1 = require("../utils/deprecation-warning");
+const normalize_arguments_1 = require("../as-promise/normalize-arguments");
+const calculate_retry_delay_1 = require("./calculate-retry-delay");
 const globalDnsCache = new cacheable_lookup_1.default();
 const kRequest = Symbol('request');
 const kResponse = Symbol('response');
@@ -43,10 +46,19 @@ const kTriggerRead = Symbol('triggerRead');
 const kBody = Symbol('body');
 const kJobs = Symbol('jobs');
 const kOriginalResponse = Symbol('originalResponse');
+const kRetryTimeout = Symbol('retryTimeout');
 exports.kIsNormalizedAlready = Symbol('isNormalizedAlready');
 const supportsBrotli = is_1.default.string(process.versions.brotli);
 exports.withoutBody = new Set(['GET', 'HEAD']);
-exports.knownHookEvents = ['init', 'beforeRequest', 'beforeRedirect', 'beforeError'];
+exports.knownHookEvents = [
+    'init',
+    'beforeRequest',
+    'beforeRedirect',
+    'beforeError',
+    'beforeRetry',
+    // Promise-Only
+    'afterResponse'
+];
 function validateSearchParameters(searchParameters) {
     // eslint-disable-next-line guard-for-in
     for (const key in searchParameters) {
@@ -103,6 +115,10 @@ exports.setNonEnumerableProperties = (sources, to) => {
     }
     Object.defineProperties(to, properties);
 };
+/**
+An error to be thrown when a request fails.
+Contains a `code` property with error class code, like `ECONNREFUSED`.
+*/
 class RequestError extends Error {
     constructor(message, error, self) {
         var _a;
@@ -149,6 +165,10 @@ class RequestError extends Error {
     }
 }
 exports.RequestError = RequestError;
+/**
+An error to be thrown when the server redirects you more than ten times.
+Includes a `response` property.
+*/
 class MaxRedirectsError extends RequestError {
     constructor(request) {
         super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
@@ -156,6 +176,10 @@ class MaxRedirectsError extends RequestError {
     }
 }
 exports.MaxRedirectsError = MaxRedirectsError;
+/**
+An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
+Includes a `response` property.
+*/
 class HTTPError extends RequestError {
     constructor(response) {
         super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);
@@ -163,6 +187,10 @@ class HTTPError extends RequestError {
     }
 }
 exports.HTTPError = HTTPError;
+/**
+An error to be thrown when a cache method fails.
+For example, if the database goes down or there's a filesystem error.
+*/
 class CacheError extends RequestError {
     constructor(error, request) {
         super(error.message, error, request);
@@ -170,6 +198,9 @@ class CacheError extends RequestError {
     }
 }
 exports.CacheError = CacheError;
+/**
+An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
+*/
 class UploadError extends RequestError {
     constructor(error, request) {
         super(error.message, error, request);
@@ -177,6 +208,10 @@ class UploadError extends RequestError {
     }
 }
 exports.UploadError = UploadError;
+/**
+An error to be thrown when the request is aborted due to a timeout.
+Includes an `event` and `timings` property.
+*/
 class TimeoutError extends RequestError {
     constructor(error, timings, request) {
         super(error.message, error, request);
@@ -186,6 +221,9 @@ class TimeoutError extends RequestError {
     }
 }
 exports.TimeoutError = TimeoutError;
+/**
+An error to be thrown when reading from response stream fails.
+*/
 class ReadError extends RequestError {
     constructor(error, request) {
         super(error.message, error, request);
@@ -193,6 +231,9 @@ class ReadError extends RequestError {
     }
 }
 exports.ReadError = ReadError;
+/**
+An error to be thrown when given an unsupported protocol.
+*/
 class UnsupportedProtocolError extends RequestError {
     constructor(options) {
         super(`Unsupported protocol "${options.url.protocol}"`, {}, options);
@@ -211,6 +252,9 @@ const proxiedRequestEvents = [
 class Request extends stream_1.Duplex {
     constructor(url, options = {}, defaults) {
         super({
+            // This must be false, to enable throwing after destroy
+            // It is used for retry logic in Promise API
+            autoDestroy: false,
             // It needs to be zero because we're just proxying the data to another stream
             highWaterMark: 0
         });
@@ -222,6 +266,7 @@ class Request extends stream_1.Duplex {
         this[kStopReading] = false;
         this[kTriggerRead] = false;
         this[kJobs] = [];
+        this.retryCount = 0;
         // TODO: Remove this when targeting Node.js >= 12
         this._progressCallbacks = [];
         const unlockWrite = () => this._unlockWrite();
@@ -279,6 +324,8 @@ class Request extends stream_1.Duplex {
                 for (const job of this[kJobs]) {
                     job();
                 }
+                // Prevent memory leak
+                this[kJobs].length = 0;
                 this.requestInitialized = true;
             }
             catch (error) {
@@ -348,6 +395,7 @@ class Request extends stream_1.Duplex {
             is_1.assert.any([is_1.default.string, is_1.default.object, is_1.default.array, is_1.default.undefined], options.https.certificate);
             is_1.assert.any([is_1.default.string, is_1.default.undefined], options.https.passphrase);
         }
+        is_1.assert.any([is_1.default.object, is_1.default.undefined], options.cacheOptions);
         // `options.method`
         if (is_1.default.string(options.method)) {
             options.method = options.method.toUpperCase();
@@ -479,9 +527,7 @@ class Request extends stream_1.Duplex {
                 getCookieString = util_1.promisify(getCookieString.bind(options.cookieJar));
                 options.cookieJar = {
                     setCookie,
-                    // TODO: Fix this when upgrading to TypeScript 4.
-                    // @ts-expect-error TypeScript thinks that promisifying callback(error, string) will result in Promise<void>
-                    getCookieString
+                    getCookieString: getCookieString
                 };
             }
         }
@@ -522,6 +568,8 @@ class Request extends stream_1.Duplex {
                 }), cache));
             }
         }
+        // `options.cacheOptions`
+        options.cacheOptions = { ...options.cacheOptions };
         // `options.dnsCache`
         if (options.dnsCache === true) {
             options.dnsCache = globalDnsCache;
@@ -615,7 +663,7 @@ class Request extends stream_1.Duplex {
         options.maxRedirects = (_d = options.maxRedirects) !== null && _d !== void 0 ? _d : 0;
         // Set non-enumerable properties
         exports.setNonEnumerableProperties([defaults, rawOptions], options);
-        return options;
+        return normalize_arguments_1.default(options, defaults);
     }
     _lockWrite() {
         const onLockedWrite = () => {
@@ -717,6 +765,7 @@ class Request extends stream_1.Duplex {
         typedResponse.request = this;
         typedResponse.isFromCache = response.fromCache || false;
         typedResponse.ip = this.ip;
+        typedResponse.retryCount = this.retryCount;
         this[kIsFromCache] = typedResponse.isFromCache;
         this[kResponseSize] = Number(response.headers['content-length']) || undefined;
         this[kResponse] = response;
@@ -754,7 +803,7 @@ class Request extends stream_1.Duplex {
         }
         if (options.followRedirect && response.headers.location && redirectCodes.has(statusCode)) {
             // We're being redirected, we don't care about the response.
-            // It'd be besto to abort the request, but we can't because
+            // It'd be best to abort the request, but we can't because
             // we would have to sacrifice the TCP connection. We don't want that.
             response.resume();
             if (this[kRequest]) {
@@ -801,7 +850,10 @@ class Request extends stream_1.Duplex {
                         delete options.headers.authorization;
                     }
                     if (options.username || options.password) {
+                        // TODO: Fix this ignore.
+                        // @ts-expect-error
                         delete options.username;
+                        // @ts-expect-error
                         delete options.password;
                     }
                 }
@@ -820,16 +872,9 @@ class Request extends stream_1.Duplex {
             }
             return;
         }
-        const limitStatusCode = options.followRedirect ? 299 : 399;
-        const isOk = (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
-        if (options.throwHttpErrors && !isOk) {
-            // Normally we would have to use `void [await] this._beforeError(error)` everywhere,
-            // but since there's `void (async () => { ... })()` inside of it, we don't have to.
+        if (options.isStream && options.throwHttpErrors && !is_response_ok_1.isResponseOk(typedResponse)) {
             this._beforeError(new HTTPError(typedResponse));
-            // This is equivalent to this.destroyed
-            if (this[kStopReading]) {
-                return;
-            }
+            return;
         }
         response.on('readable', () => {
             if (this[kTriggerRead]) {
@@ -866,6 +911,7 @@ class Request extends stream_1.Duplex {
             await this._onResponseBase(response);
         }
         catch (error) {
+            /* istanbul ignore next: better safe than sorry */
             this._beforeError(error);
         }
     }
@@ -903,9 +949,6 @@ class Request extends stream_1.Duplex {
             body.once('error', (error) => {
                 this._beforeError(new UploadError(error, this));
             });
-            body.once('end', () => {
-                delete options.body;
-            });
         }
         else {
             this._unlockWrite();
@@ -926,6 +969,8 @@ class Request extends stream_1.Duplex {
             // 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
+            // TODO: Fix this ignore.
+            // @ts-expect-error
             delete options.url;
             let request;
             // This is ugly
@@ -947,7 +992,7 @@ class Request extends stream_1.Duplex {
         });
     }
     async _makeRequest() {
-        var _a;
+        var _a, _b, _c, _d, _e;
         const { options } = this;
         const { headers } = options;
         for (const key in headers) {
@@ -1013,14 +1058,20 @@ class Request extends stream_1.Duplex {
         // Prepare plain HTTP request options
         options[kRequest] = realFn;
         delete options.request;
+        // TODO: Fix this ignore.
+        // @ts-expect-error
         delete options.timeout;
         const requestOptions = options;
+        requestOptions.shared = (_b = options.cacheOptions) === null || _b === void 0 ? void 0 : _b.shared;
+        requestOptions.cacheHeuristic = (_c = options.cacheOptions) === null || _c === void 0 ? void 0 : _c.cacheHeuristic;
+        requestOptions.immutableMinTimeToLive = (_d = options.cacheOptions) === null || _d === void 0 ? void 0 : _d.immutableMinTimeToLive;
+        requestOptions.ignoreCargoCult = (_e = options.cacheOptions) === null || _e === void 0 ? void 0 : _e.ignoreCargoCult;
         // If `dnsLookupIpVersion` is not present do not override `family`
         if (options.dnsLookupIpVersion !== undefined) {
             try {
                 requestOptions.family = dns_ip_version_1.dnsLookupIpVersionToFamily(options.dnsLookupIpVersion);
             }
-            catch (_b) {
+            catch (_f) {
                 throw new Error('Invalid `dnsLookupIpVersion` option value');
             }
         }
@@ -1060,6 +1111,7 @@ class Request extends stream_1.Duplex {
                     delete requestOptions.rejectUnauthorized;
                 }
                 if (options.https.checkServerIdentity) {
+                    // @ts-expect-error - This one will be removed when we remove the alias.
                     delete requestOptions.checkServerIdentity;
                 }
                 if (options.https.certificateAuthority) {
@@ -1098,34 +1150,97 @@ class Request extends stream_1.Duplex {
             throw new RequestError(error.message, error, this);
         }
     }
+    async _error(error) {
+        try {
+            for (const hook of this.options.hooks.beforeError) {
+                // eslint-disable-next-line no-await-in-loop
+                error = await hook(error);
+            }
+        }
+        catch (error_) {
+            error = new RequestError(error_.message, error_, this);
+        }
+        this.destroy(error);
+    }
     _beforeError(error) {
-        if (this.destroyed) {
+        if (this[kStopReading]) {
             return;
         }
+        const { options } = this;
+        const retryCount = this.retryCount + 1;
         this[kStopReading] = true;
         if (!(error instanceof RequestError)) {
             error = new RequestError(error.message, error, this);
         }
+        const typedError = error;
+        const { response } = typedError;
         void (async () => {
-            try {
-                const { response } = error;
-                if (response) {
-                    response.setEncoding(this._readableState.encoding);
+            if (response && !response.body) {
+                response.setEncoding(this._readableState.encoding);
+                try {
                     response.rawBody = await get_buffer_1.default(response);
-                    response.body = response.rawBody.toString();
                 }
-            }
-            catch (_a) { }
-            try {
-                for (const hook of this.options.hooks.beforeError) {
-                    // eslint-disable-next-line no-await-in-loop
-                    error = await hook(error);
+                catch (_a) { }
+                response.body = response.rawBody.toString();
+            }
+            if (this.listenerCount('retry') !== 0) {
+                let backoff;
+                try {
+                    let retryAfter;
+                    if (response && 'retry-after' in response.headers) {
+                        retryAfter = Number(response.headers['retry-after']);
+                        if (Number.isNaN(retryAfter)) {
+                            retryAfter = Date.parse(response.headers['retry-after']) - Date.now();
+                            if (retryAfter <= 0) {
+                                retryAfter = 1;
+                            }
+                        }
+                        else {
+                            retryAfter *= 1000;
+                        }
+                    }
+                    backoff = await options.retry.calculateDelay({
+                        attemptCount: retryCount,
+                        retryOptions: options.retry,
+                        error: typedError,
+                        retryAfter,
+                        computedValue: calculate_retry_delay_1.default({
+                            attemptCount: retryCount,
+                            retryOptions: options.retry,
+                            error: typedError,
+                            retryAfter,
+                            computedValue: 0
+                        })
+                    });
+                }
+                catch (error_) {
+                    void this._error(new RequestError(error_.message, error_, this));
+                    return;
+                }
+                if (backoff) {
+                    const retry = async () => {
+                        try {
+                            for (const hook of this.options.hooks.beforeRetry) {
+                                // eslint-disable-next-line no-await-in-loop
+                                await hook(this.options, typedError, retryCount);
+                            }
+                        }
+                        catch (error_) {
+                            void this._error(new RequestError(error_.message, error, this));
+                            return;
+                        }
+                        // Something forced us to abort the retry
+                        if (this.destroyed) {
+                            return;
+                        }
+                        this.destroy();
+                        this.emit('retry', retryCount, error);
+                    };
+                    this[kRetryTimeout] = setTimeout(retry, backoff);
+                    return;
                 }
             }
-            catch (error_) {
-                error = new RequestError(error_.message, error_, this);
-            }
-            this.destroy(error);
+            void this._error(typedError);
         })();
     }
     _read() {
@@ -1212,6 +1327,8 @@ class Request extends stream_1.Duplex {
     _destroy(error, callback) {
         var _a;
         this[kStopReading] = true;
+        // Prevent further retries
+        clearTimeout(this[kRetryTimeout]);
         if (kRequest in this) {
             this[kCancelTimeouts]();
             // TODO: Remove the next `if` when these get fixed:
@@ -1225,10 +1342,19 @@ class Request extends stream_1.Duplex {
         }
         callback(error);
     }
+    get _isAboutToError() {
+        return this[kStopReading];
+    }
+    /**
+    The remote IP address.
+    */
     get ip() {
         var _a;
         return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.socket.remoteAddress;
     }
+    /**
+    Indicates whether the request has been aborted or not.
+    */
     get aborted() {
         var _a, _b, _c;
         return ((_b = (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.destroyed) !== null && _b !== void 0 ? _b : this.destroyed) && !((_c = this[kOriginalResponse]) === null || _c === void 0 ? void 0 : _c.complete);
@@ -1237,6 +1363,9 @@ class Request extends stream_1.Duplex {
         var _a;
         return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.socket;
     }
+    /**
+    Progress event for downloading (receiving a response).
+    */
     get downloadProgress() {
         let percent;
         if (this[kResponseSize]) {
@@ -1254,6 +1383,9 @@ class Request extends stream_1.Duplex {
             total: this[kResponseSize]
         };
     }
+    /**
+    Progress event for uploading (sending a request).
+    */
     get uploadProgress() {
         let percent;
         if (this[kBodySize]) {
@@ -1271,16 +1403,43 @@ class Request extends stream_1.Duplex {
             total: this[kBodySize]
         };
     }
+    /**
+    The object contains the following properties:
+
+    - `start` - Time when the request started.
+    - `socket` - Time when a socket was assigned to the request.
+    - `lookup` - Time when the DNS lookup finished.
+    - `connect` - Time when the socket successfully connected.
+    - `secureConnect` - Time when the socket securely connected.
+    - `upload` - Time when the request finished uploading.
+    - `response` - Time when the request fired `response` event.
+    - `end` - Time when the response fired `end` event.
+    - `error` - Time when the request fired `error` event.
+    - `abort` - Time when the request fired `abort` event.
+    - `phases`
+        - `wait` - `timings.socket - timings.start`
+        - `dns` - `timings.lookup - timings.socket`
+        - `tcp` - `timings.connect - timings.lookup`
+        - `tls` - `timings.secureConnect - timings.connect`
+        - `request` - `timings.upload - (timings.secureConnect || timings.connect)`
+        - `firstByte` - `timings.response - timings.upload`
+        - `download` - `timings.end - timings.response`
+        - `total` - `(timings.end || timings.error || timings.abort) - timings.start`
+
+    If something has not been measured yet, it will be `undefined`.
+
+    __Note__: The time is a `number` representing the milliseconds elapsed since the UNIX epoch.
+    */
     get timings() {
         var _a;
         return (_a = this[kRequest]) === null || _a === void 0 ? void 0 : _a.timings;
     }
+    /**
+    Whether the response was retrieved from the cache.
+    */
     get isFromCache() {
         return this[kIsFromCache];
     }
-    get _response() {
-        return this[kResponse];
-    }
     pipe(destination, options) {
         if (this[kStartedReading]) {
             throw new Error('Failed to pipe. The response has been emitted already.');

package/dist/source/core/utils/is-response-ok.d.ts

@@ -0,0 +1,2 @@
+import { Response } from '..';
+export declare const isResponseOk: (response: Response) => boolean;

package/dist/source/core/utils/is-response-ok.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isResponseOk = void 0;
+exports.isResponseOk = (response) => {
+    const { statusCode } = response;
+    const limitStatusCode = response.request.options.followRedirect ? 299 : 399;
+    return (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
+};

package/dist/source/create.js

@@ -7,11 +7,10 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     o[k2] = m[k];
 }));
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultHandler = void 0;
-const p_cancelable_1 = require("p-cancelable");
 const is_1 = require("@sindresorhus/is");
 const as_promise_1 = require("./as-promise");
 const create_rejection_1 = require("./as-promise/create-rejection");
@@ -25,14 +24,23 @@ const errors = {
     MaxRedirectsError: as_promise_1.MaxRedirectsError,
     TimeoutError: as_promise_1.TimeoutError,
     ParseError: as_promise_1.ParseError,
-    CancelError: p_cancelable_1.CancelError,
+    CancelError: as_promise_1.CancelError,
     UnsupportedProtocolError: as_promise_1.UnsupportedProtocolError,
     UploadError: as_promise_1.UploadError
 };
 // The `delay` package weighs 10KB (!)
-const delay = async (ms) => new Promise(resolve => setTimeout(resolve, ms));
-const { normalizeArguments, mergeOptions } = as_promise_1.PromisableRequest;
-const getPromiseOrStream = (options) => options.isStream ? new core_1.default(options.url, options) : as_promise_1.default(options);
+const delay = async (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+const { normalizeArguments } = core_1.default;
+const mergeOptions = (...sources) => {
+    let mergedOptions;
+    for (const source of sources) {
+        mergedOptions = normalizeArguments(undefined, source, mergedOptions);
+    }
+    return mergedOptions;
+};
+const getPromiseOrStream = (options) => options.isStream ? new core_1.default(undefined, options) : as_promise_1.default(options);
 const isGotInstance = (value) => ('defaults' in value && 'options' in value.defaults);
 const aliases = [
     'get',
@@ -218,13 +226,14 @@ const create = (defaults) => {
             return got(url, { ...options, method, isStream: true });
         });
     }
-    Object.assign(got, { ...errors, mergeOptions });
+    Object.assign(got, errors);
     Object.defineProperty(got, 'defaults', {
         value: defaults.mutableDefaults ? defaults : deep_freeze_1.default(defaults),
         writable: defaults.mutableDefaults,
         configurable: defaults.mutableDefaults,
         enumerable: true
     });
+    got.mergeOptions = mergeOptions;
     return got;
 };
 exports.default = create;

package/dist/source/index.js

@@ -7,7 +7,7 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     o[k2] = m[k];
 }));
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const url_1 = require("url");
@@ -116,7 +116,8 @@ const defaults = {
             stackAllItems: true
         },
         parseJson: (text) => JSON.parse(text),
-        stringifyJson: (object) => JSON.stringify(object)
+        stringifyJson: (object) => JSON.stringify(object),
+        cacheOptions: {}
     },
     handlers: [create_1.defaultHandler],
     mutableDefaults: false