@tanstack/solid-query 5.0.0-alpha.20 → 5.0.0-alpha.21

package/build/source/__tests__/createQueries.test.jsx

@@ -117,10 +117,6 @@ describe('useQueries', () => {
                             expectTypeNotAny(a);
                             return a.toLowerCase();
                         },
-                        onSuccess: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
                         placeholderData: 'string',
                         // @ts-expect-error (initialData: string)
                         initialData: 123,
@@ -133,14 +129,6 @@ describe('useQueries', () => {
                             expectTypeNotAny(a);
                             return parseInt(a);
                         },
-                        onSuccess: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
-                        onError: (e) => {
-                            expectType(e);
-                            expectTypeNotAny(e);
-                        },
                         placeholderData: 'string',
                         // @ts-expect-error (initialData: string)
                         initialData: 123,
@@ -253,10 +241,6 @@ describe('useQueries', () => {
                             expectTypeNotAny(a);
                             return a.toLowerCase();
                         },
-                        onSuccess: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
                         placeholderData: 'string',
                         // @ts-expect-error (initialData: string)
                         initialData: 123,
@@ -269,14 +253,6 @@ describe('useQueries', () => {
                             expectTypeNotAny(a);
                             return parseInt(a);
                         },
-                        onSuccess: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
-                        onError: (e) => {
-                            expectType(e);
-                            expectTypeNotAny(e);
-                        },
                         placeholderData: 'string',
                         // @ts-expect-error (initialData: string)
                         initialData: 123,
@@ -363,59 +339,37 @@ describe('useQueries', () => {
                     },
                 ],
             }));
-            // select / onSuccess / onSettled params are "indirectly" enforced
+            // select params are "indirectly" enforced
             createQueries(() => ({
                 queries: [
                     // unfortunately TS will not suggest the type for you
                     {
                         queryKey: key1,
                         queryFn: () => 'string',
-                        // @ts-expect-error (noImplicitAny)
-                        onSuccess: (a) => null,
-                        // @ts-expect-error (noImplicitAny)
-                        onSettled: (a) => null,
                     },
                     // however you can add a type to the callback
                     {
                         queryKey: key2,
                         queryFn: () => 'string',
-                        onSuccess: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
-                        onSettled: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
                     },
                     // the type you do pass is enforced
                     {
                         queryKey: key3,
                         queryFn: () => 'string',
-                        // @ts-expect-error (only accepts string)
-                        onSuccess: (a) => null,
                     },
                     {
                         queryKey: key4,
                         queryFn: () => 'string',
                         select: (a) => parseInt(a),
-                        // @ts-expect-error (select is defined => only accepts number)
-                        onSuccess: (a) => null,
-                        onSettled: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
                     },
                 ],
             }));
             // callbacks are also indirectly enforced with Array.map
             createQueries(() => ({
-                // @ts-expect-error (onSuccess only accepts string)
                 queries: Array(50).map((_, i) => ({
                     queryKey: ['key', i],
                     queryFn: () => i + 10,
                     select: (data) => data.toString(),
-                    onSuccess: (_data) => null,
                 })),
             }));
             createQueries(() => ({
@@ -423,7 +377,6 @@ describe('useQueries', () => {
                     queryKey: ['key', i],
                     queryFn: () => i + 10,
                     select: (data) => data.toString(),
-                    onSuccess: (_data) => null,
                 })),
             }));
             // results inference works when all the handlers are defined
@@ -432,32 +385,15 @@ describe('useQueries', () => {
                     {
                         queryKey: key1,
                         queryFn: () => 'string',
-                        // @ts-expect-error (noImplicitAny)
-                        onSuccess: (a) => null,
-                        // @ts-expect-error (noImplicitAny)
-                        onSettled: (a) => null,
                     },
                     {
                         queryKey: key2,
                         queryFn: () => 'string',
-                        onSuccess: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
-                        onSettled: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
                     },
                     {
                         queryKey: key4,
                         queryFn: () => 'string',
                         select: (a) => parseInt(a),
-                        onSuccess: (_a) => null,
-                        onSettled: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
                     },
                 ],
             }));
