@tanstack/query-core 4.22.4 → 4.24.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/query-core",
-  "version": "4.22.4",
+  "version": "4.24.3",
   "description": "The framework agnostic core that powers TanStack Query",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -33,7 +33,6 @@
     "test:types": "tsc",
     "test:lib": "jest --config ./jest.config.ts",
     "test:lib:dev": "pnpm run test:lib --watch",
-    "test:lib:publish": "pnpm run test:lib --collectCoverage false",
     "build:types": "tsc --build"
   }
 }

package/src/mutationCache.ts

@@ -79,6 +79,7 @@ export class MutationCache extends Subscribable<MutationCacheListener> {
 
   private mutations: Mutation<any, any, any, any>[]
   private mutationId: number
+  private resuming: Promise<void> | undefined
 
   constructor(config?: MutationCacheConfig) {
     super()
@@ -153,13 +154,21 @@ export class MutationCache extends Subscribable<MutationCacheListener> {
   }
 
   resumePausedMutations(): Promise<void> {
-    const pausedMutations = this.mutations.filter((x) => x.state.isPaused)
-    return notifyManager.batch(() =>
-      pausedMutations.reduce(
-        (promise, mutation) =>
-          promise.then(() => mutation.continue().catch(noop)),
-        Promise.resolve(),
-      ),
-    )
+    if (!this.resuming) {
+      const pausedMutations = this.mutations.filter((x) => x.state.isPaused)
+      this.resuming = notifyManager
+        .batch(() =>
+          pausedMutations.reduce(
+            (promise, mutation) =>
+              promise.then(() => mutation.continue().catch(noop)),
+            Promise.resolve(),
+          ),
+        )
+        .then(() => {
+          this.resuming = undefined
+        })
+    }
+
+    return this.resuming
   }
 }

package/src/query.ts

@@ -173,6 +173,7 @@ export class Query<
     this.queryHash = config.queryHash
     this.initialState = config.state || getDefaultState(this.options)
     this.state = this.initialState
+    this.scheduleGc()
   }
 
   get meta(): QueryMeta | undefined {

package/src/tests/query.test.tsx

@@ -883,4 +883,28 @@ describe('query', () => {
 
     expect(initialDataUpdatedAtSpy).toHaveBeenCalled()
   })
+
+  test('queries should be garbage collected even if they never fetched', async () => {
+    const key = queryKey()
+
+    queryClient.setQueryDefaults(key, { cacheTime: 10 })
+
+    const fn = jest.fn()
+
+    const unsubscribe = queryClient.getQueryCache().subscribe(fn)
+
+    queryClient.setQueryData(key, 'data')
+
+    await waitFor(() =>
+      expect(fn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'removed',
+        }),
+      ),
+    )
+
+    expect(queryClient.getQueryCache().findAll()).toHaveLength(0)
+
+    unsubscribe()
+  })
 })

package/src/tests/queryClient.test.tsx

@@ -8,8 +8,9 @@ import type {
   QueryFunction,
   QueryObserverOptions,
 } from '..'
-import { InfiniteQueryObserver, QueryObserver } from '..'
+import { InfiniteQueryObserver, MutationObserver, QueryObserver } from '..'
 import { focusManager, onlineManager } from '..'
+import { noop } from '../utils'
 
 describe('queryClient', () => {
   let queryClient: QueryClient
@@ -1468,6 +1469,83 @@ describe('queryClient', () => {
       onlineManager.setOnline(undefined)
     })
 
+    test('should resume paused mutations when coming online', async () => {
+      const consoleMock = jest.spyOn(console, 'error')
+      consoleMock.mockImplementation(() => undefined)
+      onlineManager.setOnline(false)
+
+      const observer1 = new MutationObserver(queryClient, {
+        mutationFn: async () => 1,
+      })
+
+      const observer2 = new MutationObserver(queryClient, {
+        mutationFn: async () => 2,
+      })
+      void observer1.mutate().catch(noop)
+      void observer2.mutate().catch(noop)
+
+      await waitFor(() => {
+        expect(observer1.getCurrentResult().isPaused).toBeTruthy()
+        expect(observer2.getCurrentResult().isPaused).toBeTruthy()
+      })
+
+      onlineManager.setOnline(true)
+
+      await waitFor(() => {
+        expect(observer1.getCurrentResult().status).toBe('success')
+        expect(observer1.getCurrentResult().status).toBe('success')
+      })
+
+      onlineManager.setOnline(undefined)
+    })
+
+    test('should resume paused mutations one after the other when invoked manually at the same time', async () => {
+      const consoleMock = jest.spyOn(console, 'error')
+      consoleMock.mockImplementation(() => undefined)
+      onlineManager.setOnline(false)
+
+      const orders: Array<string> = []
+
+      const observer1 = new MutationObserver(queryClient, {
+        mutationFn: async () => {
+          orders.push('1start')
+          await sleep(50)
+          orders.push('1end')
+          return 1
+        },
+      })
+
+      const observer2 = new MutationObserver(queryClient, {
+        mutationFn: async () => {
+          orders.push('2start')
+          await sleep(20)
+          orders.push('2end')
+          return 2
+        },
+      })
+      void observer1.mutate().catch(noop)
+      void observer2.mutate().catch(noop)
+
+      await waitFor(() => {
+        expect(observer1.getCurrentResult().isPaused).toBeTruthy()
+        expect(observer2.getCurrentResult().isPaused).toBeTruthy()
+      })
+
+      onlineManager.setOnline(undefined)
+      void queryClient.resumePausedMutations()
+      await sleep(5)
+      await queryClient.resumePausedMutations()
+
+      await waitFor(() => {
+        expect(observer1.getCurrentResult().status).toBe('success')
+        expect(observer2.getCurrentResult().status).toBe('success')
+      })
+
+      console.log('orders', orders)
+
+      expect(orders).toEqual(['1start', '1end', '2start', '2end'])
+    })
+
     test('should notify queryCache and mutationCache after multiple mounts and single unmount', async () => {
       const testClient = createQueryClient()
       testClient.mount()