@tanstack/solid-query 5.0.0-alpha.3 → 5.0.0-alpha.32

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

@@ -3,6 +3,7 @@ import * as QueriesObserverModule from '../../../query-core/src/queriesObserver'
 import { createRenderEffect, createSignal } from 'solid-js';
 import { createQueries, QueriesObserver, QueryCache, QueryClientProvider, } from '..';
 import { createQueryClient, expectType, expectTypeNotAny, queryKey, sleep, } from './utils';
+import { vi } from 'vitest';
 describe('useQueries', () => {
     const queryCache = new QueryCache();
     const queryClient = createQueryClient({ queryCache });
@@ -116,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,
@@ -132,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,
@@ -252,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,
@@ -268,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,
@@ -362,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(() => ({
@@ -422,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
@@ -431,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);
-                        },
                     },
                 ],
             }));
@@ -469,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,
                     },
                 ],
             }));
@@ -554,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);
@@ -620,7 +550,7 @@ describe('useQueries', () => {
                 return () => void 0;
             }
         }
-        const QueriesObserverSpy = jest
+        const QueriesObserverSpy = vi
             .spyOn(QueriesObserverModule, 'QueriesObserver')
             .mockImplementation((fn) => {
             return new QueriesObserverMock(fn);
@@ -657,21 +587,4 @@ describe('useQueries', () => {
         await sleep(20);
         QueriesObserverSpy.mockRestore();
     });
-    it('should use provided custom queryClient', async () => {
-        const key = queryKey();
-        const queryFn = () => {
-            return Promise.resolve('custom client');
-        };
-        function Page() {
-            const state = createQueries(() => ({
-                queries: [{ queryKey: key, queryFn }],
-                queryClient,
-            }));
-            return (<div>
-          <h1>Status: {state[0].data}</h1>
-        </div>);
-        }
-        render(() => <Page />);
-        await waitFor(() => screen.getByText('Status: custom client'));
-    });
 });