@depup/reduxjs__toolkit 2.12.0-depup.28

package/src/query/core/buildMiddleware/types.ts

@@ -0,0 +1,173 @@
+import type {
+  Action,
+  AsyncThunkAction,
+  Dispatch,
+  Middleware,
+  MiddlewareAPI,
+  ThunkAction,
+  ThunkDispatch,
+  UnknownAction,
+} from '@reduxjs/toolkit'
+import type { Api, ApiContext } from '../../apiTypes'
+import type {
+  AssertTagTypes,
+  EndpointDefinitions,
+} from '../../endpointDefinitions'
+import type {
+  QueryStatus,
+  QuerySubState,
+  RootState,
+  SubscriptionInternalState,
+  SubscriptionState,
+} from '../apiState'
+import type {
+  InfiniteQueryThunk,
+  MutationThunk,
+  QueryThunk,
+  QueryThunkArg,
+  ThunkResult,
+} from '../buildThunks'
+import type {
+  InfiniteQueryActionCreatorResult,
+  MutationActionCreatorResult,
+  QueryActionCreatorResult,
+} from '../buildInitiate'
+import type { AllSelectors } from '../buildSelectors'
+
+export type QueryStateMeta<T> = Record<string, undefined | T>
+export type TimeoutId = ReturnType<typeof setTimeout>
+
+type QueryPollState = {
+  nextPollTimestamp: number
+  timeout?: TimeoutId
+  pollingInterval: number
+}
+
+export interface InternalMiddlewareState {
+  currentSubscriptions: SubscriptionInternalState
+  currentPolls: Map<string, QueryPollState>
+  runningQueries: Map<
+    string,
+    | QueryActionCreatorResult<any>
+    | InfiniteQueryActionCreatorResult<any>
+    | undefined
+  >
+  runningMutations: Map<string, MutationActionCreatorResult<any> | undefined>
+}
+
+export interface SubscriptionSelectors {
+  getSubscriptions: () => SubscriptionInternalState
+  getSubscriptionCount: (queryCacheKey: string) => number
+  isRequestSubscribed: (queryCacheKey: string, requestId: string) => boolean
+}
+
+export interface BuildMiddlewareInput<
+  Definitions extends EndpointDefinitions,
+  ReducerPath extends string,
+  TagTypes extends string,
+> {
+  reducerPath: ReducerPath
+  context: ApiContext<Definitions>
+  queryThunk: QueryThunk
+  mutationThunk: MutationThunk
+  infiniteQueryThunk: InfiniteQueryThunk<any>
+  api: Api<any, Definitions, ReducerPath, TagTypes>
+  assertTagType: AssertTagTypes
+  selectors: AllSelectors
+  getRunningQueryThunk: (
+    endpointName: string,
+    queryArgs: any,
+  ) => (dispatch: Dispatch) => QueryActionCreatorResult<any> | undefined
+  getInternalState: (dispatch: Dispatch) => InternalMiddlewareState
+}
+
+export type SubMiddlewareApi = MiddlewareAPI<
+  ThunkDispatch<any, any, UnknownAction>,
+  RootState<EndpointDefinitions, string, string>
+>
+
+export interface BuildSubMiddlewareInput
+  extends BuildMiddlewareInput<EndpointDefinitions, string, string> {
+  internalState: InternalMiddlewareState
+  refetchQuery(
+    querySubState: Exclude<
+      QuerySubState<any>,
+      { status: QueryStatus.uninitialized }
+    >,
+  ): ThunkAction<QueryActionCreatorResult<any>, any, any, UnknownAction>
+  isThisApiSliceAction: (action: Action) => boolean
+  selectors: AllSelectors
+  mwApi: MiddlewareAPI<
+    ThunkDispatch<any, any, UnknownAction>,
+    RootState<EndpointDefinitions, string, string>
+  >
+}
+
+export type SubMiddlewareBuilder = (
+  input: BuildSubMiddlewareInput,
+) => Middleware<
+  {},
+  RootState<EndpointDefinitions, string, string>,
+  ThunkDispatch<any, any, UnknownAction>
+>
+
+type MwNext = Parameters<ReturnType<Middleware>>[0]
+
+export type ApiMiddlewareInternalHandler<Return = void> = (
+  action: Action,
+  mwApi: SubMiddlewareApi & { next: MwNext },
+  prevState: RootState<EndpointDefinitions, string, string>,
+) => Return
+
+export type InternalHandlerBuilder<ReturnType = void> = (
+  input: BuildSubMiddlewareInput,
+) => ApiMiddlewareInternalHandler<ReturnType>
+
+export interface PromiseConstructorWithKnownReason {
+  /**
+   * Creates a new Promise with a known rejection reason.
+   * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+   * a resolve callback used to resolve the promise with a value or the result of another promise,
+   * and a reject callback used to reject the promise with a provided reason or error.
+   */
+  new <T, R>(
+    executor: (
+      resolve: (value: T | PromiseLike<T>) => void,
+      reject: (reason?: R) => void,
+    ) => void,
+  ): PromiseWithKnownReason<T, R>
+}
+
+export type PromiseWithKnownReason<T, R> = Omit<
+  Promise<T>,
+  'then' | 'catch'
+> & {
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((reason: R) => TResult2 | PromiseLike<TResult2>)
+      | undefined
+      | null,
+  ): Promise<TResult1 | TResult2>
+
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: R) => TResult | PromiseLike<TResult>)
+      | undefined
+      | null,
+  ): Promise<T | TResult>
+}

