Major refactoring

readme.md

@@ -528,6 +528,8 @@ got.post('https://example.com', {
 });
 ```
 
+**Note:** When retrying in a `afterResponse` hook, all remaining `beforeRetry` hooks will be called without the `error` and `retryCount` arguments.
+
 ###### hooks.afterResponse
 
 Type: `Function[]`<br>

source/as-promise.ts

@@ -69,8 +69,9 @@ export default function asPromise(options: NormalizedOptions) {
 
 			try {
 				for (const [index, hook] of options.hooks.afterResponse.entries()) {
+					// @ts-ignore
 					// eslint-disable-next-line no-await-in-loop
-					response = await hook(response, updatedOptions => {
+					response = await hook(response, async (updatedOptions: NormalizedOptions) => {
 						updatedOptions = normalizeArguments(mergeOptions(options, {
 							...updatedOptions,
 							retry: {
@@ -85,7 +86,19 @@ export default function asPromise(options: NormalizedOptions) {
 						// The loop continues. We don't want duplicates (asPromise recursion).
 						updatedOptions.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
 
-						return asPromise(updatedOptions);
+						for (const hook of options.hooks.beforeRetry) {
+							// eslint-disable-next-line no-await-in-loop
+							await hook(updatedOptions);
+						}
+
+						const promise = asPromise(updatedOptions);
+
+						onCancel(() => {
+							promise.catch(() => {});
+							promise.cancel();
+						});
+
+						return promise;
 					});
 				}
 			} catch (error) {

source/known-hook-events.ts

@@ -25,7 +25,7 @@ export type BeforeRedirectHook = (options: NormalizedOptions, response: Response
 /**
 Called with normalized [request options](https://github.com/sindresorhus/got#options), the error and the retry count. Got will make no further changes to the request. This is especially useful when some extra work is required before the next try.
 */
-export type BeforeRetryHook = (options: NormalizedOptions, error: Error | GotError | ParseError | HTTPError | MaxRedirectsError, retryCount: number) => void | Promise<void>;
+export type BeforeRetryHook = (options: NormalizedOptions, error?: Error | GotError | ParseError | HTTPError | MaxRedirectsError, retryCount?: number) => void | Promise<void>;
 
 /**
 Called with an `Error` instance. The error is passed to the hook right before it's thrown. This is especially useful when you want to have more detailed errors.

test/hooks.ts

@@ -382,6 +382,44 @@ test('afterResponse allows to retry', withServer, async (t, server, got) => {
 	t.is(statusCode, 200);
 });
 
+test('afterResponse allows to retry - `beforeRetry` hook', withServer, async (t, server, got) => {
+	server.get('/', (request, response) => {
+		if (request.headers.token !== 'unicorn') {
+			response.statusCode = 401;
+		}
+
+		response.end();
+	});
+
+	let called = false;
+
+	const {statusCode} = await got({
+		hooks: {
+			afterResponse: [
+				(response, retryWithMergedOptions) => {
+					if (response.statusCode === 401) {
+						return retryWithMergedOptions({
+							headers: {
+								token: 'unicorn'
+							}
+						});
+					}
+
+					return response;
+				}
+			],
+			beforeRetry: [
+				options => {
+					t.truthy(options);
+					called = true;
+				}
+			]
+		}
+	});
+	t.is(statusCode, 200);
+	t.true(called);
+});
+
 test('no infinity loop when retrying on afterResponse', withServer, async (t, server, got) => {
 	server.get('/', (request, response) => {
 		if (request.headers.token !== 'unicorn') {