@tanstack/solid-query 5.0.0-alpha.15 → 5.0.0-alpha.18

package/src/createBaseQuery.ts

@@ -64,8 +64,9 @@ export function createBaseQuery<
     return observer.subscribe((result) => {
       notifyManager.batchCalls(() => {
         const query = observer.getCurrentQuery()
+        const { refetch, ...rest } = unwrap(result)
         const unwrappedResult = {
-          ...unwrap(result),
+          ...rest,
 
           // hydrate() expects a QueryState object, which is similar but not
           // quite the same as a QueryObserverResult object. Thus, for now, we're
@@ -84,7 +85,9 @@ export function createBaseQuery<
           reject(unwrappedResult.error)
         }
         if (unwrappedResult.isSuccess) {
-          resolve(unwrappedResult)
+          // Use of any here is fine
+          // We cannot include refetch since it is not serializable
+          resolve(unwrappedResult as any)
         }
       })()
     })

package/build/source/QueryClientProvider.jsx

@@ -1,21 +0,0 @@
-import { createContext, useContext, onMount, onCleanup } from 'solid-js';
-export const QueryClientContext = createContext(undefined);
-export const useQueryClient = (queryClient) => {
-    const client = useContext(QueryClientContext);
-    if (queryClient) {
-        return queryClient;
-    }
-    if (!client) {
-        throw new Error('No QueryClient set, use QueryClientProvider to set one');
-    }
-    return client;
-};
-export const QueryClientProvider = (props) => {
-    onMount(() => {
-        props.client.mount();
-    });
-    onCleanup(() => props.client.unmount());
-    return (<QueryClientContext.Provider value={props.client}>
-      {props.children}
-    </QueryClientContext.Provider>);
-};

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

@@ -1,121 +0,0 @@
-import { render, screen, waitFor } from 'solid-testing-library';
-import { queryKey } from './utils';
-import { QueryCache } from '@tanstack/query-core';
-import { createQuery, QueryClientProvider, useQueryClient } from '..';
-import { createQueryClient, sleep } from './utils';
-import { vi } from 'vitest';
-describe('QueryClientProvider', () => {
-    it('sets a specific cache for all queries to use', async () => {
-        const key = queryKey();
-        const queryCache = new QueryCache();
-        const queryClient = createQueryClient({ queryCache });
-        function Page() {
-            const query = createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'test';
-                },
-            }));
-            return (<div>
-          <h1>{query.data}</h1>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await waitFor(() => {
-            return screen.getByText('test');
-        });
-        expect(queryCache.find({ queryKey: key })).toBeDefined();
-    });
-    it('allows multiple caches to be partitioned', async () => {
-        const key1 = queryKey();
-        const key2 = queryKey();
-        const queryCache1 = new QueryCache();
-        const queryCache2 = new QueryCache();
-        const queryClient1 = createQueryClient({ queryCache: queryCache1 });
-        const queryClient2 = createQueryClient({ queryCache: queryCache2 });
-        function Page1() {
-            const query = createQuery(() => ({
-                queryKey: key1,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'test1';
-                },
-            }));
-            return (<div>
-          <h1>{query.data}</h1>
-        </div>);
-        }
-        function Page2() {
-            const query = createQuery(() => ({
-                queryKey: key2,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'test2';
-                },
-            }));
-            return (<div>
-          <h1>{query.data}</h1>
-        </div>);
-        }
-        render(() => (<>
-        <QueryClientProvider client={queryClient1}>
-          <Page1 />
-        </QueryClientProvider>
-        <QueryClientProvider client={queryClient2}>
-          <Page2 />
-        </QueryClientProvider>
-      </>));
-        await waitFor(() => screen.getByText('test1'));
-        await waitFor(() => screen.getByText('test2'));
-        expect(queryCache1.find({ queryKey: key1 })).toBeDefined();
-        expect(queryCache1.find({ queryKey: key2 })).not.toBeDefined();
-        expect(queryCache2.find({ queryKey: key1 })).not.toBeDefined();
-        expect(queryCache2.find({ queryKey: key2 })).toBeDefined();
-    });
-    it("uses defaultOptions for queries when they don't provide their own config", async () => {
-        const key = queryKey();
-        const queryCache = new QueryCache();
-        const queryClient = createQueryClient({
-            queryCache,
-            defaultOptions: {
-                queries: {
-                    gcTime: Infinity,
-                },
-            },
-        });
-        function Page() {
-            const query = createQuery(() => ({
-                queryKey: key,
-                queryFn: async () => {
-                    await sleep(10);
-                    return 'test';
-                },
-            }));
-            return (<div>
-          <h1>{query.data}</h1>
-        </div>);
-        }
-        render(() => (<QueryClientProvider client={queryClient}>
-        <Page />
-      </QueryClientProvider>));
-        await waitFor(() => screen.getByText('test'));
-        expect(queryCache.find({ queryKey: key })).toBeDefined();
-        expect(queryCache.find({ queryKey: key })?.options.gcTime).toBe(Infinity);
-    });
-    describe('useQueryClient', () => {
-        it('should throw an error if no query client has been set', () => {
-            const consoleMock = vi
-                .spyOn(console, 'error')
-                .mockImplementation(() => undefined);
-            function Page() {
-                useQueryClient();
-                return null;
-            }
-            expect(() => render(() => <Page />)).toThrow('No QueryClient set, use QueryClientProvider to set one');
-            consoleMock.mockRestore();
-        });
-    });
-});