@tanstack/query-core 4.22.0 → 4.24.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/query-core",
-  "version": "4.22.0",
+  "version": "4.24.2",
   "description": "The framework agnostic core that powers TanStack Query",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -28,9 +28,11 @@
     "src"
   ],
   "scripts": {
-    "clean": "rm -rf ./build",
-    "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"
+    "clean": "rimraf ./build",
+    "test:eslint": "eslint --ext .ts,.tsx ./src",
+    "test:types": "tsc",
+    "test:lib": "jest --config ./jest.config.ts",
+    "test:lib:dev": "pnpm run test:lib --watch",
+    "build:types": "tsc --build"
   }
 }

package/src/mutationObserver.ts

@@ -166,7 +166,7 @@ export class MutationObserver<
   private notify(options: NotifyOptions) {
     notifyManager.batch(() => {
       // First trigger the mutate callbacks
-      if (this.mutateOptions) {
+      if (this.mutateOptions && this.hasListeners()) {
         if (options.onSuccess) {
           this.mutateOptions.onSuccess?.(
             this.currentResult.data!,

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/mutations.test.tsx

@@ -308,49 +308,24 @@ describe('mutations', () => {
     expect(onSettled).toHaveBeenCalled()
   })
 
-  test('setState should update the mutation state', async () => {
-    const mutation = new MutationObserver(queryClient, {
-      mutationFn: async () => {
-        return 'update'
-      },
-      onMutate: (text) => text,
-    })
-    await mutation.mutate()
-    expect(mutation.getCurrentResult().data).toEqual('update')
-
-    // Force setState usage
-    // because no use case has been found using mutation.setState
-    const currentMutation = mutation['currentMutation']
-    currentMutation?.setState({
-      context: undefined,
-      variables: undefined,
-      data: 'new',
-      error: undefined,
-      failureCount: 0,
-      failureReason: null,
-      isPaused: false,
-      status: 'success',
-    })
+  test('addObserver should not add an existing observer', async () => {
+    const mutationCache = queryClient.getMutationCache()
+    const observer = new MutationObserver(queryClient, {})
+    const currentMutation = mutationCache.build(queryClient, {})
 
-    expect(mutation.getCurrentResult().data).toEqual('new')
-  })
+    const fn = jest.fn()
 
-  test('addObserver should not add an existing observer', async () => {
-    const mutation = new MutationObserver(queryClient, {
-      mutationFn: async () => {
-        return 'update'
-      },
-      onMutate: (text) => text,
+    const unsubscribe = mutationCache.subscribe((event) => {
+      fn(event.type)
     })
-    await mutation.mutate()
 
-    // Force addObserver usage to add an existing observer
-    // because no use case has been found
-    const currentMutation = mutation['currentMutation']!
-    expect(currentMutation['observers'].length).toEqual(1)
-    currentMutation.addObserver(mutation)
+    currentMutation.addObserver(observer)
+    currentMutation.addObserver(observer)
 
-    expect(currentMutation['observers'].length).toEqual(1)
+    expect(fn).toHaveBeenCalledTimes(1)
+    expect(fn).toHaveBeenCalledWith('observerAdded')
+
+    unsubscribe()
   })
 
   test('mutate should throw an error if no mutationFn found', async () => {
@@ -367,4 +342,20 @@ describe('mutations', () => {
     }
     expect(error).toEqual('No mutationFn found')
   })
+
+  test('mutate update the mutation state even without an active subscription', async () => {
+    const onSuccess = jest.fn()
+    const onSettled = jest.fn()
+
+    const mutation = new MutationObserver(queryClient, {
+      mutationFn: async () => {
+        return 'update'
+      },
+    })
+
+    await mutation.mutate(undefined, { onSuccess, onSettled })
+    expect(mutation.getCurrentResult().data).toEqual('update')
+    expect(onSuccess).not.toHaveBeenCalled()
+    expect(onSettled).not.toHaveBeenCalled()
+  })
 })

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()
+  })
 })