@tanstack/query-core 5.0.0-alpha.1 → 5.0.0-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/query-core",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.3",
   "description": "The framework agnostic core that powers TanStack Query",
   "author": "tannerlinsley",
   "license": "MIT",

package/src/index.ts

@@ -11,7 +11,13 @@ export { MutationObserver } from './mutationObserver'
 export { notifyManager } from './notifyManager'
 export { focusManager } from './focusManager'
 export { onlineManager } from './onlineManager'
-export { hashKey, replaceEqualDeep, isServer, keepPreviousData } from './utils'
+export {
+  hashKey,
+  replaceEqualDeep,
+  isServer,
+  matchQuery,
+  keepPreviousData,
+} from './utils'
 export type { MutationFilters, QueryFilters, Updater } from './utils'
 export { isCancelledError } from './retryer'
 export {

package/src/infiniteQueryObserver.ts

@@ -6,7 +6,7 @@ import type {
   InfiniteQueryObserverOptions,
   InfiniteQueryObserverResult,
   QueryKey,
-  RegisteredError,
+  DefaultError,
 } from './types'
 import type { QueryClient } from './queryClient'
 import type { NotifyOptions, ObserverFetchOptions } from './queryObserver'
@@ -24,7 +24,7 @@ type InfiniteQueryObserverListener<TData, TError> = (
 
 export class InfiniteQueryObserver<
   TQueryFnData = unknown,
-  TError = RegisteredError,
+  TError = DefaultError,
   TData = InfiniteData<TQueryFnData>,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,

package/src/mutation.ts

@@ -2,7 +2,7 @@ import type {
   MutationOptions,
   MutationStatus,
   MutationMeta,
-  RegisteredError,
+  DefaultError,
 } from './types'
 import type { MutationCache } from './mutationCache'
 import type { MutationObserver } from './mutationObserver'
@@ -23,7 +23,7 @@ interface MutationConfig<TData, TError, TVariables, TContext> {
 
 export interface MutationState<
   TData = unknown,
-  TError = RegisteredError,
+  TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 > {
@@ -80,31 +80,40 @@ export type Action<TData, TError, TVariables, TContext> =
 
 export class Mutation<
   TData = unknown,
-  TError = RegisteredError,
+  TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 > extends Removable {
   state: MutationState<TData, TError, TVariables, TContext>
-  readonly options: MutationOptions<TData, TError, TVariables, TContext>
+  options!: MutationOptions<TData, TError, TVariables, TContext>
   readonly mutationId: number
 
   #observers: MutationObserver<TData, TError, TVariables, TContext>[]
+  #defaultOptions?: MutationOptions<TData, TError, TVariables, TContext>
   #mutationCache: MutationCache
   #retryer?: Retryer<TData>
 
   constructor(config: MutationConfig<TData, TError, TVariables, TContext>) {
     super()
 
-    this.options = config.options
     this.mutationId = config.mutationId
+    this.#defaultOptions = config.defaultOptions
     this.#mutationCache = config.mutationCache
     this.#observers = []
     this.state = config.state || getDefaultState()
 
-    this.updateGcTime(this.options.gcTime)
+    this.setOptions(config.options)
     this.scheduleGc()
   }
 
+  setOptions(
+    options?: MutationOptions<TData, TError, TVariables, TContext>,
+  ): void {
+    this.options = { ...this.#defaultOptions, ...options }
+
+    this.updateGcTime(this.options.gcTime)
+  }
+
   get meta(): MutationMeta | undefined {
     return this.options.meta
   }
@@ -211,6 +220,15 @@ export class Mutation<
 
       await this.options.onSuccess?.(data, variables, this.state.context)
 
+      // Notify cache callback
+      await this.#mutationCache.config.onSettled?.(
+        data,
+        null,
+        this.state.variables,
+        this.state.context,
+        this as Mutation<unknown, unknown, unknown, unknown>,
+      )
+
       await this.options.onSettled?.(data, null, variables, this.state.context)
 
       this.#dispatch({ type: 'success', data })
@@ -219,7 +237,7 @@ export class Mutation<
       try {
         // Notify cache callback
         await this.#mutationCache.config.onError?.(
-          error,
+          error as any,
           variables,
           this.state.context,
           this as Mutation<unknown, unknown, unknown, unknown>,
@@ -231,6 +249,15 @@ export class Mutation<
           this.state.context,
         )
 
+        // Notify cache callback
+        await this.#mutationCache.config.onSettled?.(
+          undefined,
+          error as any,
+          this.state.variables,
+          this.state.context,
+          this as Mutation<unknown, unknown, unknown, unknown>,
+        )
+
         await this.options.onSettled?.(
           undefined,
           error as TError,

package/src/mutationCache.ts

@@ -1,5 +1,5 @@
 import type { MutationObserver } from './mutationObserver'
-import type { NotifyEvent, MutationOptions, RegisteredError } from './types'
+import type { NotifyEvent, MutationOptions, DefaultError } from './types'
 import type { QueryClient } from './queryClient'
 import { notifyManager } from './notifyManager'
 import type { Action, MutationState } from './mutation'
@@ -12,7 +12,7 @@ import { Subscribable } from './subscribable'
 
 interface MutationCacheConfig {
   onError?: (
-    error: unknown,
+    error: DefaultError,
     variables: unknown,
     context: unknown,
     mutation: Mutation<unknown, unknown, unknown>,
@@ -25,7 +25,14 @@ interface MutationCacheConfig {
   ) => Promise<unknown> | unknown
   onMutate?: (
     variables: unknown,
-    mutation: Mutation<unknown, unknown, unknown, unknown>,
+    mutation: Mutation<unknown, unknown, unknown>,
+  ) => Promise<unknown> | unknown
+  onSettled?: (
+    data: unknown | undefined,
+    error: DefaultError | null,
+    variables: unknown,
+    context: unknown,
+    mutation: Mutation<unknown, unknown, unknown>,
   ) => Promise<unknown> | unknown
 }
 
@@ -126,7 +133,7 @@ export class MutationCache extends Subscribable<MutationCacheListener> {
 
   find<
     TData = unknown,
-    TError = RegisteredError,
+    TError = DefaultError,
     TVariables = any,
     TContext = unknown,
   >(

package/src/mutationObserver.ts

@@ -7,7 +7,7 @@ import type {
   MutateOptions,
   MutationObserverResult,
   MutationObserverOptions,
-  RegisteredError,
+  DefaultError,
 } from './types'
 import { shallowEqualObjects } from './utils'
 
@@ -21,7 +21,7 @@ type MutationObserverListener<TData, TError, TVariables, TContext> = (
 
 export class MutationObserver<
   TData = unknown,
-  TError = RegisteredError,
+  TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 > extends Subscribable<
@@ -64,6 +64,7 @@ export class MutationObserver<
         observer: this,
       })
     }
+    this.#currentMutation?.setOptions(this.options)
   }
 
   protected onUnsubscribe(): void {

package/src/queriesObserver.ts

@@ -26,7 +26,6 @@ export class QueriesObserver extends Subscribable<QueriesObserverListener> {
   #result: QueryObserverResult[]
   #queries: QueryObserverOptions[]
   #observers: QueryObserver[]
-  #observersMap: Record<string, QueryObserver>
 
   constructor(client: QueryClient, queries?: QueryObserverOptions[]) {
     super()
@@ -35,7 +34,6 @@ export class QueriesObserver extends Subscribable<QueriesObserverListener> {
     this.#queries = []
     this.#result = []
     this.#observers = []
-    this.#observersMap = {}
 
     if (queries) {
       this.setQueries(queries)
@@ -82,9 +80,6 @@ export class QueriesObserver extends Subscribable<QueriesObserverListener> {
       )
 
       const newObservers = newObserverMatches.map((match) => match.observer)
-      const newObserversMap = Object.fromEntries(
-        newObservers.map((observer) => [observer.options.queryHash, observer]),
-      )
       const newResult = newObservers.map((observer) =>
         observer.getCurrentResult(),
       )
@@ -97,7 +92,6 @@ export class QueriesObserver extends Subscribable<QueriesObserverListener> {
       }
 
       this.#observers = newObservers
-      this.#observersMap = newObserversMap
       this.#result = newResult
 
       if (!this.hasListeners()) {
@@ -166,7 +160,9 @@ export class QueriesObserver extends Subscribable<QueriesObserverListener> {
 
     const getObserver = (options: QueryObserverOptions): QueryObserver => {
       const defaultedOptions = this.#client.defaultQueryOptions(options)
-      const currentObserver = this.#observersMap[defaultedOptions.queryHash!]
+      const currentObserver = this.#observers.find(
+        (o) => o.options.queryHash === defaultedOptions.queryHash,
+      )
       return (
         currentObserver ?? new QueryObserver(this.#client, defaultedOptions)
       )

package/src/query.ts

@@ -9,7 +9,7 @@ import type {
   CancelOptions,
   SetDataOptions,
   FetchStatus,
-  RegisteredError,
+  DefaultError,
 } from './types'
 import type { QueryCache } from './queryCache'
 import type { QueryObserver } from './queryObserver'
@@ -34,7 +34,7 @@ interface QueryConfig<
   state?: QueryState<TData, TError>
 }
 
-export interface QueryState<TData = unknown, TError = RegisteredError> {
+export interface QueryState<TData = unknown, TError = DefaultError> {
   data: TData | undefined
   dataUpdateCount: number
   dataUpdatedAt: number
@@ -65,7 +65,7 @@ export interface FetchContext<
 
 export interface QueryBehavior<
   TQueryFnData = unknown,
-  TError = RegisteredError,
+  TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > {
@@ -142,7 +142,7 @@ export interface SetStateOptions {
 
 export class Query<
   TQueryFnData = unknown,
-  TError = RegisteredError,
+  TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > extends Removable {
@@ -433,7 +433,15 @@ export class Query<
 
       if (!isCancelledError(error)) {
         // Notify cache callback
-        this.#cache.config.onError?.(error, this as Query<any, any, any, any>)
+        this.#cache.config.onError?.(
+          error as any,
+          this as Query<any, any, any, any>,
+        )
+        this.#cache.config.onSettled?.(
+          this.state.data,
+          error as any,
+          this as Query<any, any, any, any>,
+        )
       }
 
       if (!this.isFetchingOptimistic) {
@@ -462,6 +470,11 @@ export class Query<
 
         // Notify cache callback
         this.#cache.config.onSuccess?.(data, this as Query<any, any, any, any>)
+        this.#cache.config.onSettled?.(
+          data,
+          this.state.error as any,
+          this as Query<any, any, any, any>,
+        )
 
         if (!this.isFetchingOptimistic) {
           // Schedule query gc after fetching

package/src/queryCache.ts

@@ -6,7 +6,7 @@ import type {
   NotifyEvent,
   QueryKey,
   QueryOptions,
-  RegisteredError,
+  DefaultError,
   WithRequired,
 } from './types'
 import { notifyManager } from './notifyManager'
@@ -17,8 +17,16 @@ import type { QueryObserver } from './queryObserver'
 // TYPES
 
 interface QueryCacheConfig {
-  onError?: (error: unknown, query: Query<unknown, unknown, unknown>) => void
+  onError?: (
+    error: DefaultError,
+    query: Query<unknown, unknown, unknown>,
+  ) => void
   onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void
+  onSettled?: (
+    data: unknown | undefined,
+    error: DefaultError | null,
+    query: Query<unknown, unknown, unknown>,
+  ) => void
   createStore?: () => QueryStore
 }
 
@@ -150,7 +158,7 @@ export class QueryCache extends Subscribable<QueryCacheListener> {
 
   get<
     TQueryFnData = unknown,
-    TError = RegisteredError,
+    TError = DefaultError,
     TData = TQueryFnData,
     TQueryKey extends QueryKey = QueryKey,
   >(
@@ -165,7 +173,7 @@ export class QueryCache extends Subscribable<QueryCacheListener> {
     return [...this.#queries.values()]
   }
 
-  find<TQueryFnData = unknown, TError = RegisteredError, TData = TQueryFnData>(
+  find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(
     filters: WithRequired<QueryFilters, 'queryKey'>,
   ): Query<TQueryFnData, TError, TData> | undefined {
     if (typeof filters.exact === 'undefined') {

package/src/queryClient.ts

@@ -24,7 +24,7 @@ import type {
   RefetchQueryFilters,
   ResetOptions,
   SetDataOptions,
-  RegisteredError,
+  DefaultError,
 } from './types'
 import type { QueryState } from './query'
 import { QueryCache } from './queryCache'
@@ -177,7 +177,7 @@ export class QueryClient {
     )
   }
 
-  getQueryState<TQueryFnData = unknown, TError = RegisteredError>(
+  getQueryState<TQueryFnData = unknown, TError = DefaultError>(
     queryKey: QueryKey,
   ): QueryState<TQueryFnData, TError> | undefined {
     return this.#queryCache.find<TQueryFnData, TError>({ queryKey })?.state
@@ -272,7 +272,7 @@ export class QueryClient {
 
   fetchQuery<
     TQueryFnData,
-    TError = RegisteredError,
+    TError = DefaultError,
     TData = TQueryFnData,
     TQueryKey extends QueryKey = QueryKey,
     TPageParam = never,
@@ -301,7 +301,7 @@ export class QueryClient {
 
   prefetchQuery<
     TQueryFnData = unknown,
-    TError = RegisteredError,
+    TError = DefaultError,
     TData = TQueryFnData,
     TQueryKey extends QueryKey = QueryKey,
   >(
@@ -312,7 +312,7 @@ export class QueryClient {
 
   fetchInfiniteQuery<
     TQueryFnData,
-    TError = RegisteredError,
+    TError = DefaultError,
     TData = TQueryFnData,
     TQueryKey extends QueryKey = QueryKey,
     TPageParam = unknown,
@@ -331,7 +331,7 @@ export class QueryClient {
 
   prefetchInfiniteQuery<
     TQueryFnData,
-    TError = RegisteredError,
+    TError = DefaultError,
     TData = TQueryFnData,
     TQueryKey extends QueryKey = QueryKey,
     TPageParam = unknown,
@@ -422,7 +422,7 @@ export class QueryClient {
 
   defaultQueryOptions<
     TQueryFnData = unknown,
-    TError = RegisteredError,
+    TError = DefaultError,
     TData = TQueryFnData,
     TQueryData = TQueryFnData,
     TQueryKey extends QueryKey = QueryKey,

package/src/queryObserver.ts

@@ -1,4 +1,4 @@
-import type { DefaultedQueryObserverOptions, RegisteredError } from './types'
+import type { DefaultedQueryObserverOptions, DefaultError } from './types'
 import {
   isServer,
   isValidTimeout,
@@ -39,7 +39,7 @@ export interface ObserverFetchOptions extends FetchOptions {
 
 export class QueryObserver<
   TQueryFnData = unknown,
-  TError = RegisteredError,
+  TError = DefaultError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,

package/src/retryer.ts

@@ -1,11 +1,11 @@
 import { focusManager } from './focusManager'
 import { onlineManager } from './onlineManager'
 import { sleep } from './utils'
-import type { CancelOptions, NetworkMode, RegisteredError } from './types'
+import type { CancelOptions, NetworkMode, DefaultError } from './types'
 
 // TYPES
 
-interface RetryerConfig<TData = unknown, TError = RegisteredError> {
+interface RetryerConfig<TData = unknown, TError = DefaultError> {
   fn: () => TData | Promise<TData>
   abort?: () => void
   onError?: (error: TError) => void
@@ -28,14 +28,14 @@ export interface Retryer<TData = unknown> {
 
 export type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>
 
-type ShouldRetryFunction<TError = RegisteredError> = (
+type ShouldRetryFunction<TError = DefaultError> = (
   failureCount: number,
   error: TError,
 ) => boolean
 
 export type RetryDelayValue<TError> = number | RetryDelayFunction<TError>
 
-type RetryDelayFunction<TError = RegisteredError> = (
+type RetryDelayFunction<TError = DefaultError> = (
   failureCount: number,
   error: TError,
 ) => number
@@ -63,7 +63,7 @@ export function isCancelledError(value: any): value is CancelledError {
   return value instanceof CancelledError
 }
 
-export function createRetryer<TData = unknown, TError = RegisteredError>(
+export function createRetryer<TData = unknown, TError = DefaultError>(
   config: RetryerConfig<TData, TError>,
 ): Retryer<TData> {
   let isRetryCancelled = false

package/src/tests/mutationCache.test.tsx

@@ -3,11 +3,13 @@ import { queryKey, sleep, executeMutation, createQueryClient } from './utils'
 import { MutationCache, MutationObserver } from '..'
 
 describe('mutationCache', () => {
-  describe('MutationCacheConfig.onError', () => {
-    test('should be called when a mutation errors', async () => {
+  describe('MutationCacheConfig error callbacks', () => {
+    test('should call onError and onSettled when a mutation errors', async () => {
       const key = queryKey()
       const onError = jest.fn()
-      const testCache = new MutationCache({ onError })
+      const onSuccess = jest.fn()
+      const onSettled = jest.fn()
+      const testCache = new MutationCache({ onError, onSuccess, onSettled })
       const testClient = createQueryClient({ mutationCache: testCache })
 
       try {
@@ -23,12 +25,22 @@ describe('mutationCache', () => {
       } catch {}
 
       const mutation = testCache.getAll()[0]
+      expect(onError).toHaveBeenCalledTimes(1)
       expect(onError).toHaveBeenCalledWith(
         new Error('error'),
         'vars',
         'context',
         mutation,
       )
+      expect(onSuccess).not.toHaveBeenCalled()
+      expect(onSettled).toHaveBeenCalledTimes(1)
+      expect(onSettled).toHaveBeenCalledWith(
+        undefined,
+        new Error('error'),
+        'vars',
+        'context',
+        mutation,
+      )
     })
 
     test('should be awaited', async () => {
@@ -39,7 +51,12 @@ describe('mutationCache', () => {
         await sleep(1)
         states.push(2)
       }
-      const testCache = new MutationCache({ onError })
+      const onSettled = async () => {
+        states.push(5)
+        await sleep(1)
+        states.push(6)
+      }
+      const testCache = new MutationCache({ onError, onSettled })
       const testClient = createQueryClient({ mutationCache: testCache })
 
       try {
@@ -53,19 +70,26 @@ describe('mutationCache', () => {
               await sleep(1)
               states.push(4)
             },
+            onSettled: async () => {
+              states.push(7)
+              await sleep(1)
+              states.push(8)
+            },
           },
           'vars',
         )
       } catch {}
 
-      expect(states).toEqual([1, 2, 3, 4])
+      expect(states).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
     })
   })
-  describe('MutationCacheConfig.onSuccess', () => {
-    test('should be called when a mutation is successful', async () => {
+  describe('MutationCacheConfig success callbacks', () => {
+    test('should call onSuccess and onSettled when a mutation is successful', async () => {
       const key = queryKey()
+      const onError = jest.fn()
       const onSuccess = jest.fn()
-      const testCache = new MutationCache({ onSuccess })
+      const onSettled = jest.fn()
+      const testCache = new MutationCache({ onError, onSuccess, onSettled })
       const testClient = createQueryClient({ mutationCache: testCache })
 
       try {
@@ -81,12 +105,22 @@ describe('mutationCache', () => {
       } catch {}
 
       const mutation = testCache.getAll()[0]
+      expect(onSuccess).toHaveBeenCalledTimes(1)
       expect(onSuccess).toHaveBeenCalledWith(
         { data: 5 },
         'vars',
         'context',
         mutation,
       )
+      expect(onError).not.toHaveBeenCalled()
+      expect(onSettled).toHaveBeenCalledTimes(1)
+      expect(onSettled).toHaveBeenCalledWith(
+        { data: 5 },
+        null,
+        'vars',
+        'context',
+        mutation,
+      )
     })
     test('should be awaited', async () => {
       const key = queryKey()
@@ -96,7 +130,12 @@ describe('mutationCache', () => {
         await sleep(1)
         states.push(2)
       }
-      const testCache = new MutationCache({ onSuccess })
+      const onSettled = async () => {
+        states.push(5)
+        await sleep(1)
+        states.push(6)
+      }
+      const testCache = new MutationCache({ onSuccess, onSettled })
       const testClient = createQueryClient({ mutationCache: testCache })
 
       await executeMutation(
@@ -109,11 +148,16 @@ describe('mutationCache', () => {
             await sleep(1)
             states.push(4)
           },
+          onSettled: async () => {
+            states.push(7)
+            await sleep(1)
+            states.push(8)
+          },
         },
         'vars',
       )
 
-      expect(states).toEqual([1, 2, 3, 4])
+      expect(states).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
     })
   })
   describe('MutationCacheConfig.onMutate', () => {

package/src/tests/mutations.test.tsx

@@ -2,6 +2,7 @@ import type { QueryClient } from '..'
 import { createQueryClient, executeMutation, queryKey, sleep } from './utils'
 import type { MutationState } from '../mutation'
 import { MutationObserver } from '../mutationObserver'
+import { waitFor } from '@testing-library/react'
 
 describe('mutations', () => {
   let queryClient: QueryClient
@@ -377,4 +378,34 @@ describe('mutations', () => {
     expect(onSuccess).not.toHaveBeenCalled()
     expect(onSettled).not.toHaveBeenCalled()
   })
+
+  test('mutation callbacks should see updated options', async () => {
+    const onSuccess = jest.fn()
+
+    const mutation = new MutationObserver(queryClient, {
+      mutationFn: async () => {
+        sleep(100)
+        return 'update'
+      },
+      onSuccess: () => {
+        onSuccess(1)
+      },
+    })
+
+    void mutation.mutate()
+
+    mutation.setOptions({
+      mutationFn: async () => {
+        sleep(100)
+        return 'update'
+      },
+      onSuccess: () => {
+        onSuccess(2)
+      },
+    })
+
+    await waitFor(() => expect(onSuccess).toHaveBeenCalledTimes(1))
+
+    expect(onSuccess).toHaveBeenCalledWith(2)
+  })
 })