package/src/query/core/buildMiddleware/windowEventHandling.ts

@@ -0,0 +1,64 @@
+import { QueryStatus, STATUS_UNINITIALIZED } from '../apiState'
+import type { QueryCacheKey } from '../apiState'
+import { onFocus, onOnline } from '../setupListeners'
+import type {
+  ApiMiddlewareInternalHandler,
+  InternalHandlerBuilder,
+  SubMiddlewareApi,
+} from './types'
+
+export const buildWindowEventHandler: InternalHandlerBuilder = ({
+  reducerPath,
+  context,
+  api,
+  refetchQuery,
+  internalState,
+}) => {
+  const { removeQueryResult } = api.internalActions
+
+  const handler: ApiMiddlewareInternalHandler = (action, mwApi) => {
+    if (onFocus.match(action)) {
+      refetchValidQueries(mwApi, 'refetchOnFocus')
+    }
+    if (onOnline.match(action)) {
+      refetchValidQueries(mwApi, 'refetchOnReconnect')
+    }
+  }
+
+  function refetchValidQueries(
+    api: SubMiddlewareApi,
+    type: 'refetchOnFocus' | 'refetchOnReconnect',
+  ) {
+    const state = api.getState()[reducerPath]
+    const queries = state.queries
+    const subscriptions = internalState.currentSubscriptions
+
+    context.batch(() => {
+      for (const queryCacheKey of subscriptions.keys()) {
+        const querySubState = queries[queryCacheKey]
+        const subscriptionSubState = subscriptions.get(queryCacheKey)
+
+        if (!subscriptionSubState || !querySubState) continue
+
+        const values = [...subscriptionSubState.values()]
+        const shouldRefetch =
+          values.some((sub) => sub[type] === true) ||
+          (values.every((sub) => sub[type] === undefined) && state.config[type])
+
+        if (shouldRefetch) {
+          if (subscriptionSubState.size === 0) {
+            api.dispatch(
+              removeQueryResult({
+                queryCacheKey: queryCacheKey as QueryCacheKey,
+              }),
+            )
+          } else if (querySubState.status !== STATUS_UNINITIALIZED) {
+            api.dispatch(refetchQuery(querySubState))
+          }
+        }
+      }
+    })
+  }
+
+  return handler
+}

package/src/query/core/buildSelectors.ts

@@ -0,0 +1,413 @@
+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,
+  QueryCacheKey,
+  QueryState,
+  QuerySubState,
+  RequestStatusFlags,
+  RootState 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'
+
+export type SkipToken = typeof skipToken
+/**
+ * Can be passed into `useQuery`, `useQueryState` or `useQuerySubscription`
+ * instead of the query argument to get the same effect as if setting
+ * `skip: true` in the query options.
+ *
+ * Useful for scenarios where a query should be skipped when `arg` is `undefined`
+ * and TypeScript complains about it because `arg` is not allowed to be passed
+ * in as `undefined`, such as
+ *
+ * ```ts
+ * // codeblock-meta title="will error if the query argument is not allowed to be undefined" no-transpile
+ * useSomeQuery(arg, { skip: !!arg })
+ * ```
+ *
+ * ```ts
+ * // codeblock-meta title="using skipToken instead" no-transpile
+ * useSomeQuery(arg ?? skipToken)
+ * ```
+ *
+ * If passed directly into a query or mutation selector, that selector will always
+ * return an uninitialized state.
+ */
+export const skipToken = /* @__PURE__ */ Symbol.for('RTKQ/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>,
+> = QuerySubState<Definition> & RequestStatusFlags
+
+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>,
+> = InfiniteQuerySubState<Definition> &
+  RequestStatusFlags &
+  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>,
+> = MutationSubState<Definition> & RequestStatusFlags
+
+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
+
+  return {
+    buildQuerySelector,
+    buildInfiniteQuerySelector,
+    buildMutationSelector,
+    selectInvalidatedBy,
+    selectCachedArgsForQuery,
+    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
+  }
+}