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

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

@@ -3,6 +3,8 @@ import { createEffect, createMemo, createRenderEffect, createSignal, ErrorBounda
 import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
 import { createQuery, QueryCache, QueryClientProvider, keepPreviousData, } from '..';
 import { Blink, createQueryClient, expectType, mockNavigatorOnLine, mockVisibilityState, queryKey, setActTimeout, sleep, } from './utils';
+import { vi } from 'vitest';
+import { reconcile } from 'solid-js/store';
 describe('createQuery', () => {
     const queryCache = new QueryCache();
     const queryClient = createQueryClient({ queryCache });
@@ -361,7 +363,7 @@ describe('createQuery', () => {
     it('should call onSuccess after a query has been fetched', async () => {
         const key = queryKey();
         const states = [];
-        const onSuccess = jest.fn();
+        const onSuccess = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -387,7 +389,7 @@ describe('createQuery', () => {
     it('should call onSuccess after a disabled query has been fetched', async () => {
         const key = queryKey();
         const states = [];
-        const onSuccess = jest.fn();
+        const onSuccess = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -416,7 +418,7 @@ describe('createQuery', () => {
     it('should not call onSuccess if a component has unmounted', async () => {
         const key = queryKey();
         const states = [];
-        const onSuccess = jest.fn();
+        const onSuccess = vi.fn();
         function Page() {
             const [show, setShow] = createSignal(true);
             createEffect(() => {
@@ -448,7 +450,7 @@ describe('createQuery', () => {
     it('should call onError after a query has been fetched with an error', async () => {
         const key = queryKey();
         const states = [];
-        const onError = jest.fn();
+        const onError = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -471,7 +473,7 @@ describe('createQuery', () => {
     });
     it('should not call onError when receiving a CancelledError', async () => {
         const key = queryKey();
-        const onError = jest.fn();
+        const onError = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -497,7 +499,7 @@ describe('createQuery', () => {
     it('should call onSettled after a query has been fetched', async () => {
         const key = queryKey();
         const states = [];
-        const onSettled = jest.fn();
+        const onSettled = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -520,7 +522,7 @@ describe('createQuery', () => {
     it('should call onSettled after a query has been fetched with an error', async () => {
         const key = queryKey();
         const states = [];
-        const onSettled = jest.fn();
+        const onSettled = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,
@@ -964,7 +966,6 @@ describe('createQuery', () => {
                     count++;
                     return count === 1 ? result1 : result2;
                 },
-                notifyOnChangeProps: 'all',
             }));
             createRenderEffect(() => {
                 states.push({ ...state });
@@ -991,9 +992,8 @@ describe('createQuery', () => {
         const newTodo2 = newTodos?.[1];
         expect(todos).toEqual(result1);
         expect(newTodos).toEqual(result2);
-        expect(newTodos).not.toBe(todos);
         expect(newTodo1).toBe(todo1);
-        expect(newTodo2).not.toBe(todo2);
+        expect(newTodo2).toBe(todo2);
         return null;
     });
     it('should use query function from hook when the existing query does not have a query function', async () => {
@@ -1887,7 +1887,7 @@ describe('createQuery', () => {
     });
     it('should not refetch query on focus when `enabled` is set to `false`', async () => {
         const key = queryKey();
-        const queryFn = jest.fn().mockReturnValue('data');
+        const queryFn = vi.fn().mockReturnValue('data');
         function Page() {
             const { data = 'default' } = createQuery(() => ({
                 queryKey: key,
@@ -2500,6 +2500,7 @@ describe('createQuery', () => {
                 queryFn: () => ({ count: 10 }),
                 staleTime: Infinity,
                 initialData: () => ({ count: count() }),
+                reconcile: false,
             }));
             createRenderEffect(() => {
                 states.push({ ...state });
@@ -2523,7 +2524,7 @@ describe('createQuery', () => {
     });
     it('should retry specified number of times', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => {
             return Promise.reject(new Error('Error test Barrett'));
         });
@@ -2552,7 +2553,7 @@ describe('createQuery', () => {
     });
     it('should not retry if retry function `false`', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementationOnce(() => {
             return Promise.reject(new Error('Error test Tanner'));
         });
@@ -2585,7 +2586,7 @@ describe('createQuery', () => {
     });
     it('should extract retryDelay from error', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => {
             return Promise.reject({ delay: 50 });
         });
@@ -2747,9 +2748,9 @@ describe('createQuery', () => {
     it('should refetch if stale after a prefetch', async () => {
         const key = queryKey();
         const states = [];
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => 'data');
-        const prefetchQueryFn = jest.fn();
+        const prefetchQueryFn = vi.fn();
         prefetchQueryFn.mockImplementation(() => 'not yet...');
         await queryClient.prefetchQuery({
             queryKey: key,
@@ -2773,9 +2774,9 @@ describe('createQuery', () => {
     });
     it('should not refetch if not stale after a prefetch', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => 'data');
-        const prefetchQueryFn = jest.fn();
+        const prefetchQueryFn = vi.fn();
         prefetchQueryFn.mockImplementation(async () => {
             await sleep(10);
             return 'not yet...';
@@ -2977,7 +2978,7 @@ describe('createQuery', () => {
     });
     it('it should support enabled:false in query object syntax', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => 'data');
         function Page() {
             const { fetchStatus } = createQuery(() => ({
@@ -3028,7 +3029,7 @@ describe('createQuery', () => {
         <Page />
       </QueryClientProvider>));
         await waitFor(() => screen.getByText('fetched data'));
-        const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
+        const setTimeoutSpy = vi.spyOn(window, 'setTimeout');
         result.unmount();
         expect(setTimeoutSpy).not.toHaveBeenCalled();
     });
@@ -3046,14 +3047,14 @@ describe('createQuery', () => {
         <Page />
       </QueryClientProvider>));
         await waitFor(() => screen.getByText('fetched data'));
-        const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
+        const setTimeoutSpy = vi.spyOn(window, 'setTimeout');
         result.unmount();
         expect(setTimeoutSpy).toHaveBeenLastCalledWith(expect.any(Function), 1000 * 60 * 10);
     });
     it('should not cause memo churn when data does not change', async () => {
         const key = queryKey();
-        const queryFn = jest.fn().mockReturnValue('data');
-        const memoFn = jest.fn();
+        const queryFn = vi.fn().mockReturnValue('data');
+        const memoFn = vi.fn();
         function Page() {
             const result = createQuery(() => ({
                 queryKey: key,
@@ -3234,7 +3235,7 @@ describe('createQuery', () => {
     });
     it('should refetch if any query instance becomes enabled', async () => {
         const key = queryKey();
-        const queryFn = jest.fn().mockReturnValue('data');
+        const queryFn = vi.fn().mockReturnValue('data');
         function Disabled() {
             createQuery(() => ({ queryKey: key, queryFn, enabled: false }));
             return null;
@@ -3502,12 +3503,53 @@ describe('createQuery', () => {
         // effect should not be triggered again due to structural sharing
         expect(states).toHaveLength(1);
     });
+    it('The reconcile fn callback should correctly maintain referential equality', async () => {
+        const key1 = queryKey();
+        const states = [];
+        function Page() {
+            const [forceValue, setForceValue] = createSignal(1);
+            const state = createQuery(() => ({
+                queryKey: key1,
+                queryFn: async () => {
+                    await sleep(10);
+                    return [1, 2];
+                },
+                select: (res) => res.map((x) => x + 1),
+                reconcile(oldData, newData) {
+                    return reconcile(newData)(oldData);
+                },
+            }));
+            createEffect(() => {
+                if (state.data) {
+                    states.push(state.data);
+                }
+            });
+            const forceUpdate = () => {
+                setForceValue((prev) => prev + 1);
+            };
+            return (<div>
+          <h2>Data: {JSON.stringify(state.data)}</h2>
+          <h2>forceValue: {forceValue}</h2>
+          <button onClick={forceUpdate}>forceUpdate</button>
+        </div>);
+        }
+        render(() => (<QueryClientProvider client={queryClient}>
+        <Page />
+      </QueryClientProvider>));
+        await waitFor(() => screen.getByText('Data: [2,3]'));
+        expect(states).toHaveLength(1);
+        fireEvent.click(screen.getByRole('button', { name: /forceUpdate/i }));
+        await waitFor(() => screen.getByText('forceValue: 2'));
+        await waitFor(() => screen.getByText('Data: [2,3]'));
+        // effect should not be triggered again due to structural sharing
+        expect(states).toHaveLength(1);
+    });
     it('should cancel the query function when there are no more subscriptions', async () => {
         const key = queryKey();
-        let cancelFn = jest.fn();
+        let cancelFn = vi.fn();
         const queryFn = ({ signal }) => {
             const promise = new Promise((resolve, reject) => {
-                cancelFn = jest.fn(() => reject('Cancelled'));
+                cancelFn = vi.fn(() => reject('Cancelled'));
                 signal?.addEventListener('abort', cancelFn);
                 sleep(20).then(() => resolve('OK'));
             });
@@ -3767,7 +3809,7 @@ describe('createQuery', () => {
         expect(renders).toBe(hashes);
     });
     it('should refetch when changed enabled to true in error state', async () => {
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(async () => {
             await sleep(10);
             return Promise.reject(new Error('Suspense Error Bingo'));
@@ -4514,7 +4556,7 @@ describe('createQuery', () => {
     });
     it('setQueryData - should not call onSuccess callback of active observers', async () => {
         const key = queryKey();
-        const onSuccess = jest.fn();
+        const onSuccess = vi.fn();
         function Page() {
             const state = createQuery(() => ({
                 queryKey: key,

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

@@ -2,6 +2,7 @@ import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
 import { createRenderEffect, createSignal, ErrorBoundary, on, Show, Suspense, } from 'solid-js';
 import { createInfiniteQuery, createQuery, QueryCache, QueryClientProvider, } from '..';
 import { createQueryClient, queryKey, sleep } from './utils';
+import { vi } from 'vitest';
 describe("useQuery's in Suspense mode", () => {
     const queryCache = new QueryCache();
     const queryClient = createQueryClient({ queryCache });
@@ -91,7 +92,7 @@ describe("useQuery's in Suspense mode", () => {
     });
     it('should not call the queryFn twice when used in Suspense mode', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(() => {
             sleep(10);
             return 'data';
@@ -141,7 +142,7 @@ describe("useQuery's in Suspense mode", () => {
     });
     it('should call onSuccess on the first successful call', async () => {
         const key = queryKey();
-        const successFn = jest.fn();
+        const successFn = vi.fn();
         function Page() {
             createQuery(() => ({
                 queryKey: [key],
@@ -166,8 +167,8 @@ describe("useQuery's in Suspense mode", () => {
     });
     it('should call every onSuccess handler within a suspense boundary', async () => {
         const key = queryKey();
-        const successFn1 = jest.fn();
-        const successFn2 = jest.fn();
+        const successFn1 = vi.fn();
+        const successFn2 = vi.fn();
         function FirstComponent() {
             createQuery(() => ({
                 queryKey: key,
@@ -514,7 +515,7 @@ describe("useQuery's in Suspense mode", () => {
     });
     it('should not call the queryFn when not enabled', async () => {
         const key = queryKey();
-        const queryFn = jest.fn();
+        const queryFn = vi.fn();
         queryFn.mockImplementation(async () => {
             await sleep(10);
             return '23';

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

@@ -120,9 +120,7 @@ describe('useIsFetching', () => {
         function Page() {
             const [started, setStarted] = createSignal(false);
             const isFetching = useIsFetching(() => ({
-                filters: {
-                    queryKey: key1,
-                },
+                queryKey: key1,
             }));
             createRenderEffect(() => {
                 isFetchings.push(isFetching());
@@ -181,7 +179,7 @@ describe('useIsFetching', () => {
                     return 'test';
                 },
             }), () => queryClient);
-            const isFetching = useIsFetching(() => ({ queryClient }));
+            const isFetching = useIsFetching(undefined, () => queryClient);
             return (<div>
           <div>isFetching: {isFetching}</div>
         </div>);

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

@@ -5,6 +5,7 @@ import { createEffect, createRenderEffect, createSignal, Show } from 'solid-js';
 import { render } from 'solid-testing-library';
 import * as MutationCacheModule from '../../../query-core/src/mutationCache';
 import { setActTimeout } from './utils';
+import { vi } from 'vitest';
 describe('useIsMutating', () => {
     it('should return the number of fetching mutations', async () => {
         const isMutatings = [];
@@ -54,9 +55,7 @@ describe('useIsMutating', () => {
         const isMutatings = [];
         const queryClient = createQueryClient();
         function IsMutating() {
-            const isMutating = useIsMutating(() => ({
-                filters: { mutationKey: ['mutation1'] },
-            }));
+            const isMutating = useIsMutating(() => ({ mutationKey: ['mutation1'] }));
             createRenderEffect(() => {
                 isMutatings.push(isMutating());
             });
@@ -94,9 +93,7 @@ describe('useIsMutating', () => {
         const queryClient = createQueryClient();
         function IsMutating() {
             const isMutating = useIsMutating(() => ({
-                filters: {
-                    predicate: (mutation) => mutation.options.mutationKey?.[0] === 'mutation1',
-                },
+                predicate: (mutation) => mutation.options.mutationKey?.[0] === 'mutation1',
             }));
             createRenderEffect(() => {
                 isMutatings.push(isMutating());
@@ -130,6 +127,27 @@ describe('useIsMutating', () => {
         // Again, No unnecessary re-renders like React
         await waitFor(() => expect(isMutatings).toEqual([0, 1, 0]));
     });
+    it('should use provided custom queryClient', async () => {
+        const queryClient = createQueryClient();
+        function Page() {
+            const isMutating = useIsMutating(undefined, () => queryClient);
+            const { mutate } = createMutation(() => ({
+                mutationKey: ['mutation1'],
+                mutationFn: async () => {
+                    await sleep(10);
+                    return 'data';
+                },
+            }), () => queryClient);
+            createEffect(() => {
+                mutate();
+            });
+            return (<div>
+          <div>mutating: {isMutating}</div>
+        </div>);
+        }
+        render(() => <Page></Page>);
+        await waitFor(() => screen.findByText('mutating: 1'));
+    });
     it('should not change state if unmounted', async () => {
         // We have to mock the MutationCache to not unsubscribe
         // the listener when the component is unmounted
@@ -139,7 +157,7 @@ describe('useIsMutating', () => {
                 return () => void 0;
             }
         }
-        const MutationCacheSpy = jest
+        const MutationCacheSpy = vi
             .spyOn(MutationCacheModule, 'MutationCache')
             .mockImplementation((fn) => {
             return new MutationCacheMock(fn);
@@ -177,25 +195,4 @@ describe('useIsMutating', () => {
         await sleep(20);
         MutationCacheSpy.mockRestore();
     });
-    it('should use provided custom queryClient', async () => {
-        const queryClient = createQueryClient();
-        function Page() {
-            const isMutating = useIsMutating(() => ({ queryClient }));
-            const { mutate } = createMutation(() => ({
-                mutationKey: ['mutation1'],
-                mutationFn: async () => {
-                    await sleep(10);
-                    return 'data';
-                },
-            }), () => queryClient);
-            createEffect(() => {
-                mutate();
-            });
-            return (<div>
-          <div>mutating: {isMutating}</div>
-        </div>);
-        }
-        render(() => <Page></Page>);
-        await waitFor(() => screen.findByText('mutating: 1'));
-    });
 });

package/build/source/__tests__/utils.jsx

@@ -1,5 +1,6 @@
-import { QueryClient } from '@tanstack/query-core';
+import { QueryClient } from '../QueryClient';
 import { createEffect, createSignal, onCleanup, Show } from 'solid-js';
+import { vi } from 'vitest';
 let queryKeyCount = 0;
 export function queryKey() {
     queryKeyCount++;
@@ -20,10 +21,10 @@ export function createQueryClient(config) {
     return new QueryClient(config);
 }
 export function mockVisibilityState(value) {
-    return jest.spyOn(document, 'visibilityState', 'get').mockReturnValue(value);
+    return vi.spyOn(document, 'visibilityState', 'get').mockReturnValue(value);
 }
 export function mockNavigatorOnLine(value) {
-    return jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(value);
+    return vi.spyOn(navigator, 'onLine', 'get').mockReturnValue(value);
 }
 export function sleep(timeout) {
     return new Promise((resolve, _reject) => {

package/build/source/createBaseQuery.js

@@ -1,15 +1,26 @@
 import { hydrate } from '@tanstack/query-core';
 import { notifyManager } from '@tanstack/query-core';
 import { isServer } from 'solid-js/web';
-import { createComputed, createMemo, createResource, on, onCleanup, onMount, } from 'solid-js';
-import { createStore, unwrap } from 'solid-js/store';
+import { createComputed, createMemo, createResource, on, onCleanup, } from 'solid-js';
+import { createStore, reconcile, unwrap } from 'solid-js/store';
 import { useQueryClient } from './QueryClientProvider';
 import { shouldThrowError } from './utils';
+function reconcileFn(store, result, reconcileOption) {
+    if (reconcileOption === false)
+        return result;
+    if (typeof reconcileOption === 'function') {
+        const newData = reconcileOption(store.data, result.data);
+        return { ...result, data: newData };
+    }
+    const newData = reconcile(result.data, { key: reconcileOption })(store.data);
+    return { ...result, data: newData };
+}
 // Base Query Function that is used to create the query.
 export function createBaseQuery(options, Observer, queryClient) {
     const client = createMemo(() => useQueryClient(queryClient?.()));
     const defaultedOptions = client().defaultQueryOptions(options());
     defaultedOptions._optimisticResults = 'optimistic';
+    defaultedOptions.structuralSharing = false;
     if (isServer) {
         defaultedOptions.retry = false;
         defaultedOptions.throwErrors = true;
@@ -19,7 +30,19 @@ export function createBaseQuery(options, Observer, queryClient) {
     const createServerSubscriber = (resolve, reject) => {
         return observer.subscribe((result) => {
             notifyManager.batchCalls(() => {
-                const unwrappedResult = { ...unwrap(result) };
+                const query = observer.getCurrentQuery();
+                const { refetch, ...rest } = unwrap(result);
+                const unwrappedResult = {
+                    ...rest,
+                    // hydrate() expects a QueryState object, which is similar but not
+                    // quite the same as a QueryObserverResult object. Thus, for now, we're
+                    // copying over the missing properties from state in order to support hydration
+                    dataUpdateCount: query.state.dataUpdateCount,
+                    fetchFailureCount: query.state.fetchFailureCount,
+                    fetchFailureReason: query.state.fetchFailureReason,
+                    fetchMeta: query.state.fetchMeta,
+                    isInvalidated: query.state.isInvalidated,
+                };
                 if (unwrappedResult.isError) {
                     if (process.env['NODE_ENV'] === 'development') {
                         console.error(unwrappedResult.error);
@@ -27,6 +50,8 @@ export function createBaseQuery(options, Observer, queryClient) {
                     reject(unwrappedResult.error);
                 }
                 if (unwrappedResult.isSuccess) {
+                    // Use of any here is fine
+                    // We cannot include refetch since it is not serializable
                     resolve(unwrappedResult);
                 }
             })();
@@ -35,17 +60,21 @@ export function createBaseQuery(options, Observer, queryClient) {
     const createClientSubscriber = () => {
         return observer.subscribe((result) => {
             notifyManager.batchCalls(() => {
-                const unwrappedResult = { ...unwrap(result) };
+                // @ts-expect-error - This will error because the reconcile option does not
+                // exist on the query-core QueryObserverResult type
+                const reconcileOptions = observer.options.reconcile;
                 // If the query has data we dont suspend but instead mutate the resource
                 // This could happen when placeholderData/initialData is defined
-                if (queryResource()?.data &&
-                    unwrappedResult.data &&
-                    !queryResource.loading) {
-                    setState(unwrappedResult);
+                if (queryResource()?.data && result.data && !queryResource.loading) {
+                    setState((store) => {
+                        return reconcileFn(store, result, reconcileOptions === undefined ? 'id' : reconcileOptions);
+                    });
                     mutate(state);
                 }
                 else {
-                    setState(unwrappedResult);
+                    setState((store) => {
+                        return reconcileFn(store, result, reconcileOptions === undefined ? 'id' : reconcileOptions);
+                    });
                     refetch();
                 }
             })();
@@ -119,12 +148,11 @@ export function createBaseQuery(options, Observer, queryClient) {
             unsubscribe = null;
         }
     });
-    onMount(() => {
-        observer.setOptions(defaultedOptions, { listeners: false });
-    });
-    createComputed(() => {
-        observer.setOptions(client().defaultQueryOptions(options()));
-    });
+    createComputed(on(() => client().defaultQueryOptions(options()), () => observer.setOptions(client().defaultQueryOptions(options())), {
+        // Defer because we don't need to trigger on first render
+        // This only cares about changes to options after the observer is created
+        defer: true,
+    }));
     createComputed(on(() => state.status, () => {
         if (state.isError &&
             !state.isFetching &&
@@ -137,10 +165,8 @@ export function createBaseQuery(options, Observer, queryClient) {
     }));
     const handler = {
         get(target, prop) {
-            if (prop === 'data') {
-                return queryResource()?.data;
-            }
-            return Reflect.get(target, prop);
+            const val = queryResource()?.[prop];
+            return val !== undefined ? val : Reflect.get(target, prop);
         },
     };
     return new Proxy(state, handler);

package/build/source/createQueries.js

@@ -2,14 +2,14 @@ import { notifyManager, QueriesObserver } from '@tanstack/query-core';
 import { createComputed, onCleanup, onMount } from 'solid-js';
 import { createStore, unwrap } from 'solid-js/store';
 import { useQueryClient } from './QueryClientProvider';
-export function createQueries(queriesOptions) {
-    const queryClient = useQueryClient(queriesOptions().queryClient);
+export function createQueries(queriesOptions, queryClient) {
+    const client = useQueryClient(queryClient?.());
     const defaultedQueries = queriesOptions().queries.map((options) => {
-        const defaultedOptions = queryClient.defaultQueryOptions(options);
+        const defaultedOptions = client.defaultQueryOptions(options);
         defaultedOptions._optimisticResults = 'optimistic';
         return defaultedOptions;
     });
-    const observer = new QueriesObserver(queryClient, defaultedQueries);
+    const observer = new QueriesObserver(client, defaultedQueries);
     const [state, setState] = createStore(observer.getOptimisticResult(defaultedQueries));
     const unsubscribe = observer.subscribe((result) => {
         notifyManager.batchCalls(() => {
@@ -22,7 +22,7 @@ export function createQueries(queriesOptions) {
     });
     createComputed(() => {
         const updatedQueries = queriesOptions().queries.map((options) => {
-            const defaultedOptions = queryClient.defaultQueryOptions(options);
+            const defaultedOptions = client.defaultQueryOptions(options);
             defaultedOptions._optimisticResults = 'optimistic';
             return defaultedOptions;
         });

package/build/source/index.js

@@ -5,6 +5,7 @@ import './setBatchUpdatesFn';
 export * from '@tanstack/query-core';
 // Solid Query
 export * from './types';
+export { QueryClient } from './QueryClient';
 export { createQuery } from './createQuery';
 export { QueryClientContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
 export { useIsFetching } from './useIsFetching';

package/build/source/useIsFetching.js

@@ -1,11 +1,11 @@
 import { createMemo, createSignal, onCleanup } from 'solid-js';
 import { useQueryClient } from './QueryClientProvider';
-export function useIsFetching(options = () => ({})) {
-    const queryClient = createMemo(() => useQueryClient(options().queryClient));
-    const queryCache = createMemo(() => queryClient().getQueryCache());
-    const [fetches, setFetches] = createSignal(queryClient().isFetching(options().filters));
+export function useIsFetching(filters, queryClient) {
+    const client = createMemo(() => useQueryClient(queryClient?.()));
+    const queryCache = createMemo(() => client().getQueryCache());
+    const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
     const unsubscribe = queryCache().subscribe(() => {
-        setFetches(queryClient().isFetching(options().filters));
+        setFetches(client().isFetching(filters?.()));
     });
     onCleanup(unsubscribe);
     return fetches;

package/build/source/useIsMutating.js

@@ -1,11 +1,11 @@
 import { useQueryClient } from './QueryClientProvider';
 import { createSignal, onCleanup, createMemo } from 'solid-js';
-export function useIsMutating(options = () => ({})) {
-    const queryClient = createMemo(() => useQueryClient(options().queryClient));
-    const mutationCache = createMemo(() => queryClient().getMutationCache());
-    const [mutations, setMutations] = createSignal(queryClient().isMutating(options().filters));
+export function useIsMutating(filters, queryClient) {
+    const client = createMemo(() => useQueryClient(queryClient?.()));
+    const mutationCache = createMemo(() => client().getMutationCache());
+    const [mutations, setMutations] = createSignal(client().isMutating(filters?.()));
     const unsubscribe = mutationCache().subscribe((_result) => {
-        setMutations(queryClient().isMutating(options().filters));
+        setMutations(client().isMutating(filters?.()));
     });
     onCleanup(unsubscribe);
     return mutations;