got 12.0.0-beta.1 → 12.0.0

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

@@ -1,3 +1,3 @@
 import Request from '../core/index.js';
 import type { CancelableRequest } from './types.js';
-export default function asPromise<T>(firstRequest: Request): CancelableRequest<T>;
+export default function asPromise<T>(firstRequest?: Request): CancelableRequest<T>;

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

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import is from '@sindresorhus/is';
 import PCancelable from 'p-cancelable';
 import { HTTPError, RetryError, } from '../core/errors.js';
@@ -38,7 +38,7 @@ export default function asPromise(firstRequest) {
             request.once('response', async (response) => {
                 // Parse body
                 const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
-                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'defalte' || contentEncoding === 'br';
+                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br';
                 const { options } = request;
                 if (isCompressed && !options.decompress) {
                     response.body = response.rawBody;
@@ -48,7 +48,7 @@ export default function asPromise(firstRequest) {
                         response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
                     }
                     catch (error) {
-                        // Fallback to `utf8`
+                        // Fall back to `utf8`
                         response.body = response.rawBody.toString();
                         if (isResponseOk(response)) {
                             request._beforeError(error);
@@ -58,10 +58,7 @@ export default function asPromise(firstRequest) {
                 }
                 try {
                     const hooks = options.hooks.afterResponse;
-                    // TODO: `xo` should detect if `index` is being used for something else
-                    // eslint-disable-next-line unicorn/no-for-loop
-                    for (let index = 0; index < hooks.length; index++) {
-                        const hook = hooks[index];
+                    for (const [index, hook] of hooks.entries()) {
                         // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
                         // eslint-disable-next-line no-await-in-loop
                         response = await hook(response, async (updatedOptions) => {
@@ -75,7 +72,7 @@ export default function asPromise(firstRequest) {
                             options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
                             throw new RetryError(request);
                         });
-                        if (!(is.object(response) && is.number(response.statusCode) && response.body)) {
+                        if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {
                             throw new TypeError('The `afterResponse` hook returned an invalid value');
                         }
                     }
@@ -108,7 +105,6 @@ export default function asPromise(firstRequest) {
             request.once('error', onError);
             const previousBody = request.options?.body;
             request.once('retry', (newRetryCount, error) => {
-                // @ts-expect-error
                 firstRequest = undefined;
                 const newBody = request.options.body;
                 if (previousBody === newBody && is.nodeStream(newBody)) {

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import type { Buffer } from 'node:buffer';
 import PCancelable from 'p-cancelable';
 import { RequestError } from '../core/errors.js';
 import type Request from '../core/index.js';
@@ -10,10 +11,28 @@ An error to be thrown when the request is aborted with `.cancel()`.
 export declare class CancelError extends RequestError {
     readonly response: Response;
     constructor(request: Request);
+    /**
+    Whether the promise is canceled.
+    */
     get isCanceled(): boolean;
 }
 export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
+    /**
+    A shortcut method that gives a Promise returning a JSON object.
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'json'`.
+    */
     json: <ReturnType>() => CancelableRequest<ReturnType>;
+    /**
+    A shortcut method that gives a Promise returning a [Buffer](https://nodejs.org/api/buffer.html).
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'buffer'`.
+    */
     buffer: () => CancelableRequest<Buffer>;
+    /**
+    A shortcut method that gives a Promise returning a string.
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'text'`.
+    */
     text: () => CancelableRequest<string>;
 }

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

@@ -8,6 +8,9 @@ export class CancelError extends RequestError {
         this.name = 'CancelError';
         this.code = 'ERR_CANCELED';
     }
+    /**
+    Whether the promise is canceled.
+    */
     get isCanceled() {
         return true;
     }

package/dist/source/core/errors.js

@@ -93,6 +93,7 @@ export class MaxRedirectsError extends RequestError {
 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.
 */
+// eslint-disable-next-line @typescript-eslint/naming-convention
 export class HTTPError extends RequestError {
     constructor(response) {
         super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);

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

@@ -1,9 +1,9 @@
 /// <reference types="node" />
-import { Duplex } from 'stream';
-import { URL } from 'url';
-import { ServerResponse } from 'http';
-import type { ClientRequest } from 'http';
-import type { Socket } from 'net';
+import { Duplex } from 'node:stream';
+import { URL } from 'node:url';
+import { ServerResponse } from 'node:http';
+import type { ClientRequest } from 'node:http';
+import type { Socket } from 'node:net';
 import CacheableRequest from 'cacheable-request';
 import type { Timings } from '@szmarczak/http-timer';
 import type ResponseLike from 'responselike';
@@ -12,12 +12,12 @@ import { Response } from './response.js';
 import { RequestError } from './errors.js';
 import type { PlainResponse } from './response.js';
 import type { NativeRequestOptions } from './options.js';
+declare type Error = NodeJS.ErrnoException;
 export interface Progress {
     percent: number;
     transferred: number;
     total?: number;
 }
-declare type Error = NodeJS.ErrnoException;
 export declare type GotEventFunction<T> = 
 /**
 `request` event to get the request object of the request.
@@ -96,7 +96,6 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     private _downloadedSize;
     private _uploadedSize;
     private _stopReading;
-    private _startedReading;
     private readonly _pipedServerResponses;
     private _request?;
     private _responseSize?;
@@ -115,7 +114,7 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     flush(): Promise<void>;
     _beforeError(error: Error): void;
     _read(): void;
-    _write(chunk: any, encoding: string | undefined, callback: (error?: Error | null) => void): void;
+    _write(chunk: unknown, encoding: BufferEncoding | undefined, callback: (error?: Error | null) => void): void;
     _final(callback: (error?: Error | null) => void): void;
     _destroy(error: Error | null, callback: (error: Error | null) => void): void;
     pipe<T extends NodeJS.WritableStream>(destination: T, options?: {

package/dist/source/core/index.js

@@ -1,11 +1,14 @@
-import { Duplex } from 'stream';
-import { URL, URLSearchParams } from 'url';
-import http, { ServerResponse } from 'http';
+import process from 'node:process';
+import { Buffer } from 'node:buffer';
+import { Duplex } from 'node:stream';
+import { URL, URLSearchParams } from 'node:url';
+import http, { ServerResponse } from 'node:http';
 import timer from '@szmarczak/http-timer';
 import CacheableRequest from 'cacheable-request';
 import decompressResponse from 'decompress-response';
 import is from '@sindresorhus/is';
 import { buffer as getBuffer } from 'get-stream';
+import { FormDataEncoder, isFormDataLike } from 'form-data-encoder';
 import getBodySize from './utils/get-body-size.js';
 import isFormData from './utils/is-form-data.js';
 import proxyEvents from './utils/proxy-events.js';
@@ -104,12 +107,6 @@ export default class Request extends Duplex {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_startedReading", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "_pipedServerResponses", {
             enumerable: true,
             configurable: true,
@@ -192,7 +189,6 @@ export default class Request extends Duplex {
         this._downloadedSize = 0;
         this._uploadedSize = 0;
         this._stopReading = false;
-        this._startedReading = false;
         this._pipedServerResponses = new Set();
         this._cannotHaveBody = false;
         this._unproxyEvents = noop;
@@ -228,6 +224,11 @@ export default class Request extends Duplex {
                 Object.assign(this.options.headers, source.headers);
             }
         });
+        this.on('newListener', event => {
+            if (event === 'retry' && this.listenerCount('retry') > 0) {
+                throw new Error('A retry listener has been attached already.');
+            }
+        });
         try {
             this.options = new Options(url, options, defaults);
             if (!this.options.url) {
@@ -384,7 +385,14 @@ export default class Request extends Duplex {
                         return;
                     }
                     this.destroy();
-                    this.emit('retry', this.retryCount + 1, error);
+                    this.emit('retry', this.retryCount + 1, error, (updatedOptions) => {
+                        const request = new Request(options.url, updatedOptions, options);
+                        request.retryCount = this.retryCount + 1;
+                        process.nextTick(() => {
+                            void request.flush();
+                        });
+                        return request;
+                    });
                     return;
                 }
             }
@@ -403,7 +411,6 @@ export default class Request extends Duplex {
             let data;
             while ((data = response.read()) !== null) {
                 this._downloadedSize += data.length;
-                this._startedReading = true;
                 const progress = this.downloadProgress;
                 if (progress.percent < 1) {
                     this.emit('downloadProgress', progress);
@@ -412,7 +419,6 @@ export default class Request extends Duplex {
             }
         }
     }
-    // Node.js 12 has incorrect types, so the encoding must be a string
     _write(chunk, encoding, callback) {
         const write = () => {
             this._writeRequest(chunk, encoding, callback);
@@ -474,9 +480,6 @@ export default class Request extends Duplex {
         callback(error);
     }
     pipe(destination, options) {
-        if (this._startedReading) {
-            throw new Error('Failed to pipe. The response has been emitted already.');
-        }
         if (destination instanceof ServerResponse) {
             this._pipedServerResponses.add(destination);
         }
@@ -504,6 +507,7 @@ export default class Request extends Duplex {
         const { options } = this;
         const { headers } = options;
         const isForm = !is.undefined(options.form);
+        // eslint-disable-next-line @typescript-eslint/naming-convention
         const isJSON = !is.undefined(options.json);
         const isBody = !is.undefined(options.body);
         const cannotHaveBody = methodsWithoutBody.has(options.method) && !(options.method === 'GET' && options.allowGetBody);
@@ -515,6 +519,15 @@ export default class Request extends Duplex {
             // Serialize body
             const noContentType = !is.string(headers['content-type']);
             if (isBody) {
+                // Body is spec-compliant FormData
+                if (isFormDataLike(options.body)) {
+                    const encoder = new FormDataEncoder(options.body);
+                    if (noContentType) {
+                        headers['content-type'] = encoder.headers['Content-Type'];
+                    }
+                    headers['content-length'] = encoder.headers['Content-Length'];
+                    options.body = encoder.encode();
+                }
                 // Special case for https://github.com/form-data/form-data
                 if (isFormData(options.body) && noContentType) {
                     headers['content-type'] = `multipart/form-data; boundary=${options.body.getBoundary()}`;
@@ -837,7 +850,7 @@ export default class Request extends Duplex {
                 if (is.promise(result)) {
                     // We only need to implement the error handler in order to support HTTP2 caching.
                     // The result will be a promise anyway.
-                    // @ts-expect-error
+                    // @ts-expect-error ignore
                     // eslint-disable-next-line @typescript-eslint/promise-function-async
                     result.once = (event, handler) => {
                         if (event === 'error') {
@@ -901,7 +914,7 @@ export default class Request extends Duplex {
     }
     async _makeRequest() {
         const { options } = this;
-        const { headers } = options;
+        const { headers, username, password } = options;
         const cookieJar = options.cookieJar;
         for (const key in headers) {
             if (is.undefined(headers[key])) {
@@ -915,6 +928,10 @@ export default class Request extends Duplex {
         if (options.decompress && is.undefined(headers['accept-encoding'])) {
             headers['accept-encoding'] = supportsBrotli ? 'gzip, deflate, br' : 'gzip, deflate';
         }
+        if (username || password) {
+            const credentials = Buffer.from(`${username}:${password}`).toString('base64');
+            headers.authorization = `Basic ${credentials}`;
+        }
         // Set cookies
         if (cookieJar) {
             const cookieString = await cookieJar.getCookieString(options.url.toString());
@@ -947,10 +964,18 @@ export default class Request extends Duplex {
         // Cache support
         const fn = options.cache ? this._createCacheableRequest : request;
         try {
-            let requestOrResponse = await fn(url, this._requestOptions);
+            // We can't do `await fn(...)`,
+            // because stream `error` event can be emitted before `Promise.resolve()`.
+            let requestOrResponse = fn(url, this._requestOptions);
+            if (is.promise(requestOrResponse)) {
+                requestOrResponse = await requestOrResponse;
+            }
             // Fallback
             if (is.undefined(requestOrResponse)) {
-                requestOrResponse = await options.getFallbackRequestFunction()(url, this._requestOptions);
+                requestOrResponse = options.getFallbackRequestFunction()(url, this._requestOptions);
+                if (is.promise(requestOrResponse)) {
+                    requestOrResponse = await requestOrResponse;
+                }
             }
             if (isClientRequest(requestOrResponse)) {
                 this._onRequest(requestOrResponse);