got 14.5.0 → 14.6.1

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

@@ -18,12 +18,14 @@ export default function asPromise(firstRequest) {
     let globalResponse;
     let normalizedOptions;
     const emitter = new EventEmitter();
+    let promiseSettled = false;
     const promise = new PCancelable((resolve, reject, onCancel) => {
         onCancel(() => {
             globalRequest.destroy();
         });
         onCancel.shouldReject = false;
         onCancel(() => {
+            promiseSettled = true;
             reject(new CancelError(globalRequest));
         });
         const makeRequest = (retryCount) => {
@@ -38,7 +40,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 === 'deflate' || contentEncoding === 'br';
+                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br' || contentEncoding === 'zstd';
                 const { options } = request;
                 if (isCompressed && !options.decompress) {
                     response.body = response.rawBody;
@@ -82,7 +84,7 @@ export default function asPromise(firstRequest) {
                             }
                             throw new RetryError(request);
                         });
-                        if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {
+                        if (!(is.object(response) && is.number(response.statusCode) && 'body' in response)) {
                             throw new TypeError('The `afterResponse` hook returned an invalid value');
                         }
                     }
@@ -97,12 +99,27 @@ export default function asPromise(firstRequest) {
                     return;
                 }
                 request.destroy();
+                promiseSettled = true;
                 resolve(request.options.resolveBodyOnly ? response.body : response);
             });
+            let handledFinalError = false;
             const onError = (error) => {
                 if (promise.isCanceled) {
                     return;
                 }
+                // Route errors emitted directly on the stream (e.g., EPIPE from Node.js)
+                // through retry logic first, then handle them here after retries are exhausted.
+                // See https://github.com/sindresorhus/got/issues/1995
+                if (!request._stopReading) {
+                    request._beforeError(error);
+                    return;
+                }
+                // Allow the manual re-emission from Request to land only once.
+                if (handledFinalError) {
+                    return;
+                }
+                handledFinalError = true;
+                promiseSettled = true;
                 const { options } = request;
                 if (error instanceof HTTPError && !options.throwHttpErrors) {
                     const { response } = error;
@@ -112,10 +129,21 @@ export default function asPromise(firstRequest) {
                 }
                 reject(error);
             };
-            request.once('error', onError);
+            // Use .on() instead of .once() to keep the listener active across retries.
+            // When _stopReading is false, we return early and the error gets re-emitted
+            // after retry logic completes, so we need this listener to remain active.
+            // See https://github.com/sindresorhus/got/issues/1995
+            request.on('error', onError);
             const previousBody = request.options?.body;
             request.once('retry', (newRetryCount, error) => {
                 firstRequest = undefined;
+                // If promise already settled, don't retry
+                // This prevents the race condition in #1489 where a late error
+                // (e.g., ECONNRESET after successful response) triggers retry
+                // after the promise has already resolved/rejected
+                if (promiseSettled) {
+                    return;
+                }
                 const newBody = request.options.body;
                 if (previousBody === newBody && is.nodeStream(newBody)) {
                     error.message = 'Cannot retry with consumed body stream';
@@ -142,27 +170,35 @@ export default function asPromise(firstRequest) {
         emitter.off(event, function_);
         return promise;
     };
-    const shortcut = (responseType) => {
+    const shortcut = (promiseToAwait, responseType) => {
         const newPromise = (async () => {
             // Wait until downloading has ended
-            await promise;
+            await promiseToAwait;
             const { options } = globalResponse.request;
             return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
         })();
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
+        Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promiseToAwait));
         return newPromise;
     };
-    promise.json = () => {
+    // Note: These use `function` syntax (not arrows) to access `this` context.
+    // When custom handlers wrap the promise to transform errors, these methods
+    // are copied to the handler's promise. Using `this` ensures we await the
+    // handler's wrapped promise, not the original, so errors propagate correctly.
+    promise.json = function () {
         if (globalRequest.options) {
             const { headers } = globalRequest.options;
             if (!globalRequest.writableFinished && !('accept' in headers)) {
                 headers.accept = 'application/json';
             }
         }
-        return shortcut('json');
+        return shortcut(this, 'json');
+    };
+    promise.buffer = function () {
+        return shortcut(this, 'buffer');
+    };
+    promise.text = function () {
+        return shortcut(this, 'text');
     };
-    promise.buffer = () => shortcut('buffer');
-    promise.text = () => shortcut('text');
     return promise;
 }

package/dist/source/core/diagnostics-channel.d.ts

@@ -0,0 +1,89 @@
+import type { Timings } from '@szmarczak/http-timer';
+import type { RequestError } from './errors.js';
+export type RequestId = string;
+/**
+Message for the `got:request:create` diagnostic channel.
+
+Emitted when a request is created.
+*/
+export type DiagnosticRequestCreate = {
+    requestId: RequestId;
+    url: string;
+    method: string;
+};
+/**
+Message for the `got:request:start` diagnostic channel.
+
+Emitted before the native HTTP request is sent.
+*/
+export type DiagnosticRequestStart = {
+    requestId: RequestId;
+    url: string;
+    method: string;
+    headers: Record<string, string | string[] | undefined>;
+};
+/**
+Message for the `got:response:start` diagnostic channel.
+
+Emitted when response headers are received.
+*/
+export type DiagnosticResponseStart = {
+    requestId: RequestId;
+    url: string;
+    statusCode: number;
+    headers: Record<string, string | string[] | undefined>;
+    isFromCache: boolean;
+};
+/**
+Message for the `got:response:end` diagnostic channel.
+
+Emitted when the response completes.
+*/
+export type DiagnosticResponseEnd = {
+    requestId: RequestId;
+    url: string;
+    statusCode: number;
+    bodySize?: number;
+    timings?: Timings;
+};
+/**
+Message for the `got:request:retry` diagnostic channel.
+
+Emitted when retrying a request.
+*/
+export type DiagnosticRequestRetry = {
+    requestId: RequestId;
+    retryCount: number;
+    error: RequestError;
+    delay: number;
+};
+/**
+Message for the `got:request:error` diagnostic channel.
+
+Emitted when a request fails.
+*/
+export type DiagnosticRequestError = {
+    requestId: RequestId;
+    url: string;
+    error: RequestError;
+    timings?: Timings;
+};
+/**
+Message for the `got:response:redirect` diagnostic channel.
+
+Emitted when following a redirect.
+*/
+export type DiagnosticResponseRedirect = {
+    requestId: RequestId;
+    fromUrl: string;
+    toUrl: string;
+    statusCode: number;
+};
+export declare function generateRequestId(): RequestId;
+export declare function publishRequestCreate(message: DiagnosticRequestCreate): void;
+export declare function publishRequestStart(message: DiagnosticRequestStart): void;
+export declare function publishResponseStart(message: DiagnosticResponseStart): void;
+export declare function publishResponseEnd(message: DiagnosticResponseEnd): void;
+export declare function publishRetry(message: DiagnosticRequestRetry): void;
+export declare function publishError(message: DiagnosticRequestError): void;
+export declare function publishRedirect(message: DiagnosticResponseRedirect): void;

package/dist/source/core/diagnostics-channel.js

@@ -0,0 +1,49 @@
+import { randomUUID } from 'node:crypto';
+import diagnosticsChannel from 'node:diagnostics_channel';
+const channels = {
+    requestCreate: diagnosticsChannel.channel('got:request:create'),
+    requestStart: diagnosticsChannel.channel('got:request:start'),
+    responseStart: diagnosticsChannel.channel('got:response:start'),
+    responseEnd: diagnosticsChannel.channel('got:response:end'),
+    retry: diagnosticsChannel.channel('got:request:retry'),
+    error: diagnosticsChannel.channel('got:request:error'),
+    redirect: diagnosticsChannel.channel('got:response:redirect'),
+};
+export function generateRequestId() {
+    return randomUUID();
+}
+export function publishRequestCreate(message) {
+    if (channels.requestCreate.hasSubscribers) {
+        channels.requestCreate.publish(message);
+    }
+}
+export function publishRequestStart(message) {
+    if (channels.requestStart.hasSubscribers) {
+        channels.requestStart.publish(message);
+    }
+}
+export function publishResponseStart(message) {
+    if (channels.responseStart.hasSubscribers) {
+        channels.responseStart.publish(message);
+    }
+}
+export function publishResponseEnd(message) {
+    if (channels.responseEnd.hasSubscribers) {
+        channels.responseEnd.publish(message);
+    }
+}
+export function publishRetry(message) {
+    if (channels.retry.hasSubscribers) {
+        channels.retry.publish(message);
+    }
+}
+export function publishError(message) {
+    if (channels.error.hasSubscribers) {
+        channels.error.publish(message);
+    }
+}
+export function publishRedirect(message) {
+    if (channels.redirect.hasSubscribers) {
+        channels.redirect.publish(message);
+    }
+}

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

@@ -9,8 +9,9 @@ An error to be thrown when a request fails.
 Contains a `code` property with error class code, like `ECONNREFUSED`.
 */
 export declare class RequestError<T = unknown> extends Error {
-    input?: string;
+    name: string;
     code: string;
+    input?: string;
     stack: string;
     readonly options: Options;
     readonly response?: Response<T>;
@@ -25,6 +26,8 @@ An error to be thrown when the server redirects you more than ten times.
 Includes a `response` property.
 */
 export declare class MaxRedirectsError extends RequestError {
+    name: string;
+    code: string;
     readonly response: Response;
     readonly request: Request;
     readonly timings: Timings;
@@ -35,6 +38,8 @@ An error to be thrown when the server response code is not 2xx nor 3xx if `optio
 Includes a `response` property.
 */
 export declare class HTTPError<T = any> extends RequestError<T> {
+    name: string;
+    code: string;
     readonly response: Response<T>;
     readonly request: Request;
     readonly timings: Timings;
@@ -45,6 +50,7 @@ An error to be thrown when a cache method fails.
 For example, if the database goes down or there's a filesystem error.
 */
 export declare class CacheError extends RequestError {
+    name: string;
     readonly request: Request;
     constructor(error: Error, request: Request);
 }
@@ -52,6 +58,7 @@ export declare class CacheError extends RequestError {
 An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
 */
 export declare class UploadError extends RequestError {
+    name: string;
     readonly request: Request;
     constructor(error: Error, request: Request);
 }
@@ -60,6 +67,7 @@ An error to be thrown when the request is aborted due to a timeout.
 Includes an `event` and `timings` property.
 */
 export declare class TimeoutError extends RequestError {
+    name: string;
     readonly request: Request;
     readonly timings: Timings;
     readonly event: string;
@@ -69,6 +77,7 @@ export declare class TimeoutError extends RequestError {
 An error to be thrown when reading from response stream fails.
 */
 export declare class ReadError extends RequestError {
+    name: string;
     readonly request: Request;
     readonly response: Response;
     readonly timings: Timings;
@@ -78,12 +87,16 @@ export declare class ReadError extends RequestError {
 An error which always triggers a new retry when thrown.
 */
 export declare class RetryError extends RequestError {
+    name: string;
+    code: string;
     constructor(request: Request);
 }
 /**
 An error to be thrown when the request is aborted by AbortController.
 */
 export declare class AbortError extends RequestError {
+    name: string;
+    code: string;
     constructor(request: Request);
 }
 export {};

package/dist/source/core/errors.js

@@ -8,8 +8,9 @@ An error to be thrown when a request fails.
 Contains a `code` property with error class code, like `ECONNREFUSED`.
 */
 export class RequestError extends Error {
+    name = 'RequestError';
+    code = 'ERR_GOT_REQUEST_ERROR';
     input;
-    code;
     stack;
     response;
     request;
@@ -17,8 +18,9 @@ export class RequestError extends Error {
     constructor(message, error, self) {
         super(message, { cause: error });
         Error.captureStackTrace(this, this.constructor);
-        this.name = 'RequestError';
-        this.code = error.code ?? 'ERR_GOT_REQUEST_ERROR';
+        if (error.code) {
+            this.code = error.code;
+        }
         this.input = error.input;
         if (isRequest(self)) {
             Object.defineProperty(this, 'request', {
@@ -53,10 +55,10 @@ An error to be thrown when the server redirects you more than ten times.
 Includes a `response` property.
 */
 export class MaxRedirectsError extends RequestError {
+    name = 'MaxRedirectsError';
+    code = 'ERR_TOO_MANY_REDIRECTS';
     constructor(request) {
         super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
-        this.name = 'MaxRedirectsError';
-        this.code = 'ERR_TOO_MANY_REDIRECTS';
     }
 }
 /**
@@ -66,10 +68,10 @@ Includes a `response` property.
 // TODO: Change `HTTPError<T = any>` to `HTTPError<T = unknown>` in the next major version to enforce type usage.
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export class HTTPError extends RequestError {
+    name = 'HTTPError';
+    code = 'ERR_NON_2XX_3XX_RESPONSE';
     constructor(response) {
-        super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);
-        this.name = 'HTTPError';
-        this.code = 'ERR_NON_2XX_3XX_RESPONSE';
+        super(`Request failed with status code ${response.statusCode} (${response.statusMessage}): ${response.request.options.method} ${response.request.options.url.toString()}`, {}, response.request);
     }
 }
 /**
@@ -77,20 +79,24 @@ An error to be thrown when a cache method fails.
 For example, if the database goes down or there's a filesystem error.
 */
 export class CacheError extends RequestError {
+    name = 'CacheError';
     constructor(error, request) {
         super(error.message, error, request);
-        this.name = 'CacheError';
-        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_CACHE_ACCESS' : this.code;
+        if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+            this.code = 'ERR_CACHE_ACCESS';
+        }
     }
 }
 /**
 An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
 */
 export class UploadError extends RequestError {
+    name = 'UploadError';
     constructor(error, request) {
         super(error.message, error, request);
-        this.name = 'UploadError';
-        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_UPLOAD' : this.code;
+        if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+            this.code = 'ERR_UPLOAD';
+        }
     }
 }
 /**
@@ -98,11 +104,11 @@ An error to be thrown when the request is aborted due to a timeout.
 Includes an `event` and `timings` property.
 */
 export class TimeoutError extends RequestError {
+    name = 'TimeoutError';
     timings;
     event;
     constructor(error, timings, request) {
         super(error.message, error, request);
-        this.name = 'TimeoutError';
         this.event = error.event;
         this.timings = timings;
     }
@@ -111,29 +117,31 @@ export class TimeoutError extends RequestError {
 An error to be thrown when reading from response stream fails.
 */
 export class ReadError extends RequestError {
+    name = 'ReadError';
     constructor(error, request) {
         super(error.message, error, request);
-        this.name = 'ReadError';
-        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_READING_RESPONSE_STREAM' : this.code;
+        if (this.code === 'ERR_GOT_REQUEST_ERROR') {
+            this.code = 'ERR_READING_RESPONSE_STREAM';
+        }
     }
 }
 /**
 An error which always triggers a new retry when thrown.
 */
 export class RetryError extends RequestError {
+    name = 'RetryError';
+    code = 'ERR_RETRYING';
     constructor(request) {
         super('Retrying', {}, request);
-        this.name = 'RetryError';
-        this.code = 'ERR_RETRYING';
     }
 }
 /**
 An error to be thrown when the request is aborted by AbortController.
 */
 export class AbortError extends RequestError {
+    name = 'AbortError';
+    code = 'ERR_ABORTED';
     constructor(request) {
         super('This operation was aborted.', {}, request);
-        this.code = 'ERR_ABORTED';
-        this.name = 'AbortError';
     }
 }

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

@@ -88,11 +88,11 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     requestUrl?: URL;
     redirectUrls: URL[];
     retryCount: number;
+    _stopReading: boolean;
     private _requestOptions;
     private _stopRetry;
     private _downloadedSize;
     private _uploadedSize;
-    private _stopReading;
     private readonly _pipedServerResponses;
     private _request?;
     private _responseSize?;
@@ -106,6 +106,9 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     private _nativeResponse?;
     private _flushed;
     private _aborted;
+    private _expectedContentLength?;
+    private _byteCounter?;
+    private readonly _requestId;
     private _requestInitialized;
     constructor(url: UrlType, options?: OptionsType, defaults?: DefaultsType);
     flush(): Promise<void>;
@@ -118,6 +121,7 @@ export default class Request extends Duplex implements RequestEvents<Request> {
         end?: boolean;
     }): T;
     unpipe<T extends NodeJS.WritableStream>(destination: T): this;
+    private _checkContentLengthMismatch;
     private _finalizeBody;
     private _onResponseBase;
     private _setRawBody;
@@ -180,5 +184,9 @@ export default class Request extends Duplex implements RequestEvents<Request> {
     */
     get isFromCache(): boolean | undefined;
     get reusedSocket(): boolean | undefined;
+    /**
+    Whether the stream is read-only. Returns `true` when `body`, `json`, or `form` options are provided.
+    */
+    get isReadonly(): boolean;
 }
 export {};