@tanstack/react-query 5.0.0-alpha.3 → 5.0.0-alpha.31

package/build/umd/index.development.js

@@ -926,7 +926,7 @@
             {
               console.error(`Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`);
             }
-            onError(new Error('undefined'));
+            onError(new Error(`${this.queryHash} data is undefined`));
             return;
           }
           this.setData(data);
@@ -1043,7 +1043,7 @@
       this.state = reducer(this.state);
       notifyManager.batch(() => {
         this.#observers.forEach(observer => {
-          observer.onQueryUpdate(action);
+          observer.onQueryUpdate();
         });
         this.#cache.notify({
           query: this,
@@ -1080,7 +1080,7 @@
     constructor(config = {}) {
       super();
       this.config = config;
-      this.#queries = config.createStore?.() ?? new Map();
+      this.#queries = new Map();
     }
     build(client, options, state) {
       const queryKey = options.queryKey;
@@ -1135,10 +1135,11 @@
       return [...this.#queries.values()];
     }
     find(filters) {
-      if (typeof filters.exact === 'undefined') {
-        filters.exact = true;
-      }
-      return this.getAll().find(query => matchQuery(filters, query));
+      const defaultedFilters = {
+        exact: true,
+        ...filters
+      };
+      return this.getAll().find(query => matchQuery(defaultedFilters, query));
     }
     findAll(filters = {}) {
       const queries = this.getAll();
@@ -1444,10 +1445,11 @@
       return this.#mutations;
     }
     find(filters) {
-      if (typeof filters.exact === 'undefined') {
-        filters.exact = true;
-      }
-      return this.#mutations.find(mutation => matchMutation(filters, mutation));
+      const defaultedFilters = {
+        exact: true,
+        ...filters
+      };
+      return this.#mutations.find(mutation => matchMutation(defaultedFilters, mutation));
     }
     findAll(filters = {}) {
       return this.#mutations.filter(mutation => matchMutation(filters, mutation));
@@ -1473,12 +1475,15 @@
   function infiniteQueryBehavior() {
     return {
       onFetch: context => {
-        context.fetchFn = () => {
+        context.fetchFn = async () => {
           const options = context.options;
           const direction = context.fetchOptions?.meta?.fetchMore?.direction;
           const oldPages = context.state.data?.pages || [];
           const oldPageParams = context.state.data?.pageParams || [];
-          let newPageParams = oldPageParams;
+          const empty = {
+            pages: [],
+            pageParams: []
+          };
           let cancelled = false;
           const addSignalProperty = object => {
             Object.defineProperty(object, 'signal', {
@@ -1498,95 +1503,95 @@
 
           // Get query function
           const queryFn = context.options.queryFn || (() => Promise.reject(new Error('Missing queryFn')));
-          const buildNewPages = (pages, param, page, previous) => {
-            const {
-              maxPages
-            } = context.options;
-            if (previous) {
-              newPageParams = addToStart(newPageParams, param, maxPages);
-              return addToStart(pages, page, maxPages);
-            }
-            newPageParams = addToEnd(newPageParams, param, maxPages);
-            return addToEnd(pages, page, maxPages);
-          };
 
           // Create function to fetch a page
-          const fetchPage = (pages, param, previous) => {
+          const fetchPage = async (data, param, previous) => {
             if (cancelled) {
               return Promise.reject();
             }
-            if (typeof param === 'undefined' && pages.length) {
-              return Promise.resolve(pages);
+            if (typeof param === 'undefined' && data.pages.length) {
+              return Promise.resolve(data);
             }
             const queryFnContext = {
               queryKey: context.queryKey,
               pageParam: param,
+              direction: previous ? 'backward' : 'forward',
               meta: context.options.meta
             };
             addSignalProperty(queryFnContext);
-            const queryFnResult = queryFn(queryFnContext);
-            const promise = Promise.resolve(queryFnResult).then(page => buildNewPages(pages, param, page, previous));
-            return promise;
+            const page = await queryFn(queryFnContext);
+            const {
+              maxPages
+            } = context.options;
+            const addTo = previous ? addToStart : addToEnd;
+            return {
+              pages: addTo(data.pages, page, maxPages),
+              pageParams: addTo(data.pageParams, param, maxPages)
+            };
           };
-          let promise;
+          let result;
 
           // Fetch first page?
           if (!oldPages.length) {
-            promise = fetchPage([], options.defaultPageParam);
+            result = await fetchPage(empty, options.defaultPageParam);
           }
 
           // fetch next / previous page?
           else if (direction) {
             const previous = direction === 'backward';
-            const param = previous ? getPreviousPageParam(options, oldPages) : getNextPageParam(options, oldPages);
-            promise = fetchPage(oldPages, param, previous);
+            const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+            const oldData = {
+              pages: oldPages,
+              pageParams: oldPageParams
+            };
+            const param = pageParamFn(options, oldData);
+            result = await fetchPage(oldData, param, previous);
           }
 
           // Refetch pages
           else {
-            newPageParams = [];
-
             // Fetch first page
-            promise = fetchPage([], oldPageParams[0]);
+            result = await fetchPage(empty, oldPageParams[0]);
 
             // Fetch remaining pages
             for (let i = 1; i < oldPages.length; i++) {
-              promise = promise.then(pages => {
-                const param = getNextPageParam(options, pages);
-                return fetchPage(pages, param);
-              });
+              const param = getNextPageParam(options, result);
+              result = await fetchPage(result, param);
             }
           }
-          const finalPromise = promise.then(pages => ({
-            pages,
-            pageParams: newPageParams
-          }));
-          return finalPromise;
+          return result;
         };
       }
     };
   }
-  function getNextPageParam(options, pages) {
-    return options.getNextPageParam(pages[pages.length - 1], pages);
+  function getNextPageParam(options, {
+    pages,
+    pageParams
+  }) {
+    const lastIndex = pages.length - 1;
+    return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams);
   }
-  function getPreviousPageParam(options, pages) {
-    return options.getPreviousPageParam?.(pages[0], pages);
+  function getPreviousPageParam(options, {
+    pages,
+    pageParams
+  }) {
+    return options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams);
   }
 
   /**
    * Checks if there is a next page.
    */
-  function hasNextPage(options, pages) {
-    if (!pages) return false;
-    return typeof getNextPageParam(options, pages) !== 'undefined';
+  function hasNextPage(options, data) {
+    if (!data) return false;
+    return typeof getNextPageParam(options, data) !== 'undefined';
   }
 
   /**
    * Checks if there is a previous page.
    */
-  function hasPreviousPage(options, pages) {
-    if (!pages || !options.getPreviousPageParam) return false;
-    return typeof getPreviousPageParam(options, pages) !== 'undefined';
+  function hasPreviousPage(options, data) {
+    if (!data || !options.getPreviousPageParam) return false;
+    return typeof getPreviousPageParam(options, data) !== 'undefined';
   }
 
   // CLASS
@@ -1711,10 +1716,11 @@
       });
     }
     cancelQueries(filters = {}, cancelOptions = {}) {
-      if (typeof cancelOptions.revert === 'undefined') {
-        cancelOptions.revert = true;
-      }
-      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
+      const defaultedCancelOptions = {
+        revert: true,
+        ...cancelOptions
+      };
+      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map(query => query.cancel(defaultedCancelOptions)));
       return Promise.all(promises).then(noop$1).catch(noop$1);
     }
     invalidateQueries(filters = {}, options = {}) {
@@ -1733,15 +1739,18 @@
       });
     }
     refetchQueries(filters = {}, options) {
-      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => query.fetch(undefined, {
+      const fetchOptions = {
         ...options,
         cancelRefetch: options?.cancelRefetch ?? true
-      })));
-      let promise = Promise.all(promises).then(noop$1);
-      if (!options?.throwOnError) {
-        promise = promise.catch(noop$1);
-      }
-      return promise;
+      };
+      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {
+        let promise = query.fetch(undefined, fetchOptions);
+        if (!fetchOptions.throwOnError) {
+          promise = promise.catch(noop$1);
+        }
+        return query.state.fetchStatus === 'paused' ? Promise.resolve() : promise;
+      }));
+      return Promise.all(promises).then(noop$1);
     }
     fetchQuery(options) {
       const defaultedOptions = this.defaultQueryOptions(options);
@@ -1834,8 +1843,8 @@
       if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {
         defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';
       }
-      if (typeof defaultedOptions.throwErrors === 'undefined') {
-        defaultedOptions.throwErrors = !!defaultedOptions.suspense;
+      if (typeof defaultedOptions.throwOnError === 'undefined') {
+        defaultedOptions.throwOnError = !!defaultedOptions.suspense;
       }
       return defaultedOptions;
     }
@@ -1863,10 +1872,12 @@
     #currentResult = undefined;
     #currentResultState;
     #currentResultOptions;
-    #previousQueryResult;
     #selectError;
     #selectFn;
     #selectResult;
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    #lastQueryWithDefinedData;
     #staleTimeoutId;
     #refetchIntervalId;
     #currentRefetchInterval;
@@ -2023,7 +2034,7 @@
       }, timeout);
     }
     #computeRefetchInterval() {
