Support AbortController

documentation/2-options.md

@@ -209,6 +209,29 @@ await got('https://httpbin.org/anything');
 #### **Note:**
 > - If you're passing an absolute URL as `url`, you need to set `prefixUrl` to an empty string.
 
+
+### `signal`
+
+**Type: [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)**
+
+You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
+
+*Requires Node.js 16 or later.*
+
+```js
+import got from 'got';
+
+const abortController = new AbortController();
+
+const request = got('https://httpbin.org/anything', {
+	signal: abortController.signal
+});
+
+setTimeout(() => {
+	abortController.abort();
+}, 100);
+```
+
 ### `method`
 
 **Type: `string`**\

source/as-promise/index.ts

@@ -5,6 +5,7 @@ import {
 	RequestError,
 	HTTPError,
 	RetryError,
+	AbortError,
 } from '../core/errors.js';
 import Request from '../core/index.js';
 import {parseBody, isResponseOk} from '../core/response.js';
@@ -22,13 +23,39 @@ const proxiedRequestEvents = [
 	'downloadProgress',
 ];
 
-export default function asPromise<T>(firstRequest?: Request): CancelableRequest<T> {
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const getDOMException = (errorMessage: string) => globalThis.DOMException === undefined
+	? new AbortError(errorMessage)
+	: new DOMException(errorMessage);
+
+const getAbortedReason = (signal: AbortSignal) => {
+	// To do: Remove below any castings when '@types/node' targets 18
+	const reason = (signal as any).reason === undefined
+		? getDOMException('This operation was aborted.')
+		: (signal as any).reason;
+
+	return reason instanceof Error ? reason : getDOMException(reason);
+};
+
+export default function asPromise<T>(firstRequest?: Request, signal?: AbortSignal): CancelableRequest<T> {
 	let globalRequest: Request;
 	let globalResponse: Response;
 	let normalizedOptions: Options;
 	const emitter = new EventEmitter();
 
 	const promise = new PCancelable<T>((resolve, reject, onCancel) => {
+		if (signal) {
+			if (signal.aborted) {
+				globalRequest.destroy();
+				reject(getAbortedReason(signal));
+			}
+
+			signal.addEventListener('abort', () => {
+				globalRequest.destroy();
+				reject(getAbortedReason(signal));
+			});
+		}
+
 		onCancel(() => {
 			globalRequest.destroy();
 		});

source/core/errors.ts

@@ -170,3 +170,15 @@ export class RetryError extends RequestError {
 		this.code = 'ERR_RETRYING';
 	}
 }
+
+/**
+An error to be thrown when the request is aborted by AbortController.
+DOMException is thrown instead of this Error when DOMException is available.
+*/
+export class AbortError extends Error {
+	constructor(message: string) {
+		super();
+		this.name = 'AbortError';
+		this.message = message;
+	}
+}

source/core/options.ts

@@ -827,6 +827,7 @@ const defaultInternals: Options['_internals'] = {
 	},
 	setHost: true,
 	maxHeaderSize: undefined,
+	signal: undefined,
 };
 
 const cloneInternals = (internals: typeof defaultInternals) => {
@@ -1484,6 +1485,36 @@ export default class Options {
 		}
 	}
 
+	/**
+	You can abort the `request` using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
+
+	**Requires Node.js 16 or later.*
+
+	@example
+	```
+	import got from 'got';
+
+	const abortController = new AbortController();
+
+	const request = got('https://httpbin.org/anything', {
+		signal: abortController.signal
+	});
+
+	setTimeout(() => {
+		abortController.abort();
+	}, 100);
+	```
+	*/
+	get signal(): AbortSignal | undefined {
+		return this._internals.signal;
+	}
+
+	set signal(value: AbortSignal | undefined) {
+		assert.object(value);
+
+		this._internals.signal = value;
+	}
+
 	/**
 	Ignore invalid cookies instead of throwing an error.
 	Only useful when the `cookieJar` option has been set. Not recommended.
@@ -2410,6 +2441,7 @@ export default class Options {
 			headers: internals.headers,
 			createConnection: internals.createConnection,
 			timeout: internals.http2 ? getHttp2TimeoutOption(internals) : undefined,
+			signal: internals.signal,
 
 			// HTTP/2 options
 			h2session: internals.h2session,
@@ -2473,5 +2505,6 @@ export default class Options {
 		Object.freeze(options.retry.methods);
 		Object.freeze(options.retry.statusCodes);
 		Object.freeze(options.context);
+		Object.freeze(options.signal);
 	}
 }

source/create.ts

@@ -34,6 +34,20 @@ const aliases: readonly HTTPAlias[] = [
 	'delete',
 ];
 
+const getSignal = (url: string | URL | OptionsInit | undefined, options?: OptionsInit): AbortSignal | undefined => {
+	let signal;
+
+	if (typeof url === 'object' && 'signal' in (url as OptionsInit)) {
+		signal = (url as OptionsInit).signal;
+	}
+
+	if (options?.signal) {
+		signal = options.signal;
+	}
+
+	return signal;
+};
+
 const create = (defaults: InstanceDefaults): Got => {
 	defaults = {
 		options: new Options(undefined, undefined, defaults.options),
@@ -52,6 +66,8 @@ const create = (defaults: InstanceDefaults): Got => {
 		const request = new Request(url, options, defaultOptions);
 		let promise: CancelableRequest | undefined;
 
+		const signal = getSignal(url, options);
+
 		const lastHandler = (normalized: Options): GotReturn => {
 			// Note: `options` is `undefined` when `new Options(...)` fails
 			request.options = normalized;
@@ -63,7 +79,7 @@ const create = (defaults: InstanceDefaults): Got => {
 			}
 
 			if (!promise) {
-				promise = asPromise(request);
+				promise = asPromise(request, signal);
 			}
 
 			return promise;
@@ -77,7 +93,7 @@ const create = (defaults: InstanceDefaults): Got => {
 
 			if (is.promise(result) && !request.options.isStream) {
 				if (!promise) {
-					promise = asPromise(request);
+					promise = asPromise(request, signal);
 				}
 
 				if (result !== promise) {