@@ -470,12 +406,6 @@ describe('useQueries', () => {
                     {
                         queryKey: key1,
                         queryFn: () => Promise.resolve('string'),
-                        onSuccess: (a) => {
-                            expectType(a);
-                            expectTypeNotAny(a);
-                        },
-                        // @ts-expect-error (refuses to accept a Promise)
-                        onSettled: (a) => null,
                     },
                 ],
             }));
@@ -555,11 +485,10 @@ describe('useQueries', () => {
                 queries: queries.map(
                 // no need to type the mapped query
                 (query) => {
-                    const { queryFn: fn, queryKey: key, onError: err } = query;
+                    const { queryFn: fn, queryKey: key } = query;
                     expectType(fn);
                     return {
                         queryKey: key,
-                        onError: err,
                         queryFn: fn
                             ? (ctx) => {
                                 expectType(ctx.queryKey);

package/build/source/__tests__/createQuery.test.jsx

@@ -42,20 +42,16 @@ describe('createQuery', () => {
             createQuery(() => ({
                 queryKey: [key],
                 queryFn: async () => true,
-                onSuccess: (data) => expectType(data),
-                onSettled: (data) => expectType(data),
             }));
             // it should be possible to specify a union type as result type
             const unionTypeSync = createQuery(() => ({
                 queryKey: key,
                 queryFn: () => (Math.random() > 0.5 ? 'a' : 'b'),
-                onSuccess: (data) => expectType(data),
             }));
             expectType(unionTypeSync.data);
             const unionTypeAsync = createQuery(() => ({
                 queryKey: key,
                 queryFn: () => Promise.resolve(Math.random() > 0.5 ? 'a' : 'b'),
-                onSuccess: (data) => expectType(data),
             }));
             expectType(unionTypeAsync.data);
             // should error when the query function result does not match with the specified type
@@ -360,189 +356,6 @@ describe('createQuery', () => {
             isFetchedAfterMount: true,
         });
     });
-    it('should call onSuccess after a query has been fetched', async () => {
-        const key = queryKey();
-        const states = [];
-        const onSuccess = vi.fn();
-        function Page() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'data';
-                },
-                onSuccess,
-            }));
-            createRenderEffect(() => {
-                states.push({ ...state });
-            });
-            return <div>data: {state.data}</div>;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await screen.findByText('data: data');
-        expect(states.length).toBe(2);
-        expect(onSuccess).toHaveBeenCalledTimes(1);
-        expect(onSuccess).toHaveBeenCalledWith('data');
-    });
-    it('should call onSuccess after a disabled query has been fetched', async () => {
-        const key = queryKey();
-        const states = [];
-        const onSuccess = vi.fn();
-        function Page() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: () => 'data',
-                enabled: false,
-                onSuccess,
-            }));
-            createRenderEffect(() => {
-                states.push({ ...state });
-            });
-            createEffect(() => {
-                const refetch = state.refetch;
-                setActTimeout(() => {
-                    refetch();
-                }, 10);
-            });
-            return null;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await sleep(50);
-        expect(onSuccess).toHaveBeenCalledTimes(1);
-        expect(onSuccess).toHaveBeenCalledWith('data');
-    });
-    it('should not call onSuccess if a component has unmounted', async () => {
-        const key = queryKey();
-        const states = [];
-        const onSuccess = vi.fn();
-        function Page() {
-            const [show, setShow] = createSignal(true);
-            createEffect(() => {
-                setShow(false);
-            });
-            return <>{show() && <Component />}</>;
-        }
-        function Component() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'data';
-                },
-                onSuccess,
-            }));
-            createRenderEffect(() => {
-                states.push({ ...state });
-            });
-            return null;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await sleep(50);
-        expect(states.length).toBe(1);
-        expect(onSuccess).toHaveBeenCalledTimes(0);
-    });
-    it('should call onError after a query has been fetched with an error', async () => {
-        const key = queryKey();
-        const states = [];
-        const onError = vi.fn();
-        function Page() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: () => Promise.reject(new Error('error')),
-                retry: false,
-                onError,
-            }));
-            createRenderEffect(() => {
-                states.push({ ...state });
-            });
-            return null;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await sleep(10);
-        expect(states.length).toBe(2);
-        expect(onError).toHaveBeenCalledTimes(1);
-        expect(onError).toHaveBeenCalledWith(new Error('error'));
-    });
-    it('should not call onError when receiving a CancelledError', async () => {
-        const key = queryKey();
-        const onError = vi.fn();
-        function Page() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 23;
-                },
-                onError,
-            }));
-            return (<span>
-          status: {state.status}, fetchStatus: {state.fetchStatus}
-        </span>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await sleep(5);
-        await queryClient.cancelQueries({ queryKey: key });
-        // query cancellation will reset the query to it's initial state
-        await waitFor(() => screen.getByText('status: pending, fetchStatus: idle'));
-        expect(onError).not.toHaveBeenCalled();
-    });
-    it('should call onSettled after a query has been fetched', async () => {
-        const key = queryKey();
-        const states = [];
-        const onSettled = vi.fn();
-        function Page() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: () => 'data',
-                onSettled,
-            }));
-            createRenderEffect(() => {
-                states.push({ ...state });
-            });
-            return null;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await sleep(10);
-        expect(states.length).toBe(2);
-        expect(onSettled).toHaveBeenCalledTimes(1);
-        expect(onSettled).toHaveBeenCalledWith('data', null);
-    });
-    it('should call onSettled after a query has been fetched with an error', async () => {
-        const key = queryKey();
-        const states = [];
-        const onSettled = vi.fn();
-        function Page() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: () => Promise.reject('error'),
-                retry: false,
-                onSettled,
-            }));
-            createRenderEffect(() => {
-                states.push({ ...state });
-            });
-            return null;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await sleep(10);
-        expect(states.length).toBe(2);
-        expect(onSettled).toHaveBeenCalledTimes(1);
-        expect(onSettled).toHaveBeenCalledWith(undefined, 'error');
-    });
     it('should not cancel an ongoing fetch when refetch is called with cancelRefetch=false if we have data already', async () => {
         const key = queryKey();
         let fetchCount = 0;
@@ -1751,45 +1564,6 @@ describe('createQuery', () => {
         // There wiil only be one pass
         expect(renders).toBe(1);
     });
-    it('should batch re-renders including hook callbacks', async () => {
-        const key = queryKey();
-        let renders = 0;
-        let callbackCount = 0;
-        const queryFn = async () => {
-            await sleep(10);
-            return 'data';
-        };
-        function Page() {
-            const [count, setCount] = createSignal(0);
-            createQuery(() => ({
-                queryKey: key,
-                queryFn,
-                onSuccess: () => {
-                    setCount((x) => x + 1);
-                },
-            }));
-            createQuery(() => ({
-                queryKey: key,
-                queryFn,
-                onSuccess: () => {
-                    setCount((x) => x + 1);
-                },
-            }));
-            createEffect(() => {
-                renders++;
-                callbackCount = count();
-            });
-            return <div>count: {count()}</div>;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await waitFor(() => screen.getByText('count: 2'));
-        // Should be 3 instead of 5
-        expect(renders).toBe(3);
-        // Both callbacks should have been executed
-        expect(callbackCount).toBe(2);
-    });
     it('should render latest data even if react has discarded certain renders', async () => {
         const key = queryKey();
         function Page() {
@@ -4554,31 +4328,6 @@ describe('createQuery', () => {
             error,
         });
     });
-    it('setQueryData - should not call onSuccess callback of active observers', async () => {
-        const key = queryKey();
-        const onSuccess = vi.fn();
-        function Page() {
-            const state = createQuery(() => ({
-                queryKey: key,
-                queryFn: () => 'data',
-                onSuccess,
-            }));
-            return (<div>
-          <div>data: {state.data}</div>
-          <button onClick={() => queryClient.setQueryData(key, 'newData')}>
-            setQueryData
-          </button>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await waitFor(() => screen.getByText('data: data'));
-        fireEvent.click(screen.getByRole('button', { name: /setQueryData/i }));
-        await waitFor(() => screen.getByText('data: newData'));
-        expect(onSuccess).toHaveBeenCalledTimes(1);
-        expect(onSuccess).toHaveBeenCalledWith('data');
-    });
     it('setQueryData - should respect updatedAt', async () => {
         const key = queryKey();
         function Page() {

package/build/source/__tests__/suspense.test.jsx

@@ -140,68 +140,6 @@ describe("useQuery's in Suspense mode", () => {
         expect(screen.queryByText('rendered')).toBeNull();
         expect(queryCache.find({ queryKey: key })?.getObserversCount()).toBe(0);
     });
-    it('should call onSuccess on the first successful call', async () => {
-        const key = queryKey();
-        const successFn = vi.fn();
-        function Page() {
-            createQuery(() => ({
-                queryKey: [key],
-                queryFn: async () => {
-                    await sleep(10);
-                    return key;
-                },
-                suspense: true,
-                select: () => 'selected',
-                onSuccess: successFn,
-            }));
-            return <>rendered</>;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Suspense fallback="loading">
-          <Page />
-        </Suspense>
-      </QueryClientProvider>));
-        await waitFor(() => screen.getByText('rendered'));
-        await waitFor(() => expect(successFn).toHaveBeenCalledTimes(1));
-        await waitFor(() => expect(successFn).toHaveBeenCalledWith('selected'));
-    });
-    it('should call every onSuccess handler within a suspense boundary', async () => {
-        const key = queryKey();
-        const successFn1 = vi.fn();
-        const successFn2 = vi.fn();
-        function FirstComponent() {
-            createQuery(() => ({
-                queryKey: key,
-                queryFn: () => {
-                    sleep(10);
-                    return 'data';
-                },
-                onSuccess: successFn1,
-            }));
-            return <span>first</span>;
-        }
-        function SecondComponent() {
-            createQuery(() => ({
-                queryKey: key,
-                queryFn: () => {
-                    sleep(10);
-                    return 'data';
-                },
-                onSuccess: successFn2,
-            }));
-            return <span>second</span>;
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Suspense fallback="loading">
-          <FirstComponent />
-          <SecondComponent />
-        </Suspense>
-        ,
-      </QueryClientProvider>));
-        await waitFor(() => screen.getByText('second'));
-        await waitFor(() => expect(successFn1).toHaveBeenCalledTimes(1));
-        await waitFor(() => expect(successFn2).toHaveBeenCalledTimes(1));
-    });
     // https://github.com/tannerlinsley/react-query/issues/468
     it('should reset error state if new component instances are mounted', async () => {
         const key = queryKey();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-query",
-  "version": "5.0.0-alpha.20",
+  "version": "5.0.0-alpha.21",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "vite-plugin-solid": "^2.3.9"
   },
   "dependencies": {
-    "@tanstack/query-core": "5.0.0-alpha.19"
+    "@tanstack/query-core": "5.0.0-alpha.21"
   },
   "peerDependencies": {
     "solid-js": "^1.6.13"

package/src/__tests__/createQueries.test.tsx

@@ -158,10 +158,6 @@ describe('useQueries', () => {
                 expectTypeNotAny(a)
                 return a.toLowerCase()
               },
-              onSuccess: (a) => {
-                expectType<string>(a)
-                expectTypeNotAny(a)
-              },
               placeholderData: 'string',
               // @ts-expect-error (initialData: string)
               initialData: 123,
@@ -174,14 +170,6 @@ describe('useQueries', () => {
                 expectTypeNotAny(a)
                 return parseInt(a)
               },
-              onSuccess: (a) => {
-                expectType<number>(a)
-                expectTypeNotAny(a)
-              },
-              onError: (e) => {
-                expectType<boolean>(e)
-                expectTypeNotAny(e)
-              },
               placeholderData: 'string',
               // @ts-expect-error (initialData: string)
               initialData: 123,
@@ -319,10 +307,6 @@ describe('useQueries', () => {
               expectTypeNotAny(a)
               return a.toLowerCase()
             },
-            onSuccess: (a) => {
-              expectType<string>(a)
-              expectTypeNotAny(a)
-            },
             placeholderData: 'string',
             // @ts-expect-error (initialData: string)
             initialData: 123,
@@ -335,14 +319,6 @@ describe('useQueries', () => {
               expectTypeNotAny(a)
               return parseInt(a)
             },
-            onSuccess: (a) => {
-              expectType<number>(a)
-              expectTypeNotAny(a)
-            },
-            onError: (e) => {
-              expectType<boolean>(e)
-              expectTypeNotAny(e)
-            },
             placeholderData: 'string',
             // @ts-expect-error (initialData: string)
             initialData: 123,
@@ -436,60 +412,38 @@ describe('useQueries', () => {
         ],
       }))
 
-      // select / onSuccess / onSettled params are "indirectly" enforced
+      // select params are "indirectly" enforced
       createQueries(() => ({
         queries: [
           // unfortunately TS will not suggest the type for you
           {
             queryKey: key1,
             queryFn: () => 'string',
-            // @ts-expect-error (noImplicitAny)
-            onSuccess: (a) => null,
-            // @ts-expect-error (noImplicitAny)
-            onSettled: (a) => null,
           },
           // however you can add a type to the callback
           {
             queryKey: key2,
             queryFn: () => 'string',
-            onSuccess: (a: string) => {
-              expectType<string>(a)
-              expectTypeNotAny(a)
-            },
-            onSettled: (a: string | undefined) => {
-              expectType<string | undefined>(a)
-              expectTypeNotAny(a)
-            },
           },
           // the type you do pass is enforced
           {
             queryKey: key3,
             queryFn: () => 'string',
-            // @ts-expect-error (only accepts string)
-            onSuccess: (a: number) => null,
           },
           {
             queryKey: key4,
             queryFn: () => 'string',
             select: (a: string) => parseInt(a),
-            // @ts-expect-error (select is defined => only accepts number)
-            onSuccess: (a: string) => null,
-            onSettled: (a: number | undefined) => {
-              expectType<number | undefined>(a)
-              expectTypeNotAny(a)
-            },
           },
         ],
       }))
 
       // callbacks are also indirectly enforced with Array.map
       createQueries(() => ({
-        // @ts-expect-error (onSuccess only accepts string)
         queries: Array(50).map((_, i) => ({
           queryKey: ['key', i] as const,
           queryFn: () => i + 10,
           select: (data: number) => data.toString(),
-          onSuccess: (_data: number) => null,
         })),
       }))
 
@@ -498,7 +452,6 @@ describe('useQueries', () => {
           queryKey: ['key', i] as const,
           queryFn: () => i + 10,
           select: (data: number) => data.toString(),
-          onSuccess: (_data: string) => null,
         })),
       }))
 
@@ -508,32 +461,15 @@ describe('useQueries', () => {
           {
             queryKey: key1,
             queryFn: () => 'string',
-            // @ts-expect-error (noImplicitAny)
-            onSuccess: (a) => null,
-            // @ts-expect-error (noImplicitAny)
-            onSettled: (a) => null,
           },
           {
             queryKey: key2,
             queryFn: () => 'string',
-            onSuccess: (a: string) => {
-              expectType<string>(a)
-              expectTypeNotAny(a)
-            },
-            onSettled: (a: string | undefined) => {
-              expectType<string | undefined>(a)
-              expectTypeNotAny(a)
-            },
           },
           {
             queryKey: key4,
             queryFn: () => 'string',
             select: (a: string) => parseInt(a),
-            onSuccess: (_a: number) => null,
-            onSettled: (a: number | undefined) => {
-              expectType<number | undefined>(a)
-              expectTypeNotAny(a)
-            },
           },
         ],
       }))
@@ -547,12 +483,6 @@ describe('useQueries', () => {
           {
             queryKey: key1,
             queryFn: () => Promise.resolve('string'),
-            onSuccess: (a: string) => {
-              expectType<string>(a)
-              expectTypeNotAny(a)
-            },
-            // @ts-expect-error (refuses to accept a Promise)
-            onSettled: (a: Promise<string>) => null,
           },
         ],
       }))
@@ -658,11 +588,10 @@ describe('useQueries', () => {
         queries: queries.map(
           // no need to type the mapped query
           (query) => {
-            const { queryFn: fn, queryKey: key, onError: err } = query
+            const { queryFn: fn, queryKey: key } = query
             expectType<QueryFunction<TQueryFnData, TQueryKey> | undefined>(fn)
             return {
               queryKey: key,
-              onError: err,
               queryFn: fn
                 ? (ctx: QueryFunctionContext<TQueryKey>) => {
                     expectType<TQueryKey>(ctx.queryKey)

package/src/__tests__/createQuery.test.tsx

@@ -80,21 +80,17 @@ describe('createQuery', () => {
       createQuery(() => ({
         queryKey: [key],
         queryFn: async () => true,
-        onSuccess: (data) => expectType<boolean>(data),
-        onSettled: (data) => expectType<boolean | undefined>(data),
       }))
 
       // it should be possible to specify a union type as result type
       const unionTypeSync = createQuery(() => ({
         queryKey: key,
         queryFn: () => (Math.random() > 0.5 ? 'a' : 'b'),
-        onSuccess: (data) => expectType<'a' | 'b'>(data),
       }))
       expectType<'a' | 'b' | undefined>(unionTypeSync.data)
       const unionTypeAsync = createQuery<'a' | 'b'>(() => ({
         queryKey: key,
         queryFn: () => Promise.resolve(Math.random() > 0.5 ? 'a' : 'b'),
-        onSuccess: (data) => expectType<'a' | 'b'>(data),
       }))
       expectType<'a' | 'b' | undefined>(unionTypeAsync.data)
 
@@ -491,241 +487,6 @@ describe('createQuery', () => {
     })
   })
 
-  it('should call onSuccess after a query has been fetched', async () => {
-    const key = queryKey()
-    const states: CreateQueryResult<string>[] = []
-    const onSuccess = vi.fn()
-
-    function Page() {
-      const state = createQuery(() => ({
-        queryKey: key,
-        queryFn: async () => {
-          await sleep(10)
-          return 'data'
-        },
-        onSuccess,
-      }))
-      createRenderEffect(() => {
-        states.push({ ...state })
-      })
-      return <div>data: {state.data}</div>
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await screen.findByText('data: data')
-    expect(states.length).toBe(2)
-    expect(onSuccess).toHaveBeenCalledTimes(1)
-    expect(onSuccess).toHaveBeenCalledWith('data')
-  })
-
-  it('should call onSuccess after a disabled query has been fetched', async () => {
-    const key = queryKey()
-    const states: CreateQueryResult<string>[] = []
-    const onSuccess = vi.fn()
-
-    function Page() {
-      const state = createQuery(() => ({
-        queryKey: key,
-        queryFn: () => 'data',
-        enabled: false,
-        onSuccess,
-      }))
-
-      createRenderEffect(() => {
-        states.push({ ...state })
-      })
-
-      createEffect(() => {
-        const refetch = state.refetch
-        setActTimeout(() => {
-          refetch()
-        }, 10)
-      })
-
-      return null
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await sleep(50)
-    expect(onSuccess).toHaveBeenCalledTimes(1)
-    expect(onSuccess).toHaveBeenCalledWith('data')
-  })
-
-  it('should not call onSuccess if a component has unmounted', async () => {
-    const key = queryKey()
-    const states: CreateQueryResult<string>[] = []
-    const onSuccess = vi.fn()
-
-    function Page() {
-      const [show, setShow] = createSignal(true)
-
-      createEffect(() => {
-        setShow(false)
-      })
-      return <>{show() && <Component />}</>
-    }
-
-    function Component() {
-      const state = createQuery(() => ({
-        queryKey: key,
-        queryFn: async () => {
-          await sleep(10)
-          return 'data'
-        },
-        onSuccess,
-      }))
-      createRenderEffect(() => {
-        states.push({ ...state })
-      })
-      return null
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await sleep(50)
-    expect(states.length).toBe(1)
-    expect(onSuccess).toHaveBeenCalledTimes(0)
-  })
-
-  it('should call onError after a query has been fetched with an error', async () => {
-    const key = queryKey()
-    const states: CreateQueryResult<unknown>[] = []
-    const onError = vi.fn()
-
-    function Page() {
-      const state = createQuery(() => ({
-        queryKey: key,
-        queryFn: () => Promise.reject(new Error('error')),
-        retry: false,
-        onError,
-      }))
-
-      createRenderEffect(() => {
-        states.push({ ...state })
-      })
-
-      return null
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await sleep(10)
-    expect(states.length).toBe(2)
-    expect(onError).toHaveBeenCalledTimes(1)
-    expect(onError).toHaveBeenCalledWith(new Error('error'))
-  })
-
-  it('should not call onError when receiving a CancelledError', async () => {
-    const key = queryKey()
-    const onError = vi.fn()
-
-    function Page() {
-      const state = createQuery(() => ({
-        queryKey: key,
-        queryFn: async () => {
-          await sleep(10)
-          return 23
-        },
-        onError,
-      }))
-      return (
-        <span>
-          status: {state.status}, fetchStatus: {state.fetchStatus}
-        </span>
-      )
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await sleep(5)
-    await queryClient.cancelQueries({ queryKey: key })
-    // query cancellation will reset the query to it's initial state
-    await waitFor(() => screen.getByText('status: pending, fetchStatus: idle'))
-    expect(onError).not.toHaveBeenCalled()
-  })
-
-  it('should call onSettled after a query has been fetched', async () => {
-    const key = queryKey()
-    const states: CreateQueryResult<string>[] = []
-    const onSettled = vi.fn()
-
-    function Page() {
-      const state = createQuery(() => ({
-        queryKey: key,
-        queryFn: () => 'data',
-        onSettled,
-      }))
-
-      createRenderEffect(() => {
-        states.push({ ...state })
-      })
-      return null
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await sleep(10)
-    expect(states.length).toBe(2)
-    expect(onSettled).toHaveBeenCalledTimes(1)
-    expect(onSettled).toHaveBeenCalledWith('data', null)
-  })
-
-  it('should call onSettled after a query has been fetched with an error', async () => {
-    const key = queryKey()
-    const states: CreateQueryResult<string>[] = []
-    const onSettled = vi.fn()
-
-    function Page() {
-      const state = createQuery(() => ({
-        queryKey: key,
-        queryFn: () => Promise.reject<unknown>('error'),
-        retry: false,
-        onSettled,
-      }))
-      createRenderEffect(() => {
-        states.push({ ...state })
-      })
-      return null
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await sleep(10)
-    expect(states.length).toBe(2)
-    expect(onSettled).toHaveBeenCalledTimes(1)
-    expect(onSettled).toHaveBeenCalledWith(undefined, 'error')
-  })
-
   it('should not cancel an ongoing fetch when refetch is called with cancelRefetch=false if we have data already', async () => {
     const key = queryKey()
     let fetchCount = 0
@@ -2274,56 +2035,6 @@ describe('createQuery', () => {
     expect(renders).toBe(1)
   })
 
-  it('should batch re-renders including hook callbacks', async () => {
-    const key = queryKey()
-
-    let renders = 0
-    let callbackCount = 0
-
-    const queryFn = async () => {
-      await sleep(10)
-      return 'data'
-    }
-
-    function Page() {
-      const [count, setCount] = createSignal(0)
-      createQuery(() => ({
-        queryKey: key,
-        queryFn,
-        onSuccess: () => {
-          setCount((x) => x + 1)
-        },
-      }))
-      createQuery(() => ({
-        queryKey: key,
-        queryFn,
-        onSuccess: () => {
-          setCount((x) => x + 1)
-        },
-      }))
-
-      createEffect(() => {
-        renders++
-        callbackCount = count()
-      })
-
-      return <div>count: {count()}</div>
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await waitFor(() => screen.getByText('count: 2'))
-
-    // Should be 3 instead of 5
-    expect(renders).toBe(3)
-    // Both callbacks should have been executed
-    expect(callbackCount).toBe(2)
-  })
-
   it('should render latest data even if react has discarded certain renders', async () => {
     const key = queryKey()
 
@@ -6107,40 +5818,6 @@ describe('createQuery', () => {
     })
   })
 
-  it('setQueryData - should not call onSuccess callback of active observers', async () => {
-    const key = queryKey()
-    const onSuccess = vi.fn()
-
-    function Page() {
-      const state = createQuery(() => ({
-        queryKey: key,
-        queryFn: () => 'data',
-        onSuccess,
-      }))
-      return (
-        <div>
-          <div>data: {state.data}</div>
-          <button onClick={() => queryClient.setQueryData(key, 'newData')}>
-            setQueryData
-          </button>
-        </div>
-      )
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>
-    ))
-
-    await waitFor(() => screen.getByText('data: data'))
-    fireEvent.click(screen.getByRole('button', { name: /setQueryData/i }))
-    await waitFor(() => screen.getByText('data: newData'))
-
-    expect(onSuccess).toHaveBeenCalledTimes(1)
-    expect(onSuccess).toHaveBeenCalledWith('data')
-  })
-
   it('setQueryData - should respect updatedAt', async () => {
     const key = queryKey()
 

package/src/__tests__/suspense.test.tsx

@@ -217,89 +217,6 @@ describe("useQuery's in Suspense mode", () => {
     expect(queryCache.find({ queryKey: key })?.getObserversCount()).toBe(0)
   })
 
-  it('should call onSuccess on the first successful call', async () => {
-    const key = queryKey()
-
-    const successFn = vi.fn()
-
-    function Page() {
-      createQuery(() => ({
-        queryKey: [key],
-        queryFn: async () => {
-          await sleep(10)
-          return key
-        },
-
-        suspense: true,
-        select: () => 'selected',
-        onSuccess: successFn,
-      }))
-
-      return <>rendered</>
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Suspense fallback="loading">
-          <Page />
-        </Suspense>
-      </QueryClientProvider>
-    ))
-
-    await waitFor(() => screen.getByText('rendered'))
-
-    await waitFor(() => expect(successFn).toHaveBeenCalledTimes(1))
-    await waitFor(() => expect(successFn).toHaveBeenCalledWith('selected'))
-  })
-
-  it('should call every onSuccess handler within a suspense boundary', async () => {
-    const key = queryKey()
-
-    const successFn1 = vi.fn()
-    const successFn2 = vi.fn()
-
-    function FirstComponent() {
-      createQuery(() => ({
-        queryKey: key,
-        queryFn: () => {
-          sleep(10)
-          return 'data'
-        },
-        onSuccess: successFn1,
-      }))
-
-      return <span>first</span>
-    }
-
-    function SecondComponent() {
-      createQuery(() => ({
-        queryKey: key,
-        queryFn: () => {
-          sleep(10)
-          return 'data'
-        },
-        onSuccess: successFn2,
-      }))
-
-      return <span>second</span>
-    }
-
-    render(() => (
-      <QueryClientProvider client={queryClient}>
-        <Suspense fallback="loading">
-          <FirstComponent />
-          <SecondComponent />
-        </Suspense>
-        ,
-      </QueryClientProvider>
-    ))
-
-    await waitFor(() => screen.getByText('second'))
-
-    await waitFor(() => expect(successFn1).toHaveBeenCalledTimes(1))
-    await waitFor(() => expect(successFn2).toHaveBeenCalledTimes(1))
-  })
-
   // https://github.com/tannerlinsley/react-query/issues/468
   it('should reset error state if new component instances are mounted', async () => {
     const key = queryKey()