-      return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval ?? false;
+      return (typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval) ?? false;
     }
     #updateRefetchInterval(nextInterval) {
       this.#clearRefetchInterval();
@@ -2061,7 +2072,6 @@
       const prevResultOptions = this.#currentResultOptions;
       const queryChange = query !== prevQuery;
       const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
-      const prevQueryResult = queryChange ? this.#currentResult : this.#previousQueryResult;
       const {
         state
       } = query;
@@ -2120,7 +2130,7 @@
         if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
           placeholderData = prevResult.data;
         } else {
-          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(prevQueryResult?.data) : options.placeholderData;
+          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(this.#lastQueryWithDefinedData?.state.data, this.#lastQueryWithDefinedData) : options.placeholderData;
           if (options.select && typeof placeholderData !== 'undefined') {
             try {
               placeholderData = options.select(placeholderData);
@@ -2184,6 +2194,9 @@
       if (shallowEqualObjects(nextResult, prevResult)) {
         return;
       }
+      if (this.#currentResultState.data !== undefined) {
+        this.#lastQueryWithDefinedData = this.#currentQuery;
+      }
       this.#currentResult = nextResult;
 
       // Determine which callbacks to trigger
@@ -2199,7 +2212,7 @@
           return true;
         }
         const includedProps = new Set(notifyOnChangeProps ?? this.#trackedProps);
-        if (this.options.throwErrors) {
+        if (this.options.throwOnError) {
           includedProps.add('error');
         }
         return Object.keys(this.#currentResult).some(key => {
@@ -2224,36 +2237,20 @@
       const prevQuery = this.#currentQuery;
       this.#currentQuery = query;
       this.#currentQueryInitialState = query.state;
-      this.#previousQueryResult = this.#currentResult;
       if (this.hasListeners()) {
         prevQuery?.removeObserver(this);
         query.addObserver(this);
       }
     }
-    onQueryUpdate(action) {
-      const notifyOptions = {};
-      if (action.type === 'success') {
-        notifyOptions.onSuccess = !action.manual;
-      } else if (action.type === 'error' && !isCancelledError(action.error)) {
-        notifyOptions.onError = true;
-      }
-      this.#updateResult(notifyOptions);
+    onQueryUpdate() {
+      this.#updateResult();
       if (this.hasListeners()) {
         this.#updateTimers();
       }
     }
     #notify(notifyOptions) {
       notifyManager.batch(() => {
-        // First trigger the configuration callbacks
-        if (notifyOptions.onSuccess) {
-          this.options.onSuccess?.(this.#currentResult.data);
-          this.options.onSettled?.(this.#currentResult.data, null);
-        } else if (notifyOptions.onError) {
-          this.options.onError?.(this.#currentResult.error);
-          this.options.onSettled?.(undefined, this.#currentResult.error);
-        }
-
-        // Then trigger the listeners
+        // First, trigger the listeners
         if (notifyOptions.listeners) {
           this.listeners.forEach(listener => {
             listener(this.#currentResult);
@@ -2375,9 +2372,10 @@
     }
     #findMatchingObservers(queries) {
       const prevObservers = this.#observers;
+      const prevObserversMap = new Map(prevObservers.map(observer => [observer.options.queryHash, observer]));
       const defaultedQueryOptions = queries.map(options => this.#client.defaultQueryOptions(options));
       const matchingObservers = defaultedQueryOptions.flatMap(defaultedOptions => {
-        const match = prevObservers.find(observer => observer.options.queryHash === defaultedOptions.queryHash);
+        const match = prevObserversMap.get(defaultedOptions.queryHash);
         if (match != null) {
           return [{
             defaultedQueryOptions: defaultedOptions,
@@ -2386,8 +2384,8 @@
         }
         return [];
       });
-      const matchedQueryHashes = matchingObservers.map(match => match.defaultedQueryOptions.queryHash);
-      const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.includes(defaultedOptions.queryHash));
+      const matchedQueryHashes = new Set(matchingObservers.map(match => match.defaultedQueryOptions.queryHash));
+      const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.has(defaultedOptions.queryHash));
       const getObserver = options => {
         const defaultedOptions = this.#client.defaultQueryOptions(options);
         const currentObserver = this.#observers.find(o => o.options.queryHash === defaultedOptions.queryHash);
@@ -2444,7 +2442,7 @@
       options.behavior = infiniteQueryBehavior();
       return super.getOptimisticResult(options);
     }
-    fetchNextPage(options = {}) {
+    fetchNextPage(options) {
       return this.fetch({
         ...options,
         meta: {
@@ -2454,9 +2452,7 @@
         }
       });
     }
-    fetchPreviousPage({
-      ...options
-    } = {}) {
+    fetchPreviousPage(options) {
       return this.fetch({
         ...options,
         meta: {
@@ -2481,8 +2477,8 @@
         ...result,
         fetchNextPage: this.fetchNextPage,
         fetchPreviousPage: this.fetchPreviousPage,
-        hasNextPage: hasNextPage(options, state.data?.pages),
-        hasPreviousPage: hasPreviousPage(options, state.data?.pages),
+        hasNextPage: hasNextPage(options, state.data),
+        hasPreviousPage: hasPreviousPage(options, state.data),
         isFetchingNextPage,
         isFetchingPreviousPage,
         isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
@@ -2608,24 +2604,10 @@
     return query.state.status === 'success';
   }
   function dehydrate(client, options = {}) {
-    const mutations = [];
-    const queries = [];
-    if (options.dehydrateMutations !== false) {
-      const shouldDehydrateMutation = options.shouldDehydrateMutation || defaultShouldDehydrateMutation;
-      client.getMutationCache().getAll().forEach(mutation => {
-        if (shouldDehydrateMutation(mutation)) {
-          mutations.push(dehydrateMutation(mutation));
-        }
-      });
-    }
-    if (options.dehydrateQueries !== false) {
-      const shouldDehydrateQuery = options.shouldDehydrateQuery || defaultShouldDehydrateQuery;
-      client.getQueryCache().getAll().forEach(query => {
-        if (shouldDehydrateQuery(query)) {
-          queries.push(dehydrateQuery(query));
-        }
-      });
-    }
+    const filterMutation = options.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
+    const mutations = client.getMutationCache().getAll().flatMap(mutation => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []);
+    const filterQuery = options.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;
+    const queries = client.getQueryCache().getAll().flatMap(query => filterQuery(query) ? [dehydrateQuery(query)] : []);
     return {
       mutations,
       queries
@@ -2747,7 +2729,7 @@
   }
 
   const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
-    if (options.suspense || options.throwErrors) {
+    if (options.suspense || options.throwOnError) {
       // Prevent retrying failed query if the error boundary has not been reset yet
       if (!errorResetBoundary.isReset()) {
         options.retryOnMount = false;
@@ -2762,10 +2744,10 @@
   const getHasError = ({
     result,
     errorResetBoundary,
-    throwErrors,
+    throwOnError,
     query
   }) => {
-    return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(throwErrors, [result.error, query]);
+    return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(throwOnError, [result.error, query]);
   };
 
   const ensureStaleTime = defaultedOptions => {
@@ -2779,26 +2761,19 @@
   };
   const willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
   const shouldSuspend = (defaultedOptions, result, isRestoring) => defaultedOptions?.suspense && willFetch(result, isRestoring);
-  const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).then(({
-    data
-  }) => {
-    defaultedOptions.onSuccess?.(data);
-    defaultedOptions.onSettled?.(data, null);
-  }).catch(error => {
+  const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
     errorResetBoundary.clearReset();
-    defaultedOptions.onError?.(error);
-    defaultedOptions.onSettled?.(undefined, error);
   });
 
   // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
   // `placeholderData` function does not have a parameter
 
   function useQueries({
-    queries,
-    queryClient
-  }) {
+    queries
+  }, queryClient) {
     const client = useQueryClient(queryClient);
     const isRestoring = useIsRestoring();
+    const errorResetBoundary = useQueryErrorResetBoundary();
     const defaultedQueries = React__namespace.useMemo(() => queries.map(options => {
       const defaultedOptions = client.defaultQueryOptions(options);
 
@@ -2806,6 +2781,11 @@
       defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
       return defaultedOptions;
     }), [queries, client, isRestoring]);
+    defaultedQueries.forEach(query => {
+      ensureStaleTime(query);
+      ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
+    });
+    useClearResetErrorBoundary(errorResetBoundary);
     const [observer] = React__namespace.useState(() => new QueriesObserver(client, defaultedQueries));
     const optimisticResult = observer.getOptimisticResult(defaultedQueries);
     React__namespace.useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
@@ -2816,12 +2796,6 @@
         listeners: false
       });
     }, [defaultedQueries, observer]);
-    const errorResetBoundary = useQueryErrorResetBoundary();
-    defaultedQueries.forEach(query => {
-      ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
-      ensureStaleTime(query);
-    });
-    useClearResetErrorBoundary(errorResetBoundary);
     const shouldAtLeastOneSuspend = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result, isRestoring));
     const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
       const options = defaultedQueries[index];
@@ -2838,11 +2812,12 @@
     if (suspensePromises.length > 0) {
       throw Promise.all(suspensePromises);
     }
+    const observerQueries = observer.getQueries();
     const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => getHasError({
       result,
       errorResetBoundary,
-      throwErrors: defaultedQueries[index]?.throwErrors ?? false,
-      query: observer.getQueries()[index]
+      throwOnError: defaultedQueries[index]?.throwOnError ?? false,
+      query: observerQueries[index]
     }));
     if (firstSingleResultWhichShouldThrow?.error) {
       throw firstSingleResultWhichShouldThrow.error;
@@ -2858,17 +2833,6 @@
 
     // Make sure results are optimistically set in fetching state before subscribing or updating options
     defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
-
-    // Include callbacks in batch renders
-    if (defaultedOptions.onError) {
-      defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);
-    }
-    if (defaultedOptions.onSuccess) {
-      defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);
-    }
-    if (defaultedOptions.onSettled) {
-      defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);
-    }
     ensureStaleTime(defaultedOptions);
     ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
     useClearResetErrorBoundary(errorResetBoundary);
@@ -2892,7 +2856,7 @@
     if (getHasError({
       result,
       errorResetBoundary,
-      throwErrors: defaultedOptions.throwErrors,
+      throwOnError: defaultedOptions.throwOnError,
       query: observer.getCurrentQuery()
     })) {
       throw result.error;
@@ -2902,6 +2866,10 @@
     return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
   }
 
+  function queryOptions(options) {
+    return options;
+  }
+
   // HOOK
 
   function useQuery(options, queryClient) {
@@ -2979,7 +2947,7 @@
     const mutate = React__namespace.useCallback((variables, mutateOptions) => {
       observer.mutate(variables, mutateOptions).catch(noop);
     }, [observer]);
-    if (result.error && shouldThrowError(observer.options.throwErrors, [result.error])) {
+    if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) {
       throw result.error;
     }
     return {
@@ -3024,6 +2992,7 @@
   exports.matchQuery = matchQuery;
   exports.notifyManager = notifyManager;
   exports.onlineManager = onlineManager;
+  exports.queryOptions = queryOptions;
   exports.replaceEqualDeep = replaceEqualDeep;
   exports.useInfiniteQuery = useInfiniteQuery;
   exports.useIsFetching = useIsFetching;