got 10.5.7 → 11.0.0

package/dist/source/{calculate-retry-delay.js → as-promise/calculate-retry-delay.js}

@@ -1,30 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const is_1 = require("@sindresorhus/is");
-const errors_1 = require("./errors");
+const types_1 = require("./types");
 const retryAfterStatusCodes = new Set([413, 429, 503]);
-const isErrorWithResponse = (error) => (error instanceof errors_1.HTTPError || error instanceof errors_1.ParseError || error instanceof errors_1.MaxRedirectsError);
+const isErrorWithResponse = (error) => (error instanceof types_1.HTTPError || error instanceof types_1.ParseError || error instanceof types_1.MaxRedirectsError);
 const calculateRetryDelay = ({ attemptCount, retryOptions, error }) => {
     if (attemptCount > retryOptions.limit) {
         return 0;
     }
     const hasMethod = retryOptions.methods.includes(error.options.method);
-    const hasErrorCode = Reflect.has(error, 'code') && retryOptions.errorCodes.includes(error.code);
+    const hasErrorCode = retryOptions.errorCodes.includes(error.code);
     const hasStatusCode = isErrorWithResponse(error) && retryOptions.statusCodes.includes(error.response.statusCode);
     if (!hasMethod || (!hasErrorCode && !hasStatusCode)) {
         return 0;
     }
     if (isErrorWithResponse(error)) {
         const { response } = error;
-        if (response && Reflect.has(response.headers, 'retry-after') && retryAfterStatusCodes.has(response.statusCode)) {
+        if (response && 'retry-after' in response.headers && retryAfterStatusCodes.has(response.statusCode)) {
             let after = Number(response.headers['retry-after']);
-            if (is_1.default.nan(after)) {
+            if (Number.isNaN(after)) {
                 after = Date.parse(response.headers['retry-after']) - Date.now();
             }
             else {
                 after *= 1000;
             }
-            if (after > retryOptions.maxRetryAfter) {
+            if (retryOptions.maxRetryAfter === undefined || after > retryOptions.maxRetryAfter) {
                 return 0;
             }
             return after;

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

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

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

@@ -0,0 +1,124 @@
+"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 = (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}'`);
+        }
+    }
+    catch (error) {
+        throw new types_1.ParseError(error, response);
+    }
+};
+class PromisableRequest extends core_1.default {
+    static normalizeArguments(url, nonNormalizedOptions, defaults) {
+        const options = super.normalizeArguments(url, nonNormalizedOptions, defaults);
+        if (is_1.default.null_(options.encoding)) {
+            throw new TypeError('To get a Buffer, set `options.responseType` to `buffer` instead');
+        }
+        is_1.assert.any([is_1.default.string, is_1.default.undefined], options.encoding);
+        is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.resolveBodyOnly);
+        is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.methodRewriting);
+        is_1.assert.any([is_1.default.boolean, is_1.default.undefined], options.isStream);
+        // `options.retry`
+        const { retry } = options;
+        if (defaults) {
+            options.retry = { ...defaults.retry };
+        }
+        else {
+            options.retry = {
+                calculateDelay: retryObject => retryObject.computedValue,
+                limit: 0,
+                methods: [],
+                statusCodes: [],
+                errorCodes: [],
+                maxRetryAfter: undefined
+            };
+        }
+        if (is_1.default.object(retry)) {
+            options.retry = {
+                ...options.retry,
+                ...retry
+            };
+            options.retry.methods = [...new Set(options.retry.methods.map(method => method.toUpperCase()))];
+            options.retry.statusCodes = [...new Set(options.retry.statusCodes)];
+            options.retry.errorCodes = [...new Set(options.retry.errorCodes)];
+        }
+        else if (is_1.default.number(retry)) {
+            options.retry.limit = retry;
+        }
+        if (is_1.default.undefined(options.retry.maxRetryAfter)) {
+            options.retry.maxRetryAfter = Math.min(...[options.timeout.request, options.timeout.connect].filter(is_1.default.number));
+        }
+        // `options.pagination`
+        if (is_1.default.object(options.pagination)) {
+            if (defaults) {
+                options.pagination = {
+                    ...defaults.pagination,
+                    ...options.pagination
+                };
+            }
+            const { pagination } = options;
+            if (!is_1.default.function_(pagination.transform)) {
+                throw new Error('`options.pagination.transform` must be implemented');
+            }
+            if (!is_1.default.function_(pagination.shouldContinue)) {
+                throw new Error('`options.pagination.shouldContinue` must be implemented');
+            }
+            if (!is_1.default.function_(pagination.filter)) {
+                throw new TypeError('`options.pagination.filter` must be implemented');
+            }
+            if (!is_1.default.function_(pagination.paginate)) {
+                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) {
+        let mergedOptions;
+        for (const source of sources) {
+            mergedOptions = PromisableRequest.normalizeArguments(undefined, source, mergedOptions);
+        }
+        return mergedOptions;
+    }
+    async _beforeError(error) {
+        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
+                error = await hook(error);
+            }
+        }
+        catch (error_) {
+            this.destroy(new core_1.RequestError(error_.message, error_, this));
+            return;
+        }
+        // Let the promise decide whether to abort or not
+        this.emit('error', error);
+    }
+}
+exports.default = PromisableRequest;

package/dist/source/as-promise/create-rejection.d.ts

@@ -0,0 +1,2 @@
+import { CancelableRequest, BeforeErrorHook } from './types';
+export default function createRejection(error: Error, ...beforeErrorGroups: Array<BeforeErrorHook[] | undefined>): CancelableRequest<never>;

package/dist/source/as-promise/create-rejection.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+function createRejection(error, ...beforeErrorGroups) {
+    const promise = (async () => {
+        if (error instanceof types_1.RequestError) {
+            try {
+                for (const hooks of beforeErrorGroups) {
+                    if (hooks) {
+                        for (const hook of hooks) {
+                            // eslint-disable-next-line no-await-in-loop
+                            error = await hook(error);
+                        }
+                    }
+                }
+            }
+            catch (error_) {
+                error = error_;
+            }
+        }
+        throw error;
+    })();
+    const returnPromise = () => promise;
+    promise.json = returnPromise;
+    promise.text = returnPromise;
+    promise.buffer = returnPromise;
+    promise.on = returnPromise;
+    return promise;
+}
+exports.default = createRejection;

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

@@ -0,0 +1,5 @@
+import { NormalizedOptions, CancelableRequest } from './types';
+import PromisableRequest from './core';
+export default function asPromise<T>(options: NormalizedOptions): CancelableRequest<T>;
+export * from './types';
+export { PromisableRequest };

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

@@ -0,0 +1,203 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const getStream = require("get-stream");
+const PCancelable = require("p-cancelable");
+const calculate_retry_delay_1 = require("./calculate-retry-delay");
+const types_1 = require("./types");
+const core_1 = require("./core");
+exports.PromisableRequest = core_1.default;
+const proxy_events_1 = require("../core/utils/proxy-events");
+const proxiedRequestEvents = [
+    'request',
+    'response',
+    'redirect',
+    'uploadProgress',
+    'downloadProgress'
+];
+function asPromise(options) {
+    let retryCount = 0;
+    let globalRequest;
+    let globalResponse;
+    const emitter = new events_1.EventEmitter();
+    const promise = new PCancelable((resolve, reject, onCancel) => {
+        const makeRequest = () => {
+            // 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._noPipe = true;
+            onCancel(() => request.destroy());
+            globalRequest = request;
+            request.once('response', async (response) => {
+                response.retryCount = retryCount;
+                if (response.request.aborted) {
+                    // Canceled while downloading - will throw a `CancelError` or `TimeoutError` error
+                    return;
+                }
+                const isOk = () => {
+                    const { statusCode } = response;
+                    const limitStatusCode = options.followRedirect ? 299 : 399;
+                    return (statusCode >= 200 && statusCode <= limitStatusCode) || statusCode === 304;
+                };
+                // Download body
+                let rawBody;
+                try {
+                    rawBody = await getStream.buffer(request);
+                    response.rawBody = rawBody;
+                }
+                catch (error) {
+                    request._beforeError(new types_1.ReadError(error, request));
+                    return;
+                }
+                // Parse body
+                try {
+                    response.body = core_1.parseBody(response, options.responseType, options.encoding);
+                }
+                catch (error) {
+                    // Fallback to `utf8`
+                    response.body = rawBody.toString();
+                    if (isOk()) {
+                        request._beforeError(error);
+                        return;
+                    }
+                }
+                try {
+                    for (const [index, hook] of options.hooks.afterResponse.entries()) {
+                        // @ts-ignore TS doesn't notice that CancelableRequest is a Promise
+                        // eslint-disable-next-line no-await-in-loop
+                        response = await hook(response, async (updatedOptions) => {
+                            request.destroy();
+                            const typedOptions = core_1.default.normalizeArguments(undefined, {
+                                ...updatedOptions,
+                                retry: {
+                                    calculateDelay: () => 0
+                                },
+                                throwHttpErrors: false,
+                                resolveBodyOnly: false
+                            }, options);
+                            // Remove any further hooks for that request, because we'll call them anyway.
+                            // The loop continues. We don't want duplicates (asPromise recursion).
+                            typedOptions.hooks.afterResponse = typedOptions.hooks.afterResponse.slice(0, index);
+                            for (const hook of typedOptions.hooks.beforeRetry) {
+                                // eslint-disable-next-line no-await-in-loop
+                                await hook(typedOptions);
+                            }
+                            const promise = asPromise(typedOptions);
+                            onCancel(() => {
+                                promise.catch(() => { });
+                                promise.cancel();
+                            });
+                            return promise;
+                        });
+                    }
+                }
+                catch (error) {
+                    request._beforeError(error);
+                    return;
+                }
+                if (throwHttpErrors && !isOk()) {
+                    reject(new types_1.HTTPError(response));
+                    return;
+                }
+                globalResponse = response;
+                resolve(options.resolveBodyOnly ? response.body : response);
+            });
+            request.once('error', (error) => {
+                if (promise.isCanceled) {
+                    return;
+                }
+                if (!request.options) {
+                    reject(error);
+                    return;
+                }
+                let backoff;
+                retryCount++;
+                try {
+                    backoff = options.retry.calculateDelay({
+                        attemptCount: retryCount,
+                        retryOptions: options.retry,
+                        error,
+                        computedValue: calculate_retry_delay_1.default({
+                            attemptCount: retryCount,
+                            retryOptions: options.retry,
+                            error,
+                            computedValue: 0
+                        })
+                    });
+                }
+                catch (error_) {
+                    // Don't emit the `response` event
+                    request.destroy();
+                    reject(new types_1.RequestError(error_.message, error, request));
+                    return;
+                }
+                if (backoff) {
+                    // Don't emit the `response` event
+                    request.destroy();
+                    const retry = async () => {
+                        options.throwHttpErrors = throwHttpErrors;
+                        try {
+                            for (const hook of options.hooks.beforeRetry) {
+                                // eslint-disable-next-line no-await-in-loop
+                                await hook(options, error, retryCount);
+                            }
+                        }
+                        catch (error_) {
+                            // Don't emit the `response` event
+                            request.destroy();
+                            reject(new types_1.RequestError(error_.message, error, request));
+                            return;
+                        }
+                        makeRequest();
+                    };
+                    setTimeout(retry, backoff);
+                    return;
+                }
+                // The retry has not been made
+                retryCount--;
+                if (error instanceof types_1.HTTPError) {
+                    // It will be handled by the `response` event
+                    return;
+                }
+                // Don't emit the `response` event
+                request.destroy();
+                reject(error);
+            });
+            proxy_events_1.default(request, emitter, proxiedRequestEvents);
+        };
+        makeRequest();
+    });
+    promise.on = (event, fn) => {
+        emitter.on(event, fn);
+        return promise;
+    };
+    const shortcut = (responseType) => {
+        const newPromise = (async () => {
+            // Wait until downloading has ended
+            await promise;
+            return core_1.parseBody(globalResponse, responseType, options.encoding);
+        })();
+        Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
+        return newPromise;
+    };
+    promise.json = () => {
+        if (!globalRequest.writableFinished && options.headers.accept === undefined) {
+            options.headers.accept = 'application/json';
+        }
+        return shortcut('json');
+    };
+    promise.buffer = () => shortcut('buffer');
+    promise.text = () => shortcut('text');
+    return promise;
+}
+exports.default = asPromise;
+__export(require("./types"));

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

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+import PCancelable = require('p-cancelable');
+import { CancelError } from 'p-cancelable';
+import { Options as RequestOptions, NormalizedOptions as RequestNormalizedOptions, Defaults as RequestDefaults, Hooks as RequestHooks, Response as RequestResponse, RequestError, MaxRedirectsError, CacheError, UploadError, TimeoutError, HTTPError, ReadError, UnsupportedProtocolError, HookEvent as RequestHookEvent, InitHook, BeforeRequestHook, BeforeRedirectHook, BeforeErrorHook, Progress, Headers, RequestFunction, Method, RequestEvents } from '../core';
+import PromisableRequest from './core';
+export declare type ResponseType = 'json' | 'buffer' | 'text';
+export interface Response<T = unknown> extends RequestResponse<T> {
+    request: PromisableRequest;
+}
+export interface RetryObject {
+    attemptCount: number;
+    retryOptions: RequiredRetryOptions;
+    error: TimeoutError | RequestError;
+    computedValue: number;
+}
+export declare type RetryFunction = (retryObject: RetryObject) => number;
+export interface RequiredRetryOptions {
+    limit: number;
+    methods: Method[];
+    statusCodes: number[];
+    errorCodes: string[];
+    calculateDelay: RetryFunction;
+    maxRetryAfter?: number;
+}
+export declare type BeforeRetryHook = (options: NormalizedOptions, error?: RequestError, retryCount?: number) => void | Promise<void>;
+export declare type AfterResponseHook = (response: Response, retryWithMergedOptions: (options: Options) => CancelableRequest<Response>) => Response | CancelableRequest<Response> | Promise<Response | CancelableRequest<Response>>;
+export interface Hooks extends RequestHooks {
+    beforeRetry?: BeforeRetryHook[];
+    afterResponse?: AfterResponseHook[];
+}
+export interface PaginationOptions<T> {
+    pagination?: {
+        transform?: (response: Response) => Promise<T[]> | T[];
+        filter?: (item: T, allItems: T[], currentItems: T[]) => boolean;
+        paginate?: (response: Response, allItems: T[], currentItems: T[]) => Options | false;
+        shouldContinue?: (item: T, allItems: T[], currentItems: T[]) => boolean;
+        countLimit?: number;
+    };
+}
+export interface Options extends RequestOptions, PaginationOptions<unknown> {
+    hooks?: Hooks;
+    responseType?: ResponseType;
+    resolveBodyOnly?: boolean;
+    retry?: Partial<RequiredRetryOptions> | number;
+    isStream?: boolean;
+    encoding?: BufferEncoding;
+}
+export interface NormalizedOptions extends RequestNormalizedOptions {
+    hooks: Required<Hooks>;
+    responseType: ResponseType;
+    resolveBodyOnly: boolean;
+    retry: RequiredRetryOptions;
+    isStream: boolean;
+    encoding?: BufferEncoding;
+    pagination?: Required<PaginationOptions<unknown>['pagination']>;
+}
+export interface Defaults extends RequestDefaults {
+    hooks: Required<Hooks>;
+    responseType: ResponseType;
+    resolveBodyOnly: boolean;
+    retry: RequiredRetryOptions;
+    isStream: boolean;
+    pagination?: Required<PaginationOptions<unknown>['pagination']>;
+}
+export declare class ParseError extends RequestError {
+    readonly response: Response;
+    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>;
+    buffer(): CancelableRequest<Buffer>;
+    text(): CancelableRequest<string>;
+}
+export declare type HookEvent = RequestHookEvent | 'beforeRetry' | 'afterResponse';
+export { RequestError, MaxRedirectsError, CacheError, UploadError, TimeoutError, HTTPError, ReadError, UnsupportedProtocolError, CancelError };
+export { InitHook, BeforeRequestHook, BeforeRedirectHook, BeforeErrorHook };
+export { Progress, Headers, RequestFunction };

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const p_cancelable_1 = require("p-cancelable");
+exports.CancelError = p_cancelable_1.CancelError;
+const core_1 = require("../core");
+exports.RequestError = 
+// Errors to be exported
+core_1.RequestError;
+exports.MaxRedirectsError = core_1.MaxRedirectsError;
+exports.CacheError = core_1.CacheError;
+exports.UploadError = core_1.UploadError;
+exports.TimeoutError = core_1.TimeoutError;
+exports.HTTPError = core_1.HTTPError;
+exports.ReadError = core_1.ReadError;
+exports.UnsupportedProtocolError = core_1.UnsupportedProtocolError;
+class ParseError extends core_1.RequestError {
+    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,
+            value: response
+        });
+    }
+}
+exports.ParseError = ParseError;