Fix race condition causing retry after promise settles

Fixes #1489

Author: sindresorhus

source/as-promise/index.ts

@@ -29,6 +29,7 @@ export default function asPromise<T>(firstRequest?: Request): CancelableRequest<
 	let globalResponse: Response;
 	let normalizedOptions: Options;
 	const emitter = new EventEmitter();
+	let promiseSettled = false;
 
 	const promise = new PCancelable<T>((resolve, reject, onCancel) => {
 		onCancel(() => {
@@ -37,6 +38,7 @@ export default function asPromise<T>(firstRequest?: Request): CancelableRequest<
 
 		onCancel.shouldReject = false;
 		onCancel(() => {
+			promiseSettled = true;
 			reject(new CancelError(globalRequest));
 		});
 
@@ -123,6 +125,7 @@ export default function asPromise<T>(firstRequest?: Request): CancelableRequest<
 				}
 
 				request.destroy();
+				promiseSettled = true;
 				resolve(request.options.resolveBodyOnly ? response.body as T : response as unknown as T);
 			});
 
@@ -148,6 +151,7 @@ export default function asPromise<T>(firstRequest?: Request): CancelableRequest<
 
 				handledFinalError = true;
 
+				promiseSettled = true;
 				const {options} = request;
 
 				if (error instanceof HTTPError && !options.throwHttpErrors) {
@@ -172,6 +176,14 @@ export default function asPromise<T>(firstRequest?: Request): CancelableRequest<
 			request.once('retry', (newRetryCount: number, error: RequestError) => {
 				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)) {

test/retry.ts

@@ -838,3 +838,59 @@ test('does not retry on stream errors when not in errorCodes', async t => {
 	t.is(attemptCount, 1);
 	t.is(error?.code, 'ETEST');
 });
+
+test('does not retry after promise settles (issue #1489)', async t => {
+	let retryTriggered = false;
+
+	const response = await got('https://example.com', {
+		retry: {limit: 2, errorCodes: ['ECONNRESET']},
+		hooks: {
+			beforeRetry: [() => {
+				retryTriggered = true;
+			}],
+		},
+		request() {
+			const emitter = new EventEmitter() as http.ClientRequest;
+			emitter.abort = () => {};
+			// @ts-expect-error Imitating a stream
+			emitter.end = () => {};
+			emitter.destroyed = false;
+			// @ts-expect-error Imitating a stream
+			emitter.destroy = () => {
+				emitter.destroyed = true;
+			};
+
+			emitter.write = () => true;
+			// @ts-expect-error Imitating a stream
+			emitter.writable = true;
+			// @ts-expect-error Imitating a stream
+			emitter.writableEnded = false;
+
+			setTimeout(() => {
+				const incomingMessage = new PassThroughStream() as unknown as http.IncomingMessage;
+				incomingMessage.statusCode = 200;
+				incomingMessage.headers = {};
+
+				emitter.emit('response', incomingMessage);
+
+				setImmediate(() => {
+					// @ts-expect-error PassThrough method
+					incomingMessage.end('ok');
+				});
+
+				// Late error after response - should NOT trigger retry
+				setTimeout(() => {
+					const error = new Error('read ECONNRESET');
+					(error as NodeJS.ErrnoException).code = 'ECONNRESET';
+					emitter.emit('error', error);
+				}, 10);
+			});
+
+			return emitter;
+		},
+		throwHttpErrors: false,
+	});
+
+	t.is(response.statusCode, 200);
+	t.false(retryTriggered);
+});