got 11.0.0-beta.1 → 11.0.3

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,32 @@
 "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);
+        }
+        throw new types_1.ParseError({
+            message: `Unknown body type '${responseType}'`,
+            name: 'Error'
+        }, response);
     }
-    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 +91,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,23 +105,12 @@ class PromisableRequest extends core_1.default {
         return mergedOptions;
     }
     async _beforeError(error) {
-        const isHTTPError = error instanceof core_1.HTTPError;
-        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(error_);
-            return;
-        }
-        if (this._throwHttpErrors && !isHTTPError) {
-            this.destroy(error);
-        }
-        else {
-            this.emit('error', error);
+        if (!(error instanceof core_1.RequestError)) {
+            error = new core_1.RequestError(error.message, error, this);
         }
+        // Let the promise decide whether to abort or not
+        // It is also responsible for the `beforeError` hook
+        this.emit('error', error);
     }
 }
 exports.default = PromisableRequest;

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

@@ -20,22 +20,37 @@ 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 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;
             }
+            // Note from @szmarczak: I think we should use `request.options` instead of the local options
             const request = new core_1.default(options.url, options);
-            request._throwHttpErrors = throwHttpErrors;
             request._noPipe = true;
             onCancel(() => request.destroy());
+            const reject = async (error) => {
+                try {
+                    for (const hook of options.hooks.beforeError) {
+                        // eslint-disable-next-line no-await-in-loop
+                        error = await hook(error);
+                    }
+                }
+                catch (error_) {
+                    _reject(new types_1.RequestError(error_.message, error_, request));
+                    return;
+                }
+                _reject(error);
+            };
+            globalRequest = request;
             request.once('response', async (response) => {
                 response.retryCount = retryCount;
                 if (response.request.aborted) {
@@ -48,23 +63,26 @@ 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));
+                catch (_) {
+                    // The same error is caught below.
+                    // See request.once('error')
                     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);
+                        // TODO: Call `request._beforeError`, see https://github.com/nodejs/node/issues/32995
+                        reject(error);
                         return;
                     }
                 }
@@ -73,7 +91,6 @@ function asPromise(options) {
                         // @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: {
@@ -99,13 +116,15 @@ function asPromise(options) {
                     }
                 }
                 catch (error) {
-                    request._beforeError(error);
+                    // TODO: Call `request._beforeError`, see https://github.com/nodejs/node/issues/32995
+                    reject(new types_1.RequestError(error.message, error, request));
                     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 +153,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 +170,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 +198,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

@@ -1,7 +1,7 @@
 /// <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 { 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, Agents, Method, PromiseCookieJar, RequestEvents } from '../core';
 import PromisableRequest from './core';
 export declare type ResponseType = 'json' | 'buffer' | 'text';
 export interface Response<T = unknown> extends RequestResponse<T> {
@@ -35,6 +35,7 @@ export interface PaginationOptions<T> {
         paginate?: (response: Response, allItems: T[], currentItems: T[]) => Options | false;
         shouldContinue?: (item: T, allItems: T[], currentItems: T[]) => boolean;
         countLimit?: number;
+        requestLimit?: number;
     };
 }
 export interface Options extends RequestOptions, PaginationOptions<unknown> {
@@ -64,7 +65,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>;
@@ -74,4 +75,4 @@ export interface CancelableRequest<T extends Response | Response['body'] = Respo
 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 };
+export { Progress, Headers, RequestFunction, Agents, Method, PromiseCookieJar };

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,10 @@ 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;
+declare const kBody: unique symbol;
+declare const kJobs: unique symbol;
 export declare const kIsNormalizedAlready: unique symbol;
 export interface Agents {
     http?: http.Agent;
@@ -120,7 +124,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 +177,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 +195,39 @@ 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);
+    readonly request: Request;
+    readonly timings: Timings;
+    constructor(request: Request);
 }
 export declare class HTTPError extends RequestError {
     readonly response: Response;
-    constructor(response: Response, options: NormalizedOptions);
+    readonly request: Request;
+    readonly timings: Timings;
+    constructor(response: Response);
 }
 export declare class CacheError extends RequestError {
-    constructor(error: Error, options: NormalizedOptions);
+    readonly request: Request;
+    constructor(error: Error, request: Request);
 }
 export declare class UploadError extends RequestError {
-    constructor(error: Error, options: NormalizedOptions, request: Request);
+    readonly request: Request;
+    constructor(error: Error, request: Request);
 }
 export declare class TimeoutError extends RequestError {
+    readonly request: Request;
     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);
+    readonly request: Request;
+    readonly response: Response;
+    readonly timings: Timings;
+    constructor(error: Error, request: Request);
 }
 export declare class UnsupportedProtocolError extends RequestError {
     constructor(options: NormalizedOptions);
@@ -224,6 +238,10 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     _cannotHaveBody: boolean;
     [kDownloadedSize]: number;
     [kUploadedSize]: number;
+    [kStopReading]: boolean;
+    [kTriggerRead]: boolean;
+    [kBody]: Options['body'];
+    [kJobs]: Array<() => void>;
     [kBodySize]?: number;
     [kServerResponsesPiped]: Set<ServerResponse>;
     [kIsFromCache]?: boolean;
@@ -236,9 +254,8 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     _progressCallbacks: Array<() => void>;
     options: NormalizedOptions;
     requestUrl: string;
-    finalized: boolean;
+    requestInitialized: 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 +263,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 +273,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;