@tanstack/solid-query 5.0.0-alpha.5 → 5.0.0-alpha.51

package/build/lib/index.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+require('./setBatchUpdatesFn.cjs');
+var queryCore = require('@tanstack/query-core');
+var QueryClient = require('./QueryClient.cjs');
+var createQuery = require('./createQuery.cjs');
+var QueryClientProvider = require('./QueryClientProvider.cjs');
+var useIsFetching = require('./useIsFetching.cjs');
+var createInfiniteQuery = require('./createInfiniteQuery.cjs');
+var createMutation = require('./createMutation.cjs');
+var useIsMutating = require('./useIsMutating.cjs');
+var createQueries = require('./createQueries.cjs');
+
+
+
+exports.QueryClient = QueryClient.QueryClient;
+exports.createQuery = createQuery.createQuery;
+exports.queryOptions = createQuery.queryOptions;
+exports.QueryClientContext = QueryClientProvider.QueryClientContext;
+exports.QueryClientProvider = QueryClientProvider.QueryClientProvider;
+exports.useQueryClient = QueryClientProvider.useQueryClient;
+exports.useIsFetching = useIsFetching.useIsFetching;
+exports.createInfiniteQuery = createInfiniteQuery.createInfiniteQuery;
+exports.createMutation = createMutation.createMutation;
+exports.useIsMutating = useIsMutating.useIsMutating;
+exports.createQueries = createQueries.createQueries;
+Object.keys(queryCore).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return queryCore[k]; }
+  });
+});
+//# sourceMappingURL=index.cjs.map

package/build/source/QueryClient.js

@@ -0,0 +1,6 @@
+import { QueryClient as QueryCoreClient } from '@tanstack/query-core';
+export class QueryClient extends QueryCoreClient {
+    constructor(config = {}) {
+        super(config);
+    }
+}

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

