@depup/reduxjs__toolkit 2.12.0-depup.28

package/src/query/core/buildThunks.ts

@@ -0,0 +1,1124 @@
+import type {
+  AsyncThunk,
+  AsyncThunkPayloadCreator,
+  Draft,
+  ThunkAction,
+  ThunkDispatch,
+  UnknownAction,
+} from '@reduxjs/toolkit'
+import type { Patch } from 'immer'
+import { isDraftable, produceWithPatches } from '../utils/immerImports'
+import type { Api, ApiContext } from '../apiTypes'
+import type {
+  BaseQueryError,
+  BaseQueryFn,
+  QueryReturnValue,
+} from '../baseQueryTypes'
+import type { InternalSerializeQueryArgs } from '../defaultSerializeQueryArgs'
+import type {
+  AssertTagTypes,
+  EndpointDefinition,
+  EndpointDefinitions,
+  InfiniteQueryArgFrom,
+  InfiniteQueryCombinedArg,
+  InfiniteQueryDefinition,
+  MutationDefinition,
+  PageParamFrom,
+  QueryArgFrom,
+  QueryDefinition,
+  ResultDescription,
+  ResultTypeFrom,
+  SchemaFailureConverter,
+  SchemaFailureHandler,
+  SchemaFailureInfo,
+  SchemaType,
+} from '../endpointDefinitions'
+import {
+  calculateProvidedBy,
+  ENDPOINT_QUERY,
+  isInfiniteQueryDefinition,
+  isQueryDefinition,
+} from '../endpointDefinitions'
+import { HandledError } from '../HandledError'
+import type { UnwrapPromise } from '../tsHelpers'
+import type {
+  RootState,
+  QueryKeys,
+  QuerySubstateIdentifier,
+  InfiniteData,
+  InfiniteQueryConfigOptions,
+  QueryCacheKey,
+  InfiniteQueryDirection,
+  InfiniteQueryKeys,
+} from './apiState'
+import { QueryStatus, STATUS_UNINITIALIZED } from './apiState'
+import type {
+  InfiniteQueryActionCreatorResult,
+  QueryActionCreatorResult,
+  StartInfiniteQueryActionCreatorOptions,
+  StartQueryActionCreatorOptions,
+} from './buildInitiate'
+import { forceQueryFnSymbol, isUpsertQuery } from './buildInitiate'
+import type { AllSelectors } from './buildSelectors'
+import type { ApiEndpointQuery, PrefetchOptions } from './module'
+import {
+  createAsyncThunk,
+  isAllOf,
+  isFulfilled,
+  isPending,
+  isRejected,
+  isRejectedWithValue,
+  SHOULD_AUTOBATCH,
+} from './rtkImports'
+import {
+  parseWithSchema,
+  NamedSchemaError,
+  shouldSkip,
+} from '../standardSchema'
+
+export type BuildThunksApiEndpointQuery<
+  Definition extends QueryDefinition<any, any, any, any, any>,
+> = Matchers<QueryThunk, Definition>
+
+export type BuildThunksApiEndpointInfiniteQuery<
+  Definition extends InfiniteQueryDefinition<any, any, any, any, any>,
+> = Matchers<InfiniteQueryThunk<any>, Definition>
+
+export type BuildThunksApiEndpointMutation<
+  Definition extends MutationDefinition<any, any, any, any, any>,
+> = Matchers<MutationThunk, Definition>
+
+type EndpointThunk<
+  Thunk extends QueryThunk | MutationThunk | InfiniteQueryThunk<any>,
+  Definition extends EndpointDefinition<any, any, any, any>,
+> =
+  Definition extends EndpointDefinition<
+    infer QueryArg,
+    infer BaseQueryFn,
+    any,
+    infer ResultType
+  >
+    ? Thunk extends AsyncThunk<unknown, infer ATArg, infer ATConfig>
+      ? AsyncThunk<
+          ResultType,
+          ATArg & { originalArgs: QueryArg },
+          ATConfig & { rejectValue: BaseQueryError<BaseQueryFn> }
+        >
+      : never
+    : Definition extends InfiniteQueryDefinition<
+          infer QueryArg,
+          infer PageParam,
+          infer BaseQueryFn,
+          any,
+          infer ResultType
+        >
+      ? Thunk extends AsyncThunk<unknown, infer ATArg, infer ATConfig>
+        ? AsyncThunk<
+            InfiniteData<ResultType, PageParam>,
+            ATArg & { originalArgs: QueryArg },
+            ATConfig & { rejectValue: BaseQueryError<BaseQueryFn> }
+          >
+        : never
+      : never
+
+export type PendingAction<
+  Thunk extends QueryThunk | MutationThunk | InfiniteQueryThunk<any>,
+  Definition extends EndpointDefinition<any, any, any, any>,
+> = ReturnType<EndpointThunk<Thunk, Definition>['pending']>
+
+export type FulfilledAction<
+  Thunk extends QueryThunk | MutationThunk | InfiniteQueryThunk<any>,
+  Definition extends EndpointDefinition<any, any, any, any>,
+> = ReturnType<EndpointThunk<Thunk, Definition>['fulfilled']>
+
+export type RejectedAction<
+  Thunk extends QueryThunk | MutationThunk | InfiniteQueryThunk<any>,
+  Definition extends EndpointDefinition<any, any, any, any>,
+> = ReturnType<EndpointThunk<Thunk, Definition>['rejected']>
+
+export type Matcher<M> = (value: any) => value is M
+
+export interface Matchers<
+  Thunk extends QueryThunk | MutationThunk | InfiniteQueryThunk<any>,
+  Definition extends EndpointDefinition<any, any, any, any>,
+> {
+  matchPending: Matcher<PendingAction<Thunk, Definition>>
+  matchFulfilled: Matcher<FulfilledAction<Thunk, Definition>>
+  matchRejected: Matcher<RejectedAction<Thunk, Definition>>
+}
+
+export type QueryThunkArg = QuerySubstateIdentifier &
+  StartQueryActionCreatorOptions & {
+    type: 'query'
+    originalArgs: unknown
+    endpointName: string
+  }
+
+export type InfiniteQueryThunkArg<
+  D extends InfiniteQueryDefinition<any, any, any, any, any>,
+> = QuerySubstateIdentifier &
+  StartInfiniteQueryActionCreatorOptions<D> & {
+    type: `query`
+    originalArgs: unknown
+    endpointName: string
+    param: unknown
+    direction?: InfiniteQueryDirection
+    refetchCachedPages?: boolean
+  }
+
+type MutationThunkArg = {
+  type: 'mutation'
+  originalArgs: unknown
+  endpointName: string
+  track?: boolean
+  fixedCacheKey?: string
+}
+
+export type ThunkResult = unknown
+
+export type ThunkApiMetaConfig = {
+  pendingMeta: { startedTimeStamp: number; [SHOULD_AUTOBATCH]: true }
+  fulfilledMeta: {
+    fulfilledTimeStamp: number
+    baseQueryMeta: unknown
+    [SHOULD_AUTOBATCH]: true
+  }
+  rejectedMeta: { baseQueryMeta: unknown; [SHOULD_AUTOBATCH]: true }
+}
+export type QueryThunk = AsyncThunk<
+  ThunkResult,
+  QueryThunkArg,
+  ThunkApiMetaConfig
+>
+export type InfiniteQueryThunk<
+  D extends InfiniteQueryDefinition<any, any, any, any, any>,
+> = AsyncThunk<ThunkResult, InfiniteQueryThunkArg<D>, ThunkApiMetaConfig>
+export type MutationThunk = AsyncThunk<
+  ThunkResult,
+  MutationThunkArg,
+  ThunkApiMetaConfig
+>
+
+function defaultTransformResponse(baseQueryReturnValue: unknown) {
+  return baseQueryReturnValue
+}
+
+export type MaybeDrafted<T> = T | Draft<T>
+export type Recipe<T> = (data: MaybeDrafted<T>) => void | MaybeDrafted<T>
+export type UpsertRecipe<T> = (
+  data: MaybeDrafted<T> | undefined,
+) => void | MaybeDrafted<T>
+
+export type PatchQueryDataThunk<
+  Definitions extends EndpointDefinitions,
+  PartialState,
+> = <EndpointName extends QueryKeys<Definitions>>(
+  endpointName: EndpointName,
+  arg: QueryArgFrom<Definitions[EndpointName]>,
+  patches: readonly Patch[],
+  updateProvided?: boolean,
+) => ThunkAction<void, PartialState, any, UnknownAction>
+
+export type AllQueryKeys<Definitions extends EndpointDefinitions> =
+  | QueryKeys<Definitions>
+  | InfiniteQueryKeys<Definitions>
+
+export type QueryArgFromAnyQueryDefinition<
+  Definitions extends EndpointDefinitions,
+  EndpointName extends AllQueryKeys<Definitions>,
+> =
+  Definitions[EndpointName] extends InfiniteQueryDefinition<
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+    ? InfiniteQueryArgFrom<Definitions[EndpointName]>
+    : Definitions[EndpointName] extends QueryDefinition<any, any, any, any>
+      ? QueryArgFrom<Definitions[EndpointName]>
+      : never
+
+export type DataFromAnyQueryDefinition<
+  Definitions extends EndpointDefinitions,
+  EndpointName extends AllQueryKeys<Definitions>,
+> =
+  Definitions[EndpointName] extends InfiniteQueryDefinition<
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+    ? InfiniteData<
+        ResultTypeFrom<Definitions[EndpointName]>,
+        PageParamFrom<Definitions[EndpointName]>
+      >
+    : Definitions[EndpointName] extends QueryDefinition<any, any, any, any>
+      ? ResultTypeFrom<Definitions[EndpointName]>
+      : unknown
+
+export type UpsertThunkResult<
+  Definitions extends EndpointDefinitions,
+  EndpointName extends AllQueryKeys<Definitions>,
+> =
+  Definitions[EndpointName] extends InfiniteQueryDefinition<
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+    ? InfiniteQueryActionCreatorResult<Definitions[EndpointName]>
+    : Definitions[EndpointName] extends QueryDefinition<any, any, any, any>
+      ? QueryActionCreatorResult<Definitions[EndpointName]>
+      : QueryActionCreatorResult<never>
+
+export type UpdateQueryDataThunk<
+  Definitions extends EndpointDefinitions,
+  PartialState,
+> = <EndpointName extends AllQueryKeys<Definitions>>(
+  endpointName: EndpointName,
+  arg: QueryArgFromAnyQueryDefinition<Definitions, EndpointName>,
+  updateRecipe: Recipe<DataFromAnyQueryDefinition<Definitions, EndpointName>>,
+  updateProvided?: boolean,
+) => ThunkAction<PatchCollection, PartialState, any, UnknownAction>
+
+export type UpsertQueryDataThunk<
+  Definitions extends EndpointDefinitions,
+  PartialState,
+> = <EndpointName extends AllQueryKeys<Definitions>>(
+  endpointName: EndpointName,
+  arg: QueryArgFromAnyQueryDefinition<Definitions, EndpointName>,
+  value: DataFromAnyQueryDefinition<Definitions, EndpointName>,
+) => ThunkAction<
+  UpsertThunkResult<Definitions, EndpointName>,
+  PartialState,
+  any,
+  UnknownAction
+>
+
+/**
+ * An object returned from dispatching a `api.util.updateQueryData` call.
+ */
+export type PatchCollection = {
+  /**
+   * An `immer` Patch describing the cache update.
+   */
+  patches: Patch[]
+  /**
+   * An `immer` Patch to revert the cache update.
+   */
+  inversePatches: Patch[]
+  /**
+   * A function that will undo the cache update.
+   */
+  undo: () => void
+}
+
+type TransformCallback = (
+  baseQueryReturnValue: unknown,
+  meta: unknown,
+  arg: unknown,
+) => any
+
+export const addShouldAutoBatch = <T extends Record<string, any>>(
+  arg: T = {} as T,
+): T & { [SHOULD_AUTOBATCH]: true } => {
+  return { ...arg, [SHOULD_AUTOBATCH]: true }
+}
+
+export function buildThunks<
+  BaseQuery extends BaseQueryFn,
+  ReducerPath extends string,
+  Definitions extends EndpointDefinitions,
+>({
+  reducerPath,
+  baseQuery,
+  context: { endpointDefinitions },
+  serializeQueryArgs,
+  api,
+  assertTagType,
+  selectors,
+  onSchemaFailure,
+  catchSchemaFailure: globalCatchSchemaFailure,
+  skipSchemaValidation: globalSkipSchemaValidation,
+}: {
+  baseQuery: BaseQuery
+  reducerPath: ReducerPath
+  context: ApiContext<Definitions>
+  serializeQueryArgs: InternalSerializeQueryArgs
+  api: Api<BaseQuery, Definitions, ReducerPath, any>
+  assertTagType: AssertTagTypes
+  selectors: AllSelectors
+  onSchemaFailure: SchemaFailureHandler | undefined
+  catchSchemaFailure: SchemaFailureConverter<BaseQuery> | undefined
+  skipSchemaValidation: boolean | SchemaType[] | undefined
+}) {
+  type State = RootState<any, string, ReducerPath>
+
+  const patchQueryData: PatchQueryDataThunk<EndpointDefinitions, State> =
+    (endpointName, arg, patches, updateProvided) => (dispatch, getState) => {
+      const endpointDefinition = endpointDefinitions[endpointName]
+
+      const queryCacheKey = serializeQueryArgs({
+        queryArgs: arg,
+        endpointDefinition,
+        endpointName,
+      })
+
+      dispatch(
+        api.internalActions.queryResultPatched({ queryCacheKey, patches }),
+      )
+
+      if (!updateProvided) {
+        return
+      }
+
+      const newValue = api.endpoints[endpointName].select(arg)(
+        // Work around TS 4.1 mismatch
+        getState() as RootState<any, any, any>,
+      )
+
+      const providedTags = calculateProvidedBy(
+        endpointDefinition.providesTags,
+        newValue.data,
+        undefined,
+        arg,
+        {},
+        assertTagType,
+      )
+
+      dispatch(
+        api.internalActions.updateProvidedBy([{ queryCacheKey, providedTags }]),
+      )
+    }
+
+  function addToStart<T>(items: Array<T>, item: T, max = 0): Array<T> {
+    const newItems = [item, ...items]
+    return max && newItems.length > max ? newItems.slice(0, -1) : newItems
+  }
+
+  function addToEnd<T>(items: Array<T>, item: T, max = 0): Array<T> {
+    const newItems = [...items, item]
+    return max && newItems.length > max ? newItems.slice(1) : newItems
+  }
+
+  const updateQueryData: UpdateQueryDataThunk<EndpointDefinitions, State> =
+    (endpointName, arg, updateRecipe, updateProvided = true) =>
+    (dispatch, getState) => {
+      const endpointDefinition = api.endpoints[endpointName]
+
+      const currentState = endpointDefinition.select(arg)(
+        // Work around TS 4.1 mismatch
+        getState() as RootState<any, any, any>,
+      )
+
+      const ret: PatchCollection = {
+        patches: [],
+        inversePatches: [],
+        undo: () =>
+          dispatch(
+            api.util.patchQueryData(
+              endpointName,
+              arg,
+              ret.inversePatches,
+              updateProvided,
+            ),
+          ),
+      }
+      if (currentState.status === STATUS_UNINITIALIZED) {
+        return ret
+      }
+      let newValue
+      if ('data' in currentState) {
+        if (isDraftable(currentState.data)) {
+          const [value, patches, inversePatches] = produceWithPatches(
+            currentState.data,
+            updateRecipe,
+          )
+          ret.patches.push(...patches)
+          ret.inversePatches.push(...inversePatches)
+          newValue = value
+        } else {
+          newValue = updateRecipe(currentState.data)
+          ret.patches.push({ op: 'replace', path: [], value: newValue })
+          ret.inversePatches.push({
+            op: 'replace',
+            path: [],
+            value: currentState.data,
+          })
+        }
+      }
+
+      if (ret.patches.length === 0) {
+        return ret
+      }
+
+      dispatch(
+        api.util.patchQueryData(endpointName, arg, ret.patches, updateProvided),
+      )
+
+      return ret
+    }
+
+  const upsertQueryData: UpsertQueryDataThunk<Definitions, State> =
+    (endpointName, arg, value) => (dispatch) => {
+      type EndpointName = typeof endpointName
+      const res = dispatch(
+        (
+          api.endpoints[endpointName] as ApiEndpointQuery<
+            QueryDefinition<any, any, any, any, any>,
+            Definitions
+          >
+        ).initiate(arg, {
+          subscribe: false,
+          forceRefetch: true,
+          [forceQueryFnSymbol]: () => ({ data: value }),
+        }),
+      ) as UpsertThunkResult<Definitions, EndpointName>
+
+      return res
+    }
+
+  const getTransformCallbackForEndpoint = (
+    endpointDefinition: EndpointDefinition<any, any, any, any>,
+    transformFieldName: 'transformResponse' | 'transformErrorResponse',
+  ): TransformCallback => {
+    return endpointDefinition.query && endpointDefinition[transformFieldName]
+      ? (endpointDefinition[transformFieldName]! as TransformCallback)
+      : defaultTransformResponse
+  }
+
+  // The generic async payload function for all of our thunks
+  const executeEndpoint: AsyncThunkPayloadCreator<
+    ThunkResult,
+    QueryThunkArg | MutationThunkArg | InfiniteQueryThunkArg<any>,
+    ThunkApiMetaConfig & { state: RootState<any, string, ReducerPath> }
+  > = async (
+    arg,
+    {
+      signal,
+      abort,
+      rejectWithValue,
+      fulfillWithValue,
+      dispatch,
+      getState,
+      extra,
+    },
+  ) => {
+    const endpointDefinition = endpointDefinitions[arg.endpointName]
+    const { metaSchema, skipSchemaValidation = globalSkipSchemaValidation } =
+      endpointDefinition
+
+    const isQuery = arg.type === ENDPOINT_QUERY
+
+    try {
+      let transformResponse: TransformCallback = defaultTransformResponse
+
+      const baseQueryApi = {
+        signal,
+        abort,
+        dispatch,
+        getState,
+        extra,
+        endpoint: arg.endpointName,
+        type: arg.type,
+        forced: isQuery ? isForcedQuery(arg, getState()) : undefined,
+        queryCacheKey: isQuery ? arg.queryCacheKey : undefined,
+      }
+
+      const forceQueryFn = isQuery ? arg[forceQueryFnSymbol] : undefined
+
+      let finalQueryReturnValue: QueryReturnValue
+
+      // Infinite query wrapper, which executes the request and returns
+      // the InfiniteData `{pages, pageParams}` structure
+      const fetchPage = async (
+        data: InfiniteData<unknown, unknown>,
+        param: unknown,
+        maxPages: number,
+        previous?: boolean,
+      ): Promise<QueryReturnValue> => {
+        // This should handle cases where there is no `getPrevPageParam`,
+        // or `getPPP` returned nullish
+        if (param == null && data.pages.length) {
+          return Promise.resolve({ data })
+        }
+
+        const finalQueryArg: InfiniteQueryCombinedArg<any, any> = {
+          queryArg: arg.originalArgs,
+          pageParam: param,
+        }
+
+        const pageResponse = await executeRequest(finalQueryArg)
+
+        const addTo = previous ? addToStart : addToEnd
+
+        return {
+          data: {
+            pages: addTo(data.pages, pageResponse.data, maxPages),
+            pageParams: addTo(data.pageParams, param, maxPages),
+          },
+          meta: pageResponse.meta,
+        }
+      }
+
+      // Wrapper for executing either `query` or `queryFn`,
+      // and handling any errors
+      async function executeRequest(
+        finalQueryArg: unknown,
+      ): Promise<QueryReturnValue> {
+        let result: QueryReturnValue
+        const { extraOptions, argSchema, rawResponseSchema, responseSchema } =
+          endpointDefinition
+
+        if (argSchema && !shouldSkip(skipSchemaValidation, 'arg')) {
+          finalQueryArg = await parseWithSchema(
+            argSchema,
+            finalQueryArg,
+            'argSchema',
+            {}, // we don't have a meta yet, so we can't pass it
+          )
+        }
+
+        if (forceQueryFn) {
+          // upsertQueryData relies on this to pass in the user-provided value
+          result = forceQueryFn()
+        } else if (endpointDefinition.query) {
+          // We should only run `transformResponse` when the endpoint has a `query` method,
+          // and we're not doing an `upsertQueryData`.
+          transformResponse = getTransformCallbackForEndpoint(
+            endpointDefinition,
+            'transformResponse',
+          )
+
+          result = await baseQuery(
+            endpointDefinition.query(finalQueryArg as any),
+            baseQueryApi,
+            extraOptions as any,
+          )
+        } else {
+          result = await endpointDefinition.queryFn(
+            finalQueryArg as any,
+            baseQueryApi,
+            extraOptions as any,
+            (arg) => baseQuery(arg, baseQueryApi, extraOptions as any),
+          )
+        }
+
+        if (
+          typeof process !== 'undefined' &&
+          process.env.NODE_ENV === 'development'
+        ) {
+          const what = endpointDefinition.query ? '`baseQuery`' : '`queryFn`'
+          let err: undefined | string
+          if (!result) {
+            err = `${what} did not return anything.`
+          } else if (typeof result !== 'object') {
+            err = `${what} did not return an object.`
+          } else if (result.error && result.data) {
+            err = `${what} returned an object containing both \`error\` and \`result\`.`
+          } else if (result.error === undefined && result.data === undefined) {
+            err = `${what} returned an object containing neither a valid \`error\` and \`result\`. At least one of them should not be \`undefined\``
+          } else {
+            for (const key of Object.keys(result)) {
+              if (key !== 'error' && key !== 'data' && key !== 'meta') {
+                err = `The object returned by ${what} has the unknown property ${key}.`
+                break
+              }
+            }
+          }
+          if (err) {
+            console.error(
+              `Error encountered handling the endpoint ${arg.endpointName}.
+                  ${err}
+                  It needs to return an object with either the shape \`{ data: <value> }\` or \`{ error: <value> }\` that may contain an optional \`meta\` property.
+                  Object returned was:`,
+              result,
+            )
+          }
+        }
+
+        if (result.error) throw new HandledError(result.error, result.meta)
+
+        let { data } = result
+
+        if (
+          rawResponseSchema &&
+          !shouldSkip(skipSchemaValidation, 'rawResponse')
+        ) {
+          data = await parseWithSchema(
+            rawResponseSchema,
+            result.data,
+            'rawResponseSchema',
+            result.meta,
+          )
+        }
+
+        let transformedResponse = await transformResponse(
+          data,
+          result.meta,
+          finalQueryArg,
+        )
+
+        if (responseSchema && !shouldSkip(skipSchemaValidation, 'response')) {
+          transformedResponse = await parseWithSchema(
+            responseSchema,
+            transformedResponse,
+            'responseSchema',
+            result.meta,
+          )
+        }
+
+        return {
+          ...result,
+          data: transformedResponse,
+        }
+      }
+
+      if (isQuery && 'infiniteQueryOptions' in endpointDefinition) {
+        // This is an infinite query endpoint
+        const { infiniteQueryOptions } = endpointDefinition
+
+        // Runtime checks should guarantee this is a positive number if provided
+        const { maxPages = Infinity } = infiniteQueryOptions
+
+        // Priority: per-call override > endpoint config > default (true)
+        const refetchCachedPages =
+          (arg as InfiniteQueryThunkArg<any>).refetchCachedPages ??
+          infiniteQueryOptions.refetchCachedPages ??
+          true
+
+        let result: QueryReturnValue
+
+        // Start by looking up the existing InfiniteData value from state,
+        // falling back to an empty value if it doesn't exist yet
+        const blankData = { pages: [], pageParams: [] }
+        const cachedData = selectors.selectQueryEntry(
+          getState(),
+          arg.queryCacheKey,
+        )?.data as InfiniteData<unknown, unknown> | undefined
+
+        // When the arg changes or the user forces a refetch,
+        // we don't include the `direction` flag. This lets us distinguish
+        // between actually refetching with a forced query, vs just fetching
+        // the next page.
+        const isForcedQueryNeedingRefetch = // arg.forceRefetch
+          isForcedQuery(arg, getState()) &&
+          !(arg as InfiniteQueryThunkArg<any>).direction
+        const existingData = (
+          isForcedQueryNeedingRefetch || !cachedData ? blankData : cachedData
+        ) as InfiniteData<unknown, unknown>
+
+        // If the thunk specified a direction and we do have at least one page,
+        // fetch the next or previous page
+        if ('direction' in arg && arg.direction && existingData.pages.length) {
+          const previous = arg.direction === 'backward'
+          const pageParamFn = previous ? getPreviousPageParam : getNextPageParam
+          const param = pageParamFn(
+            infiniteQueryOptions,
+            existingData,
+            arg.originalArgs,
+          )
+
+          result = await fetchPage(existingData, param, maxPages, previous)
+        } else {
+          // Otherwise, fetch the first page and then any remaining pages
+
+          const { initialPageParam = infiniteQueryOptions.initialPageParam } =
+            arg as InfiniteQueryThunkArg<any>
+
+          // If we're doing a refetch, we should start from
+          // the first page we have cached.
+          // Otherwise, we should start from the initialPageParam
+          const cachedPageParams = cachedData?.pageParams ?? []
+          const firstPageParam = cachedPageParams[0] ?? initialPageParam
+          const totalPages = cachedPageParams.length
+
+          // Fetch first page
+          result = await fetchPage(existingData, firstPageParam, maxPages)
+
+          if (forceQueryFn) {
+            // HACK `upsertQueryData` expects the user to pass in the `{pages, pageParams}` structure,
+            // but `fetchPage` treats that as `pages[0]`. We have to manually un-nest it.
+            result = {
+              data: (result.data as InfiniteData<unknown, unknown>).pages[0],
+            } as QueryReturnValue
+          }
+
+          if (refetchCachedPages) {
+            // Fetch remaining pages
+            for (let i = 1; i < totalPages; i++) {
+              const param = getNextPageParam(
+                infiniteQueryOptions,
+                result.data as InfiniteData<unknown, unknown>,
+                arg.originalArgs,
+              )
+              result = await fetchPage(
+                result.data as InfiniteData<unknown, unknown>,
+                param,
+                maxPages,
+              )
+            }
+          }
+        }
+
+        finalQueryReturnValue = result
+      } else {
+        // Non-infinite endpoint. Just run the one request.
+        finalQueryReturnValue = await executeRequest(arg.originalArgs)
+      }
+
+      if (
+        metaSchema &&
+        !shouldSkip(skipSchemaValidation, 'meta') &&
+        finalQueryReturnValue.meta
+      ) {
+        finalQueryReturnValue.meta = await parseWithSchema(
+          metaSchema,
+          finalQueryReturnValue.meta,
+          'metaSchema',
+          finalQueryReturnValue.meta,
+        )
+      }
+
+      // console.log('Final result: ', transformedData)
+      return fulfillWithValue(
+        finalQueryReturnValue.data,
+        addShouldAutoBatch({
+          fulfilledTimeStamp: Date.now(),
+          baseQueryMeta: finalQueryReturnValue.meta,
+        }),
+      )
+    } catch (error) {
+      let caughtError = error
+      if (caughtError instanceof HandledError) {
+        let transformErrorResponse = getTransformCallbackForEndpoint(
+          endpointDefinition,
+          'transformErrorResponse',
+        )
+        const { rawErrorResponseSchema, errorResponseSchema } =
+          endpointDefinition
+
+        let { value, meta } = caughtError
+
+        try {
+          if (
+            rawErrorResponseSchema &&
+            !shouldSkip(skipSchemaValidation, 'rawErrorResponse')
+          ) {
+            value = await parseWithSchema(
+              rawErrorResponseSchema,
+              value,
+              'rawErrorResponseSchema',
+              meta,
+            )
+          }
+
+          if (metaSchema && !shouldSkip(skipSchemaValidation, 'meta')) {
+            meta = await parseWithSchema(metaSchema, meta, 'metaSchema', meta)
+          }
+          let transformedErrorResponse = await transformErrorResponse(
+            value,
+            meta,
+            arg.originalArgs,
+          )
+          if (
+            errorResponseSchema &&
+            !shouldSkip(skipSchemaValidation, 'errorResponse')
+          ) {
+            transformedErrorResponse = await parseWithSchema(
+              errorResponseSchema,
+              transformedErrorResponse,
+              'errorResponseSchema',
+              meta,
+            )
+          }
+
+          return rejectWithValue(
+            transformedErrorResponse,
+            addShouldAutoBatch({ baseQueryMeta: meta }),
+          )
+        } catch (e) {
+          caughtError = e
+        }
+      }
+      try {
+        if (caughtError instanceof NamedSchemaError) {
+          const info: SchemaFailureInfo = {
+            endpoint: arg.endpointName,
+            arg: arg.originalArgs,
+            type: arg.type,
+            queryCacheKey: isQuery ? arg.queryCacheKey : undefined,
+          }
+          endpointDefinition.onSchemaFailure?.(caughtError, info)
+          onSchemaFailure?.(caughtError, info)
+          const { catchSchemaFailure = globalCatchSchemaFailure } =
+            endpointDefinition
+          if (catchSchemaFailure) {
+            return rejectWithValue(
+              catchSchemaFailure(caughtError, info),
+              addShouldAutoBatch({ baseQueryMeta: caughtError._bqMeta }),
+            )
+          }
+        }
+      } catch (e) {
+        caughtError = e
+      }
+      if (
+        typeof process !== 'undefined' &&
+        process.env.NODE_ENV !== 'production'
+      ) {
+        console.error(
+          `An unhandled error occurred processing a request for the endpoint "${arg.endpointName}".
+In the case of an unhandled error, no tags will be "provided" or "invalidated".`,
+          caughtError,
+        )
+      } else {
+        console.error(caughtError)
+      }
+      throw caughtError
+    }
+  }
+
+  function isForcedQuery(
+    arg: QueryThunkArg,
+    state: RootState<any, string, ReducerPath>,
+  ) {
+    const requestState = selectors.selectQueryEntry(state, arg.queryCacheKey)
+    const baseFetchOnMountOrArgChange =
+      selectors.selectConfig(state).refetchOnMountOrArgChange
+
+    const fulfilledVal = requestState?.fulfilledTimeStamp
+    const refetchVal =
+      arg.forceRefetch ?? (arg.subscribe && baseFetchOnMountOrArgChange)
+
+    if (refetchVal) {
+      // Return if it's true or compare the dates because it must be a number
+      return (
+        refetchVal === true ||
+        (Number(new Date()) - Number(fulfilledVal)) / 1000 >= refetchVal
+      )
+    }
+    return false
+  }
+
+  const createQueryThunk = <
+    ThunkArgType extends QueryThunkArg | InfiniteQueryThunkArg<any>,
+  >() => {
+    const generatedQueryThunk = createAsyncThunk<
+      ThunkResult,
+      ThunkArgType,
+      ThunkApiMetaConfig & { state: RootState<any, string, ReducerPath> }
+    >(`${reducerPath}/executeQuery`, executeEndpoint, {
+      getPendingMeta({ arg }) {
+        const endpointDefinition = endpointDefinitions[arg.endpointName]
+        return addShouldAutoBatch({
+          startedTimeStamp: Date.now(),
+          ...(isInfiniteQueryDefinition(endpointDefinition)
+            ? { direction: (arg as InfiniteQueryThunkArg<any>).direction }
+            : {}),
+        })
+      },
+      condition(queryThunkArg, { getState }) {
+        const state = getState()
+
+        const requestState = selectors.selectQueryEntry(
+          state,
+          queryThunkArg.queryCacheKey,
+        )
+        const fulfilledVal = requestState?.fulfilledTimeStamp
+        const currentArg = queryThunkArg.originalArgs
+        const previousArg = requestState?.originalArgs
+        const endpointDefinition =
+          endpointDefinitions[queryThunkArg.endpointName]
+        const direction = (queryThunkArg as InfiniteQueryThunkArg<any>)
+          .direction
+
+        // Order of these checks matters.
+        // In order for `upsertQueryData` to successfully run while an existing request is in flight,
+        /// we have to check for that first, otherwise `queryThunk` will bail out and not run at all.
+        if (isUpsertQuery(queryThunkArg)) {
+          return true
+        }
+
+        // Don't retry a request that's currently in-flight
+        if (requestState?.status === 'pending') {
+          return false
+        }
+
+        // if this is forced, continue
+        if (isForcedQuery(queryThunkArg, state)) {
+          return true
+        }
+
+        if (
+          isQueryDefinition(endpointDefinition) &&
+          endpointDefinition?.forceRefetch?.({
+            currentArg,
+            previousArg,
+            endpointState: requestState,
+            state,
+          })
+        ) {
+          return true
+        }
+
+        // Pull from the cache unless we explicitly force refetch or qualify based on time
+        if (fulfilledVal && !direction) {
+          // Value is cached and we didn't specify to refresh, skip it.
+          return false
+        }
+
+        return true
+      },
+      dispatchConditionRejection: true,
+    })
+    return generatedQueryThunk
+  }
+
+  const queryThunk = createQueryThunk<QueryThunkArg>()
+  const infiniteQueryThunk = createQueryThunk<InfiniteQueryThunkArg<any>>()
+
+  const mutationThunk = createAsyncThunk<
+    ThunkResult,
+    MutationThunkArg,
+    ThunkApiMetaConfig & { state: RootState<any, string, ReducerPath> }
+  >(`${reducerPath}/executeMutation`, executeEndpoint, {
+    getPendingMeta() {
+      return addShouldAutoBatch({ startedTimeStamp: Date.now() })
+    },
+  })
+
+  const hasTheForce = (options: any): options is { force: boolean } =>
+    'force' in options
+  const hasMaxAge = (
+    options: any,
+  ): options is { ifOlderThan: false | number } => 'ifOlderThan' in options
+
+  const prefetch =
+    <EndpointName extends QueryKeys<Definitions>>(
+      endpointName: EndpointName,
+      arg: any,
+      options: PrefetchOptions = {},
+    ): ThunkAction<void, any, any, UnknownAction> =>
+    (dispatch: ThunkDispatch<any, any, any>, getState: () => any) => {
+      const force = hasTheForce(options) && options.force
+      const maxAge = hasMaxAge(options) && options.ifOlderThan
+
+      const queryAction = (force: boolean = true) => {
+        const options: StartQueryActionCreatorOptions = {
+          forceRefetch: force,
+          subscribe: false,
+        }
+        return (
+          api.endpoints[endpointName] as ApiEndpointQuery<any, any>
+        ).initiate(arg, options)
+      }
+      const latestStateValue = (
+        api.endpoints[endpointName] as ApiEndpointQuery<any, any>
+      ).select(arg)(getState())
+
+      if (force) {
+        dispatch(queryAction())
+      } else if (maxAge) {
+        const lastFulfilledTs = latestStateValue?.fulfilledTimeStamp
+        if (!lastFulfilledTs) {
+          dispatch(queryAction())
+          return
+        }
+        const shouldRetrigger =
+          (Number(new Date()) - Number(new Date(lastFulfilledTs))) / 1000 >=
+          maxAge
+        if (shouldRetrigger) {
+          dispatch(queryAction())
+        }
+      } else {
+        // If prefetching with no options, just let it try
+        dispatch(queryAction(false))
+      }
+    }
+
+  function matchesEndpoint(endpointName: string) {
+    return (action: any): action is UnknownAction =>
+      action?.meta?.arg?.endpointName === endpointName
+  }
+
+  function buildMatchThunkActions<
+    Thunk extends
+      | AsyncThunk<any, QueryThunkArg, ThunkApiMetaConfig>
+      | AsyncThunk<any, MutationThunkArg, ThunkApiMetaConfig>,
+  >(thunk: Thunk, endpointName: string) {
+    return {
+      matchPending: isAllOf(isPending(thunk), matchesEndpoint(endpointName)),
+      matchFulfilled: isAllOf(
+        isFulfilled(thunk),
+        matchesEndpoint(endpointName),
+      ),
+      matchRejected: isAllOf(isRejected(thunk), matchesEndpoint(endpointName)),
+    } as Matchers<Thunk, any>
+  }
+
+  return {
+    queryThunk,
+    mutationThunk,
+    infiniteQueryThunk,
+    prefetch,
+    updateQueryData,
+    upsertQueryData,
+    patchQueryData,
+    buildMatchThunkActions,
+  }
+}
+
+export function getNextPageParam(
+  options: InfiniteQueryConfigOptions<unknown, unknown, unknown>,
+  { pages, pageParams }: InfiniteData<unknown, unknown>,
+  queryArg: unknown,
+): unknown | undefined {
+  const lastIndex = pages.length - 1
+  return options.getNextPageParam(
+    pages[lastIndex],
+    pages,
+    pageParams[lastIndex],
+    pageParams,
+    queryArg,
+  )
+}
+
+export function getPreviousPageParam(
+  options: InfiniteQueryConfigOptions<unknown, unknown, unknown>,
+  { pages, pageParams }: InfiniteData<unknown, unknown>,
+  queryArg: unknown,
+): unknown | undefined {
+  return options.getPreviousPageParam?.(
+    pages[0],
+    pages,
+    pageParams[0],
+    pageParams,
+    queryArg,
+  )
+}
+
+export function calculateProvidedByThunk(
+  action: UnwrapPromise<
+    | ReturnType<ReturnType<QueryThunk>>
+    | ReturnType<ReturnType<MutationThunk>>
+    | ReturnType<ReturnType<InfiniteQueryThunk<any>>>
+  >,
+  type: 'providesTags' | 'invalidatesTags',
+  endpointDefinitions: EndpointDefinitions,
+  assertTagType: AssertTagTypes,
+) {
+  return calculateProvidedBy(
+    endpointDefinitions[action.meta.arg.endpointName][
+      type
+    ] as ResultDescription<any, any, any, any, any>,
+    isFulfilled(action) ? action.payload : undefined,
+    isRejectedWithValue(action) ? action.payload : undefined,
+    action.meta.arg.originalArgs,
+    'baseQueryMeta' in action.meta ? action.meta.baseQueryMeta : undefined,
+    assertTagType,
+  )
+}