@reduxjs/toolkit
Version:
The official, opinionated, batteries-included toolset for efficient Redux development
447 lines (402 loc) • 13.7 kB
text/typescript
import type { InternalSerializeQueryArgs } from '../defaultSerializeQueryArgs'
import type {
EndpointDefinition,
EndpointDefinitions,
InfiniteQueryArgFrom,
InfiniteQueryDefinition,
MutationDefinition,
QueryArgFrom,
QueryArgFromAnyQuery,
QueryDefinition,
ReducerPathFrom,
TagDescription,
TagTypesFrom,
} from '../endpointDefinitions'
import { expandTagDescription } from '../endpointDefinitions'
import { filterMap, isNotNullish } from '../utils'
import type {
InfiniteData,
InfiniteQueryConfigOptions,
InfiniteQuerySubState,
MutationSubState,
QueryCacheEntry,
QueryCacheKey,
QueryState,
QuerySubState,
RequestStatusFlags,
WithRequestStatusFlags,
ApiRootState as _RootState,
QueryStatus,
} from './apiState'
import { STATUS_UNINITIALIZED, getRequestStatusFlags } from './apiState'
import { getMutationCacheKey } from './buildSlice'
import type { createSelector as _createSelector } from './rtkImports'
import { createNextState } from './rtkImports'
import {
type AllQueryKeys,
getNextPageParam,
getPreviousPageParam,
} from './buildThunks'
// `skipToken` lives in `../utils/skipToken` so that modules which `buildSelectors`
// already depends on (e.g. `buildThunks`) can import it without creating a cycle.
// Imported here as well as re-exported, because this module uses the symbol directly.
import type { SkipToken } from '../utils/skipToken'
import { skipToken } from '../utils/skipToken'
export { skipToken }
export type { SkipToken }
export type BuildSelectorsApiEndpointQuery<
Definition extends QueryDefinition<any, any, any, any, any>,
Definitions extends EndpointDefinitions,
> = {
select: QueryResultSelectorFactory<
Definition,
_RootState<
Definitions,
TagTypesFrom<Definition>,
ReducerPathFrom<Definition>
>
>
}
export type BuildSelectorsApiEndpointInfiniteQuery<
Definition extends InfiniteQueryDefinition<any, any, any, any, any>,
Definitions extends EndpointDefinitions,
> = {
select: InfiniteQueryResultSelectorFactory<
Definition,
_RootState<
Definitions,
TagTypesFrom<Definition>,
ReducerPathFrom<Definition>
>
>
}
export type BuildSelectorsApiEndpointMutation<
Definition extends MutationDefinition<any, any, any, any, any>,
Definitions extends EndpointDefinitions,
> = {
select: MutationResultSelectorFactory<
Definition,
_RootState<
Definitions,
TagTypesFrom<Definition>,
ReducerPathFrom<Definition>
>
>
}
type QueryResultSelectorFactory<
Definition extends QueryDefinition<any, any, any, any>,
RootState,
> = (
queryArg: QueryArgFrom<Definition> | SkipToken,
) => (state: RootState) => QueryResultSelectorResult<Definition>
export type QueryResultSelectorResult<
Definition extends QueryDefinition<any, any, any, any>,
> = WithRequestStatusFlags<QuerySubState<Definition>>
type InfiniteQueryResultSelectorFactory<
Definition extends InfiniteQueryDefinition<any, any, any, any, any>,
RootState,
> = (
queryArg: InfiniteQueryArgFrom<Definition> | SkipToken,
) => (state: RootState) => InfiniteQueryResultSelectorResult<Definition>
export type InfiniteQueryResultFlags = {
hasNextPage: boolean
hasPreviousPage: boolean
isFetchingNextPage: boolean
isFetchingPreviousPage: boolean
isFetchNextPageError: boolean
isFetchPreviousPageError: boolean
}
export type InfiniteQueryResultSelectorResult<
Definition extends InfiniteQueryDefinition<any, any, any, any, any>,
> = WithRequestStatusFlags<InfiniteQuerySubState<Definition>> &
InfiniteQueryResultFlags
type MutationResultSelectorFactory<
Definition extends MutationDefinition<any, any, any, any>,
RootState,
> = (
requestId:
| string
| { requestId: string | undefined; fixedCacheKey: string | undefined }
| SkipToken,
) => (state: RootState) => MutationResultSelectorResult<Definition>
export type MutationResultSelectorResult<
Definition extends MutationDefinition<any, any, any, any>,
> = WithRequestStatusFlags<MutationSubState<Definition>>
const initialSubState: QuerySubState<any> = {
status: STATUS_UNINITIALIZED,
}
// abuse immer to freeze default states
const defaultQuerySubState = /* @__PURE__ */ createNextState(
initialSubState,
() => {},
)
const defaultMutationSubState = /* @__PURE__ */ createNextState(
initialSubState as MutationSubState<any>,
() => {},
)
export type AllSelectors = ReturnType<typeof buildSelectors>
export function buildSelectors<
Definitions extends EndpointDefinitions,
ReducerPath extends string,
>({
serializeQueryArgs,
reducerPath,
createSelector,
}: {
serializeQueryArgs: InternalSerializeQueryArgs
reducerPath: ReducerPath
createSelector: typeof _createSelector
}) {
type RootState = _RootState<Definitions, string, string>
const selectSkippedQuery = (state: RootState) => defaultQuerySubState
const selectSkippedMutation = (state: RootState) => defaultMutationSubState
// Entries and per-endpoint results keep their references while the
// underlying cache entries are unchanged, so `useSelector` callers do not
// re-render when an unrelated query updates. The previous result is kept
// per endpoint name instead of using `resultEqualityCheck`, which only
// remembers one result per selector and would fail whenever more than one
// endpoint is being selected.
const cacheEntries = new WeakMap<object, QueryCacheEntry<any>>()
const lastEntriesForEndpoint = new Map<string, Array<QueryCacheEntry<any>>>()
const selectAllQueryEntries = createSelector(selectQueries, (queries) => {
const entries: Array<QueryCacheEntry<any>> = []
for (const [queryCacheKey, subState] of Object.entries(queries ?? {})) {
if (subState && subState.status !== STATUS_UNINITIALIZED) {
let entry = cacheEntries.get(subState)
if (!entry) {
entry = {
...subState,
queryCacheKey: queryCacheKey as QueryCacheKey,
}
cacheEntries.set(subState, entry)
}
entries.push(entry)
}
}
return entries
})
const selectEntriesForEndpoint = createSelector(
selectAllQueryEntries,
(_state: RootState, endpointName: string) => endpointName,
(entries, endpointName) => {
const result = entries.filter(
(entry) => entry.endpointName === endpointName,
)
const previous = lastEntriesForEndpoint.get(endpointName)
if (
previous &&
previous.length === result.length &&
previous.every((entry, i) => entry === result[i])
) {
return previous
}
lastEntriesForEndpoint.set(endpointName, result)
return result
},
)
return {
buildQuerySelector,
buildInfiniteQuerySelector,
buildMutationSelector,
selectInvalidatedBy,
selectCachedArgsForQuery,
selectAllQueryEntries,
selectEntriesForEndpoint,
selectApiState,
selectQueries,
selectMutations,
selectQueryEntry,
selectConfig,
}
function withRequestFlags<T extends { status: QueryStatus }>(
substate: T,
): T & RequestStatusFlags {
return { ...substate, ...getRequestStatusFlags(substate.status) }
}
function selectApiState(rootState: RootState) {
const state = rootState[reducerPath]
if (process.env.NODE_ENV !== 'production') {
if (!state) {
if ((selectApiState as any).triggered) return state
;(selectApiState as any).triggered = true
console.error(
`Error: No data found at \`state.${reducerPath}\`. Did you forget to add the reducer to the store?`,
)
}
}
return state
}
function selectQueries(rootState: RootState) {
return selectApiState(rootState)?.queries
}
function selectQueryEntry(rootState: RootState, cacheKey: QueryCacheKey) {
return selectQueries(rootState)?.[cacheKey]
}
function selectMutations(rootState: RootState) {
return selectApiState(rootState)?.mutations
}
function selectConfig(rootState: RootState) {
return selectApiState(rootState)?.config
}
function buildAnyQuerySelector(
endpointName: string,
endpointDefinition: EndpointDefinition<any, any, any, any>,
combiner: <T extends { status: QueryStatus }>(
substate: T,
) => T & RequestStatusFlags,
) {
return (queryArgs: any) => {
// Avoid calling serializeQueryArgs if the arg is skipToken
if (queryArgs === skipToken) {
return createSelector(selectSkippedQuery, combiner)
}
const serializedArgs = serializeQueryArgs({
queryArgs,
endpointDefinition,
endpointName,
})
const selectQuerySubstate = (state: RootState) =>
selectQueryEntry(state, serializedArgs) ?? defaultQuerySubState
return createSelector(selectQuerySubstate, combiner)
}
}
function buildQuerySelector(
endpointName: string,
endpointDefinition: QueryDefinition<any, any, any, any>,
) {
return buildAnyQuerySelector(
endpointName,
endpointDefinition,
withRequestFlags,
) as QueryResultSelectorFactory<any, RootState>
}
function buildInfiniteQuerySelector(
endpointName: string,
endpointDefinition: InfiniteQueryDefinition<any, any, any, any, any>,
) {
const { infiniteQueryOptions } = endpointDefinition
function withInfiniteQueryResultFlags<T extends { status: QueryStatus }>(
substate: T,
): T & RequestStatusFlags & InfiniteQueryResultFlags {
const stateWithRequestFlags = {
...(substate as InfiniteQuerySubState<any>),
...getRequestStatusFlags(substate.status),
}
const { isLoading, isError, direction } = stateWithRequestFlags
const isForward = direction === 'forward'
const isBackward = direction === 'backward'
return {
...stateWithRequestFlags,
hasNextPage: getHasNextPage(
infiniteQueryOptions,
stateWithRequestFlags.data,
stateWithRequestFlags.originalArgs,
),
hasPreviousPage: getHasPreviousPage(
infiniteQueryOptions,
stateWithRequestFlags.data,
stateWithRequestFlags.originalArgs,
),
isFetchingNextPage: isLoading && isForward,
isFetchingPreviousPage: isLoading && isBackward,
isFetchNextPageError: isError && isForward,
isFetchPreviousPageError: isError && isBackward,
}
}
return buildAnyQuerySelector(
endpointName,
endpointDefinition,
withInfiniteQueryResultFlags,
) as unknown as InfiniteQueryResultSelectorFactory<any, RootState>
}
function buildMutationSelector() {
return ((id) => {
let mutationId: string | typeof skipToken
if (typeof id === 'object') {
mutationId = getMutationCacheKey(id) ?? skipToken
} else {
mutationId = id
}
const selectMutationSubstate = (state: RootState) =>
selectApiState(state)?.mutations?.[mutationId as string] ??
defaultMutationSubState
const finalSelectMutationSubstate =
mutationId === skipToken
? selectSkippedMutation
: selectMutationSubstate
return createSelector(finalSelectMutationSubstate, withRequestFlags)
}) as MutationResultSelectorFactory<any, RootState>
}
function selectInvalidatedBy(
state: RootState,
tags: ReadonlyArray<TagDescription<string> | null | undefined>,
): Array<{
endpointName: string
originalArgs: any
queryCacheKey: QueryCacheKey
}> {
const apiState = state[reducerPath]
const toInvalidate = new Set<QueryCacheKey>()
const finalTags = filterMap(tags, isNotNullish, expandTagDescription)
for (const tag of finalTags) {
const provided = apiState.provided.tags[tag.type]
if (!provided) {
continue
}
let invalidateSubscriptions =
(tag.id !== undefined
? // id given: invalidate all queries that provide this type & id
provided[tag.id]
: // no id: invalidate all queries that provide this type
Object.values(provided).flat()) ?? []
for (const invalidate of invalidateSubscriptions) {
toInvalidate.add(invalidate)
}
}
return Array.from(toInvalidate.values()).flatMap((queryCacheKey) => {
const querySubState = apiState.queries[queryCacheKey]
return querySubState
? {
queryCacheKey,
endpointName: querySubState.endpointName!,
originalArgs: querySubState.originalArgs,
}
: []
})
}
function selectCachedArgsForQuery<
QueryName extends AllQueryKeys<Definitions>,
>(
state: RootState,
queryName: QueryName,
): Array<QueryArgFromAnyQuery<Definitions[QueryName]>> {
return filterMap(
Object.values(selectQueries(state) as QueryState<any>),
(
entry,
): entry is Exclude<
QuerySubState<Definitions[QueryName]>,
{ status: QueryStatus.uninitialized }
> =>
entry?.endpointName === queryName &&
entry.status !== STATUS_UNINITIALIZED,
(entry) => entry.originalArgs,
)
}
function getHasNextPage(
options: InfiniteQueryConfigOptions<any, any, any>,
data?: InfiniteData<unknown, unknown>,
queryArg?: unknown,
): boolean {
if (!data) return false
return getNextPageParam(options, data, queryArg) != null
}
function getHasPreviousPage(
options: InfiniteQueryConfigOptions<any, any, any>,
data?: InfiniteData<unknown, unknown>,
queryArg?: unknown,
): boolean {
if (!data || !options.getPreviousPageParam) return false
return getPreviousPageParam(options, data, queryArg) != null
}
}