UNPKG

@reduxjs/toolkit

Version:

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

332 lines (297 loc) • 10.2 kB
import type { QueryCacheEntry, QueryCacheKey, QueryStatus, QuerySubState, QuerySubstateIdentifier, Subscribers, SubscribersInternal, } from '../apiState' import type { QueryDefinition } from '../../endpointDefinitions' import { STATUS_PENDING, STATUS_UNINITIALIZED } from '../apiState' import { THIRTY_TWO_BIT_MAX_INT } from './cacheCollection' import type { QueryStateMeta, SubMiddlewareApi, TimeoutId, InternalHandlerBuilder, ApiMiddlewareInternalHandler, } from './types' import { clearPoll, setPoll } from './runtime' import type { QueryKeyRecord } from './runtime' type AnyQueryDefinition = QueryDefinition<any, any, any, any> type PollingIntervalFn = ( cacheEntry: QueryCacheEntry<AnyQueryDefinition>, ) => number type InitializedQuerySubState = Exclude< QuerySubState<AnyQueryDefinition>, { status: QueryStatus.uninitialized } > export const buildPollingHandler: InternalHandlerBuilder = ({ reducerPath, queryThunk, api, refetchQuery, runtime, }) => { const getSubscribers = (queryCacheKey: string) => runtime.queries.get(queryCacheKey)?.subscribers const { pendingPollingUpdates } = runtime // Results are per cache key, because one function can poll several keys const pollingIntervalResults = new WeakMap< QueryKeyRecord, WeakMap< PollingIntervalFn, { querySubState: InitializedQuerySubState; result: number } > >() function getPollingIntervalResults(queryCacheKey: string) { const record = runtime.queries.get(queryCacheKey) if (!record) return undefined let results = pollingIntervalResults.get(record) if (!results) { results = new WeakMap() pollingIntervalResults.set(record, results) } return results } const handler: ApiMiddlewareInternalHandler = (action, mwApi) => { if ( api.internalActions.updateSubscriptionOptions.match(action) || api.internalActions.unsubscribeQueryResult.match(action) ) { schedulePollingUpdate(action.payload.queryCacheKey, mwApi) } if ( queryThunk.pending.match(action) || (queryThunk.rejected.match(action) && action.meta.condition) ) { schedulePollingUpdate(action.meta.arg.queryCacheKey, mwApi) } if ( queryThunk.fulfilled.match(action) || (queryThunk.rejected.match(action) && !action.meta.condition) ) { startNextPoll(action.meta.arg, mwApi) } } function schedulePollingUpdate(queryCacheKey: string, api: SubMiddlewareApi) { if ( !runtime.queries.get(queryCacheKey)?.poll && !findPollingSubscribers(queryCacheKey).hasPollingSubscriber ) { return } pendingPollingUpdates.keys.add(queryCacheKey) if (!pendingPollingUpdates.timer) { pendingPollingUpdates.timer = setTimeout(() => { try { // Process all pending updates in a single batch for (const key of pendingPollingUpdates.keys) { updatePollingInterval({ queryCacheKey: key as any }, api) } } finally { pendingPollingUpdates.keys.clear() pendingPollingUpdates.timer = undefined } }, 0) } } function startNextPoll( { queryCacheKey }: QuerySubstateIdentifier, api: SubMiddlewareApi, delay?: number, ) { const state = api.getState()[reducerPath] const querySubState = state.queries[queryCacheKey] if (!querySubState || querySubState.status === STATUS_UNINITIALIZED) { cleanupPollForKey(queryCacheKey) return } const lowestPollingInterval = findLowestPollingInterval( getSubscribers(queryCacheKey), querySubState, queryCacheKey, ) if (!Number.isFinite(lowestPollingInterval)) { cleanupPollForKey(queryCacheKey) return } if ( process.env.NODE_ENV !== 'production' && lowestPollingInterval > THIRTY_TWO_BIT_MAX_INT ) { console.warn( `pollingInterval ${lowestPollingInterval} is larger than the maximum timer delay. Using ${THIRTY_TWO_BIT_MAX_INT} instead.`, ) } const pollingInterval = Math.min( lowestPollingInterval, THIRTY_TWO_BIT_MAX_INT, ) const timeoutMs = delay ?? pollingInterval const nextPollTimestamp = Date.now() + timeoutMs setPoll(runtime, queryCacheKey, { nextPollTimestamp, pollingInterval, timeout: setTimeout(() => { const currentState = api.getState()[reducerPath] const currentQuerySubState = currentState.queries[queryCacheKey] // The subscription map and cache entry may have changed since this // poll was scheduled, because unsubscribe cleanup is deferred. const { hasPollingSubscriber, skipPollingIfUnfocused } = findPollingSubscribers(queryCacheKey) if ( !currentQuerySubState || currentQuerySubState.status === STATUS_UNINITIALIZED || !hasPollingSubscriber ) { cleanupPollForKey(queryCacheKey) return } // The pending request's `fulfilled` or `rejected` action starts the next poll if (currentQuerySubState.status === STATUS_PENDING) { cleanupPollForKey(queryCacheKey) return } if (currentState.config.focused || !skipPollingIfUnfocused) { api.dispatch(refetchQuery(currentQuerySubState, 'poll')) } startNextPoll({ queryCacheKey }, api) }, timeoutMs), }) } function updatePollingInterval( { queryCacheKey }: QuerySubstateIdentifier, api: SubMiddlewareApi, ) { const state = api.getState()[reducerPath] const querySubState = state.queries[queryCacheKey] const subscriptions = getSubscribers(queryCacheKey) if (!querySubState || querySubState.status === STATUS_UNINITIALIZED) { return } if (process.env.NODE_ENV === 'test') { const updateCounters = (runtime.pollUpdateCounters ??= {}) updateCounters[queryCacheKey] = (updateCounters[queryCacheKey] ?? 0) + 1 } const lowestPollingInterval = findLowestPollingInterval( subscriptions, querySubState, queryCacheKey, ) if (!Number.isFinite(lowestPollingInterval)) { cleanupPollForKey(queryCacheKey) return } const currentPoll = runtime.queries.get(queryCacheKey)?.poll if (!currentPoll) { startNextPoll({ queryCacheKey }, api) return } const pollingInterval = Math.min( lowestPollingInterval, THIRTY_TWO_BIT_MAX_INT, ) if (pollingInterval > currentPoll.pollingInterval) { // A slower interval pushes the pending poll back, counting from when // the current wait started const lastPollStart = currentPoll.nextPollTimestamp - currentPoll.pollingInterval startNextPoll( { queryCacheKey }, api, lastPollStart + pollingInterval - Date.now(), ) } else if (Date.now() + pollingInterval < currentPoll.nextPollTimestamp) { startNextPoll({ queryCacheKey }, api) } } function cleanupPollForKey(key: string) { clearPoll(runtime, key) } // Does not call polling interval functions, so a function counts as polling. // Its `skipPollingIfUnfocused` only applies if its last result was a poll. // Polling is skipped while unfocused only if every polling subscriber skips. function findPollingSubscribers(queryCacheKey: string) { const subscribers = getSubscribers(queryCacheKey) ?? new Map() const results = getPollingIntervalResults(queryCacheKey) let hasPollingSubscriber = false let hasActivePoll = false let allActivePollsSkip = true for (const entry of subscribers.values()) { const { pollingInterval } = entry let isPolling: boolean if (typeof pollingInterval === 'function') { hasPollingSubscriber = true const previous = results?.get(pollingInterval) isPolling = !previous || isPositiveInterval(previous.result) } else { isPolling = isPositiveInterval(pollingInterval) hasPollingSubscriber ||= isPolling } if (isPolling) { hasActivePoll = true allActivePollsSkip &&= entry.skipPollingIfUnfocused === true } } return { hasPollingSubscriber, skipPollingIfUnfocused: hasActivePoll && allActivePollsSkip, } } function findLowestPollingInterval( subscribers: SubscribersInternal = new Map(), querySubState: InitializedQuerySubState, queryCacheKey: QueryCacheKey, ) { let lowestPollingInterval = Number.POSITIVE_INFINITY for (const { pollingInterval } of subscribers.values()) { let interval = pollingInterval if (typeof pollingInterval === 'function') { // The pending request's `fulfilled` or `rejected` action schedules // the next poll with the settled entry if (querySubState.status === STATUS_PENDING) continue interval = callPollingInterval( pollingInterval, querySubState, queryCacheKey, ) } if (isPositiveInterval(interval)) { lowestPollingInterval = Math.min(interval, lowestPollingInterval) } } return lowestPollingInterval } // Each function runs at most once per cache entry state function callPollingInterval( pollingInterval: PollingIntervalFn, querySubState: InitializedQuerySubState, queryCacheKey: QueryCacheKey, ) { const results = getPollingIntervalResults(queryCacheKey) const previous = results?.get(pollingInterval) if (previous?.querySubState === querySubState) { return previous.result } let result: number try { result = pollingInterval({ ...querySubState, queryCacheKey }) } catch (error) { if (process.env.NODE_ENV !== 'production') { console.error( `Error in pollingInterval function for "${queryCacheKey}". Polling is skipped for this subscriber until the cache entry changes.`, error, ) } result = 0 } results?.set(pollingInterval, { querySubState, result }) return result } return handler } function isPositiveInterval(interval: unknown): interval is number { return typeof interval === 'number' && interval > 0 }