feature: Add shouldRetry option

index.d.ts

@@ -41,6 +41,26 @@ export type Options = {
 	*/
 	readonly onFailedAttempt?: (error: FailedAttemptError) => void | Promise<void>;
 
+	/**
+	Decide if a retry should occur based on the error. Returning true triggers a retry, false aborts with the error.
+
+	@param error - The error thrown by the input function.
+
+	@example
+	```
+	import pRetry from 'p-retry';
+
+	const run = async () => { … };
+
+	const result = await pRetry(run, {
+		shouldRetry: error => !(error instanceof CustomError);
+	});
+	```
+
+	In the example above, the operation will be retried unless the error is an instance of `CustomError`.
+	*/
+	readonly shouldRetry?: (error: FailedAttemptError) => boolean | Promise<boolean>;
+
 	/**
 	You can abort retrying using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).
 

index.js

@@ -27,11 +27,14 @@ const decorateErrorWithCounts = (error, attemptNumber, options) => {
 	return error;
 };
 
+const shouldRetry = () => true;
+
 export default async function pRetry(input, options) {
 	return new Promise((resolve, reject) => {
 		options = {
 			onFailedAttempt() {},
 			retries: 10,
+			shouldRetry,
 			...options,
 		};
 
@@ -70,7 +73,14 @@ export default async function pRetry(input, options) {
 						throw error;
 					}
 
-					await options.onFailedAttempt(decorateErrorWithCounts(error, attemptNumber, options));
+					decorateErrorWithCounts(error, attemptNumber, options);
+
+					if (!(await options.shouldRetry(error))) {
+						operation.stop();
+						reject(error);
+					}
+
+					await options.onFailedAttempt(error);
 
 					if (!operation.retry(error)) {
 						throw operation.mainError();

test.js

@@ -277,3 +277,33 @@ test('preserves the abort reason', async t => {
 
 	t.is(index, 3);
 });
+
+test('should retry only when shouldRetry returns true', async t => {
+	t.plan(2);
+
+	const shouldRetryError = new Error('should-retry');
+	const customError = new Error('custom-error');
+
+	let index = 0;
+
+	try {
+		await pRetry(
+			async () => {
+				await delay(40);
+				index++;
+				const error = index < 3 ? shouldRetryError : customError;
+				throw error;
+			},
+			{
+				async shouldRetry(error) {
+					return error.message === shouldRetryError.message;
+				},
+				retries: 10,
+			},
+		);
+	} catch (error) {
+		t.is(error.message, customError.message);
+	}
+
+	t.is(index, 3);
+});