@tanstack/query-core 4.10.3 → 4.12.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/query-core",
-  "version": "4.10.3",
-  "description": "TODO",
+  "version": "4.12.0",
+  "description": "The framework agnostic core that powers TanStack Query",
   "author": "tannerlinsley",
   "license": "MIT",
   "repository": "tanstack/query",
@@ -29,6 +29,8 @@
   ],
   "scripts": {
     "clean": "rm -rf ./build",
-    "test:eslint": "../../node_modules/.bin/eslint --ext .ts,.tsx ./src"
+    "test:eslint": "../../node_modules/.bin/eslint --ext .ts,.tsx ./src",
+    "test:jest": "../../node_modules/.bin/jest --config ./jest.config.ts",
+    "test:dev": "pnpm run test:jest --watch"
   }
 }

package/src/mutation.ts

@@ -193,7 +193,7 @@ export class Mutation<
       if (!restored) {
         this.dispatch({ type: 'loading', variables: this.options.variables! })
         // Notify cache callback
-        this.mutationCache.config.onMutate?.(
+        await this.mutationCache.config.onMutate?.(
           this.state.variables,
           this as Mutation<unknown, unknown, unknown, unknown>,
         )
@@ -209,7 +209,7 @@ export class Mutation<
       const data = await executeMutation()
 
       // Notify cache callback
-      this.mutationCache.config.onSuccess?.(
+      await this.mutationCache.config.onSuccess?.(
         data,
         this.state.variables,
         this.state.context,
@@ -234,7 +234,7 @@ export class Mutation<
     } catch (error) {
       try {
         // Notify cache callback
-        this.mutationCache.config.onError?.(
+        await this.mutationCache.config.onError?.(
           error,
           this.state.variables,
           this.state.context,

package/src/mutationCache.ts

@@ -16,17 +16,17 @@ interface MutationCacheConfig {
     variables: unknown,
     context: unknown,
     mutation: Mutation<unknown, unknown, unknown>,
-  ) => void
+  ) => Promise<unknown> | unknown
   onSuccess?: (
     data: unknown,
     variables: unknown,
     context: unknown,
     mutation: Mutation<unknown, unknown, unknown>,
-  ) => void
+  ) => Promise<unknown> | unknown
   onMutate?: (
     variables: unknown,
     mutation: Mutation<unknown, unknown, unknown, unknown>,
-  ) => void
+  ) => Promise<unknown> | unknown
 }
 
 interface NotifyEventMutationAdded {

package/src/tests/mutationCache.test.tsx

@@ -22,6 +22,33 @@ describe('mutationCache', () => {
       const mutation = testCache.getAll()[0]
       expect(onError).toHaveBeenCalledWith('error', 'vars', 'context', mutation)
     })
+
+    test('should be awaited', async () => {
+      const key = queryKey()
+      const states: Array<number> = []
+      const onError = async () => {
+        states.push(1)
+        await sleep(1)
+        states.push(2)
+      }
+      const testCache = new MutationCache({ onError })
+      const testClient = createQueryClient({ mutationCache: testCache })
+
+      try {
+        await executeMutation(testClient, {
+          mutationKey: key,
+          variables: 'vars',
+          mutationFn: () => Promise.reject('error'),
+          onError: async () => {
+            states.push(3)
+            await sleep(1)
+            states.push(4)
+          },
+        })
+      } catch {}
+
+      expect(states).toEqual([1, 2, 3, 4])
+    })
   })
   describe('MutationCacheConfig.onSuccess', () => {
     test('should be called when a mutation is successful', async () => {
@@ -47,6 +74,30 @@ describe('mutationCache', () => {
         mutation,
       )
     })
+    test('should be awaited', async () => {
+      const key = queryKey()
+      const states: Array<number> = []
+      const onSuccess = async () => {
+        states.push(1)
+        await sleep(1)
+        states.push(2)
+      }
+      const testCache = new MutationCache({ onSuccess })
+      const testClient = createQueryClient({ mutationCache: testCache })
+
+      await executeMutation(testClient, {
+        mutationKey: key,
+        variables: 'vars',
+        mutationFn: () => Promise.resolve({ data: 5 }),
+        onSuccess: async () => {
+          states.push(3)
+          await sleep(1)
+          states.push(4)
+        },
+      })
+
+      expect(states).toEqual([1, 2, 3, 4])
+    })
   })
   describe('MutationCacheConfig.onMutate', () => {
     test('should be called before a mutation executes', async () => {
@@ -67,6 +118,31 @@ describe('mutationCache', () => {
       const mutation = testCache.getAll()[0]
       expect(onMutate).toHaveBeenCalledWith('vars', mutation)
     })
+
+    test('should be awaited', async () => {
+      const key = queryKey()
+      const states: Array<number> = []
+      const onMutate = async () => {
+        states.push(1)
+        await sleep(1)
+        states.push(2)
+      }
+      const testCache = new MutationCache({ onMutate })
+      const testClient = createQueryClient({ mutationCache: testCache })
+
+      await executeMutation(testClient, {
+        mutationKey: key,
+        variables: 'vars',
+        mutationFn: () => Promise.resolve({ data: 5 }),
+        onMutate: async () => {
+          states.push(3)
+          await sleep(1)
+          states.push(4)
+        },
+      })
+
+      expect(states).toEqual([1, 2, 3, 4])
+    })
   })
 
   describe('find', () => {

package/src/tests/utils.ts

@@ -65,11 +65,13 @@ export const executeMutation = (
 // so that we can pretend to be in a server environment
 export function setIsServer(isServer: boolean) {
   const original = utils.isServer
-  // @ts-ignore
-  utils.isServer = isServer
+  Object.defineProperty(utils, 'isServer', {
+    get: () => isServer,
+  })
 
   return () => {
-    // @ts-ignore
-    utils.isServer = original
+    Object.defineProperty(utils, 'isServer', {
+      get: () => original,
+    })
   }
 }