@@ -1,8 +1,7 @@
-import { render, screen, waitFor } from 'solid-testing-library';
-import { queryKey } from './utils';
+import { render, screen, waitFor } from '@solidjs/testing-library';
+import { createQueryClient, sleep, 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 () => {

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

@@ -1,8 +1,7 @@
-import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
-import { createQueryClient, sleep } from './utils';
-import { createEffect, createRenderEffect, createSignal, For, Index, Match, Switch, } from 'solid-js';
+import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
+import { createQueryClient, sleep, Blink, queryKey, setActTimeout, } from './utils';
+import { createEffect, createRenderEffect, createSignal, For, Index, Match, Switch, on, } from 'solid-js';
 import { createInfiniteQuery, QueryCache, QueryClientProvider, keepPreviousData, } from '..';
-import { Blink, queryKey, setActTimeout } from './utils';
 import { vi } from 'vitest';
 const pageSize = 10;
 const fetchItems = async (page, ts, noNext, noPrev) => {
@@ -154,7 +153,16 @@ describe('useInfiniteQuery', () => {
                 notifyOnChangeProps: 'all',
             }));
             createRenderEffect(() => {
-                states.push({ ...state });
+                states.push({
+                    data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
+                    hasNextPage: state.hasNextPage,
+                    hasPreviousPage: state.hasPreviousPage,
+                    isFetching: state.isFetching,
+                    isFetchingNextPage: state.isFetchingNextPage,
+                    isFetchingPreviousPage: state.isFetchingPreviousPage,
+                    isSuccess: state.isSuccess,
+                    isPlaceholderData: state.isPlaceholderData,
+                });
             });
             return (<div>
           <button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
@@ -306,9 +314,14 @@ describe('useInfiniteQuery', () => {
                 getNextPageParam: () => 1,
                 defaultPageParam: 0,
             }));
-            createRenderEffect(() => {
-                states.push({ ...state });
-            });
+            createRenderEffect(on(() => ({ ...state }), () => {
+                states.push({
+                    data: state.data
+                        ? JSON.parse(JSON.stringify(state.data))
+                        : undefined,
+                    isSuccess: state.isSuccess,
+                });
+            }));
             return (<div>
           <button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
           <div>data: {state.data?.pages.join(',') ?? 'null'}</div>
@@ -356,7 +369,15 @@ describe('useInfiniteQuery', () => {
                 notifyOnChangeProps: 'all',
             }));
             createRenderEffect(() => {
-                states.push({ ...state });
+                states.push({
+                    data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
+                    hasNextPage: state.hasNextPage,
+                    hasPreviousPage: state.hasPreviousPage,
+                    isFetching: state.isFetching,
+                    isFetchingNextPage: state.isFetchingNextPage,
+                    isFetchingPreviousPage: state.isFetchingPreviousPage,
+                    isSuccess: state.isSuccess,
+                });
             });
             createEffect(() => {
                 const fetchPreviousPage = state.fetchPreviousPage;
@@ -424,7 +445,13 @@ describe('useInfiniteQuery', () => {
                 notifyOnChangeProps: 'all',
             }));
             createRenderEffect(() => {
-                states.push({ ...state });
+                states.push({
+                    data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
+                    isFetching: state.isFetching,
+                    isFetchingNextPage: state.isFetchingNextPage,
+                    isRefetching: state.isRefetching,
+                    isFetchingPreviousPage: state.isFetchingPreviousPage,
+                });
             });
             return (<div>
           <button onClick={() => state.fetchNextPage()}>fetchNextPage</button>
@@ -524,7 +551,13 @@ describe('useInfiniteQuery', () => {
                 notifyOnChangeProps: 'all',
             }));
             createRenderEffect(() => {
-                states.push({ ...state });
+                states.push({
+                    hasNextPage: state.hasNextPage,
+                    data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
+                    isFetching: state.isFetching,
+                    isFetchingNextPage: state.isFetchingNextPage,
+                    isSuccess: state.isSuccess,
+                });
             });
             createEffect(() => {
                 const { refetch, fetchNextPage } = state;
@@ -804,7 +837,13 @@ describe('useInfiniteQuery', () => {
                 defaultPageParam: firstPage(),
             }));
             createRenderEffect(() => {
-                states.push({ ...state });
+                states.push({
+                    hasNextPage: state.hasNextPage,
+                    data: state.data ? JSON.parse(JSON.stringify(state.data)) : undefined,
+                    isFetching: state.isFetching,
+                    isFetchingNextPage: state.isFetchingNextPage,
+                    isSuccess: state.isSuccess,
+                });
             });
             createEffect(() => {
                 const { refetch } = state;
@@ -879,7 +918,13 @@ describe('useInfiniteQuery', () => {
                 notifyOnChangeProps: 'all',
             }));
             createRenderEffect(() => {
-                states.push({ ...state });
+                states.push({
+                    data: JSON.parse(JSON.stringify(state.data)),
+                    hasNextPage: state.hasNextPage,
+                    isFetching: state.isFetching,
+                    isFetchingNextPage: state.isFetchingNextPage,
+                    isSuccess: state.isSuccess,
+                });
             });
             createEffect(() => {
                 const { fetchNextPage } = state;

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

@@ -1,6 +1,6 @@
 import '@testing-library/jest-dom';
 import { createEffect, createRenderEffect, createSignal, ErrorBoundary, } from 'solid-js';
-import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
+import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
 import { createMutation, MutationCache, QueryCache, QueryClientProvider, } from '..';
 import { createQueryClient, mockNavigatorOnLine, queryKey, setActTimeout, sleep, } from './utils';
 import { vi } from 'vitest';
@@ -554,7 +554,7 @@ describe('createMutation', () => {
         fireEvent.click(screen.getByText('mutate'));
         fireEvent.click(screen.getByText('unmount'));
     });
-    it('should be able to throw an error when throwErrors is set to true', async () => {
+    it('should be able to throw an error when throwOnError is set to true', async () => {
         function Page() {
             const mutation = createMutation(() => ({
                 mutationFn: () => {
@@ -562,7 +562,7 @@ describe('createMutation', () => {
                     err.stack = '';
                     return Promise.reject(err);
                 },
-                throwErrors: true,
+                throwOnError: true,
             }));
             return (<div>
           <button onClick={() => mutation.mutate()}>mutate</button>
@@ -580,7 +580,7 @@ describe('createMutation', () => {
             expect(screen.queryByText('error')).not.toBeNull();
         });
     });
-    it('should be able to throw an error when throwErrors is a function that returns true', async () => {
+    it('should be able to throw an error when throwOnError is a function that returns true', async () => {
         let boundary = false;
         function Page() {
             const mutation = createMutation(() => ({
@@ -589,7 +589,7 @@ describe('createMutation', () => {
                     err.stack = '';
                     return Promise.reject(err);
                 },
-                throwErrors: () => {
+                throwOnError: () => {
                     boundary = !boundary;
                     return !boundary;
                 },

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

@@ -1,5 +1,5 @@
-import { fireEvent, render, screen, waitFor } from 'solid-testing-library';
-import * as QueriesObserverModule from '../../../query-core/src/queriesObserver';
+import { fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
+import * as QueryCore from '@tanstack/query-core';
 import { createRenderEffect, createSignal } from 'solid-js';
 import { createQueries, QueriesObserver, QueryCache, QueryClientProvider, } from '..';
 import { createQueryClient, expectType, expectTypeNotAny, queryKey, sleep, } from './utils';
@@ -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);
@@ -622,9 +551,9 @@ describe('useQueries', () => {
             }
         }
         const QueriesObserverSpy = vi
-            .spyOn(QueriesObserverModule, 'QueriesObserver')
+            .spyOn(QueryCore, 'QueriesObserver')
             .mockImplementation((fn) => {
-            return new QueriesObserverMock(fn);
+            return new QueriesObserverMock(fn, []);
         });
         function Queries() {
             createQueries(() => ({