UNPKG

@reduxjs/toolkit

Version:

The official, opinionated, batteries-included toolset for efficient Redux development

249 lines (224 loc) • 7.2 kB
import type { BaseQueryApi, BaseQueryArg, BaseQueryEnhancer, BaseQueryError, BaseQueryExtraOptions, BaseQueryFn, BaseQueryMeta, } from './baseQueryTypes' import type { FetchBaseQueryError } from './fetchBaseQuery' import { HandledError } from './HandledError' /** * Exponential backoff based on the attempt number. * * @remarks * 1. 600ms * random(0.4, 1.4) * 2. 1200ms * random(0.4, 1.4) * 3. 2400ms * random(0.4, 1.4) * 4. 4800ms * random(0.4, 1.4) * 5. 9600ms * random(0.4, 1.4) * * @param attempt - Current attempt * @param maxRetries - Maximum number of retries */ async function defaultBackoff( attempt: number = 0, maxRetries: number = 5, signal?: AbortSignal, ) { const attempts = Math.min(attempt, maxRetries) const timeout = ~~((Math.random() + 0.4) * (300 << attempts)) // Force a positive int in the case we make this an option await new Promise<void>((resolve, reject) => { const timeoutId = setTimeout(() => resolve(), timeout) // If signal is provided and gets aborted, clear timeout and reject if (signal) { const abortHandler = () => { clearTimeout(timeoutId) reject(new Error('Aborted')) } // Check if already aborted if (signal.aborted) { clearTimeout(timeoutId) reject(new Error('Aborted')) } else { signal.addEventListener('abort', abortHandler, { once: true }) } } }) } type RetryConditionFunction = ( error: BaseQueryError<BaseQueryFn>, args: BaseQueryArg<BaseQueryFn>, extraArgs: { attempt: number baseQueryApi: BaseQueryApi extraOptions: BaseQueryExtraOptions<BaseQueryFn> & RetryOptions }, ) => boolean export type RetryOptions = { /** * Function used to determine delay between retries */ backoff?: ( attempt: number, maxRetries: number, signal?: AbortSignal, ) => Promise<void> } & ( | { /** * How many times the query will be retried (default: 5) */ maxRetries?: number retryCondition?: undefined } | { /** * Callback to determine if a retry should be attempted. * Return `true` for another retry and `false` to quit trying prematurely. */ retryCondition?: RetryConditionFunction maxRetries?: undefined } ) function fail<BaseQuery extends BaseQueryFn = BaseQueryFn>( error: BaseQueryError<BaseQuery>, meta?: BaseQueryMeta<BaseQuery>, ): never { throw Object.assign(new HandledError({ error, meta }), { throwImmediately: true, }) } /** * Checks if the abort signal is aborted and fails immediately if so. * Used to exit retry loops cleanly when a request is aborted. */ function failIfAborted(signal: AbortSignal): void { if (signal.aborted) { fail({ status: 'CUSTOM_ERROR', error: 'Aborted' }) } } const EMPTY_OPTIONS = {} const retryWithBackoff: BaseQueryEnhancer< unknown, RetryOptions, RetryOptions | void > = (baseQuery, defaultOptions) => async (args, api, extraOptions) => { const baseOptions: RetryOptions = defaultOptions || EMPTY_OPTIONS const endpointOptions: RetryOptions = extraOptions || EMPTY_OPTIONS const maxRetries = endpointOptions.maxRetries ?? baseOptions.maxRetries ?? 5 const defaultRetryCondition: RetryConditionFunction = (_, __, { attempt }) => attempt <= maxRetries const baseRetryCondition = baseOptions.retryCondition // `maxRetries` only limits expected errors through the default condition. // When an endpoint sets it, a `retryCondition` from `retry()` still decides // which errors are retried, and the endpoint's limit caps the retries. const endpointMaxRetriesCondition: RetryConditionFunction | undefined = endpointOptions.maxRetries !== undefined && baseRetryCondition ? (error, args, extraArgs) => defaultRetryCondition(error, args, extraArgs) && baseRetryCondition(error, args, extraArgs) : undefined const options = { maxRetries, backoff: endpointOptions.backoff ?? baseOptions.backoff ?? defaultBackoff, retryCondition: endpointOptions.retryCondition ?? endpointMaxRetriesCondition ?? baseRetryCondition ?? defaultRetryCondition, } let retry = 0 while (true) { // Check if aborted before each attempt failIfAborted(api.signal) try { const result = await baseQuery(args, api, extraOptions) // baseQueries _should_ return an error property, so we should check for that and throw it to continue retrying if (result.error) { throw new HandledError(result) } return result } catch (e: any) { retry++ if (e.throwImmediately) { if (e instanceof HandledError) { return e.value } // We don't know what this is, so we have to rethrow it throw e } try { if (e instanceof HandledError) { if ( !options.retryCondition( e.value.error as FetchBaseQueryError, args, { attempt: retry, baseQueryApi: api, extraOptions, }, ) ) { return e.value // Max retries for expected error } } else { // For unexpected errors, respect maxRetries if (retry > options.maxRetries) { // Return the error as a proper error response instead of throwing return { error: e } } } // Check if aborted before backoff failIfAborted(api.signal) await options.backoff(retry, options.maxRetries, api.signal) } catch (handlerError: any) { // If the request was aborted, exit the retry loop failIfAborted(api.signal) // `retry.fail()` called from `retryCondition` or `backoff` if ( handlerError.throwImmediately && handlerError instanceof HandledError ) { return handlerError.value } throw handlerError } } } } /** * A utility that can wrap `baseQuery` in the API definition to provide retries with a basic exponential backoff. * * @example * * ```ts * // codeblock-meta title="Retry every request 5 times by default" * import { createApi, fetchBaseQuery, retry } from '@reduxjs/toolkit/query/react' * interface Post { * id: number * name: string * } * type PostsResponse = Post[] * * // maxRetries: 5 is the default, and can be omitted. Shown for documentation purposes. * const staggeredBaseQuery = retry(fetchBaseQuery({ baseUrl: '/' }), { maxRetries: 5 }); * export const api = createApi({ * baseQuery: staggeredBaseQuery, * endpoints: (build) => ({ * getPosts: build.query<PostsResponse, void>({ * query: () => ({ url: 'posts' }), * }), * getPost: build.query<PostsResponse, string>({ * query: (id) => ({ url: `post/${id}` }), * extraOptions: { maxRetries: 8 }, // You can override the retry behavior on each endpoint * }), * }), * }); * * export const { useGetPostsQuery, useGetPostQuery } = api; * ``` */ export const retry = /* @__PURE__ */ Object.assign(retryWithBackoff, { fail })