@tanstack/query-core 5.0.0-alpha.1 → 5.0.0-alpha.12

package/build/umd/index.development.js

@@ -889,6 +889,7 @@
         if (!isCancelledError(error)) {
           // Notify cache callback
           this.#cache.config.onError?.(error, this);
+          this.#cache.config.onSettled?.(this.state.data, error, this);
         }
         if (!this.isFetchingOptimistic) {
           // Schedule query gc after fetching
@@ -913,6 +914,7 @@
 
           // Notify cache callback
           this.#cache.config.onSuccess?.(data, this);
+          this.#cache.config.onSettled?.(data, this.state.error, this);
           if (!this.isFetchingOptimistic) {
             // Schedule query gc after fetching
             this.scheduleGc();
@@ -1152,18 +1154,26 @@
 
   class Mutation extends Removable {
     #observers;
+    #defaultOptions;
     #mutationCache;
     #retryer;
     constructor(config) {
       super();
-      this.options = config.options;
       this.mutationId = config.mutationId;
+      this.#defaultOptions = config.defaultOptions;
       this.#mutationCache = config.mutationCache;
       this.#observers = [];
       this.state = config.state || getDefaultState();
-      this.updateGcTime(this.options.gcTime);
+      this.setOptions(config.options);
       this.scheduleGc();
     }
+    setOptions(options) {
+      this.options = {
+        ...this.#defaultOptions,
+        ...options
+      };
+      this.updateGcTime(this.options.gcTime);
+    }
     get meta() {
       return this.options.meta;
     }
@@ -1258,6 +1268,9 @@
         // Notify cache callback
         await this.#mutationCache.config.onSuccess?.(data, variables, this.state.context, this);
         await this.options.onSuccess?.(data, variables, this.state.context);
+
+        // Notify cache callback
+        await this.#mutationCache.config.onSettled?.(data, null, this.state.variables, this.state.context, this);
         await this.options.onSettled?.(data, null, variables, this.state.context);
         this.#dispatch({
           type: 'success',
@@ -1269,6 +1282,9 @@
           // Notify cache callback
           await this.#mutationCache.config.onError?.(error, variables, this.state.context, this);
           await this.options.onError?.(error, variables, this.state.context);
+
+          // Notify cache callback
+          await this.#mutationCache.config.onSettled?.(undefined, error, this.state.variables, this.state.context, this);
           await this.options.onSettled?.(undefined, error, variables, this.state.context);
           throw error;
         } finally {
@@ -1438,12 +1454,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', {
@@ -1463,95 +1482,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
@@ -2266,14 +2285,12 @@
     #result;
     #queries;
     #observers;
-    #observersMap;
     constructor(client, queries) {
       super();
       this.#client = client;
       this.#queries = [];
       this.#result = [];
       this.#observers = [];
-      this.#observersMap = {};
       if (queries) {
         this.setQueries(queries);
       }
@@ -2307,14 +2324,12 @@
         // set options for the new observers to notify of changes
         newObserverMatches.forEach(match => match.observer.setOptions(match.defaultedQueryOptions, notifyOptions));
         const newObservers = newObserverMatches.map(match => match.observer);
-        const newObserversMap = Object.fromEntries(newObservers.map(observer => [observer.options.queryHash, observer]));
         const newResult = newObservers.map(observer => observer.getCurrentResult());
         const hasIndexChange = newObservers.some((observer, index) => observer !== prevObservers[index]);
         if (prevObservers.length === newObservers.length && !hasIndexChange) {
           return;
         }
         this.#observers = newObservers;
-        this.#observersMap = newObserversMap;
         this.#result = newResult;
         if (!this.hasListeners()) {
           return;
@@ -2359,7 +2374,7 @@
       const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.includes(defaultedOptions.queryHash));
       const getObserver = options => {
         const defaultedOptions = this.#client.defaultQueryOptions(options);
-        const currentObserver = this.#observersMap[defaultedOptions.queryHash];
+        const currentObserver = this.#observers.find(o => o.options.queryHash === defaultedOptions.queryHash);
         return currentObserver ?? new QueryObserver(this.#client, defaultedOptions);
       };
       const newOrReusedObservers = unmatchedQueries.map(options => {
@@ -2413,7 +2428,7 @@
       options.behavior = infiniteQueryBehavior();
       return super.getOptimisticResult(options);
     }
-    fetchNextPage(options = {}) {
+    fetchNextPage(options) {
       return this.fetch({
         ...options,
         meta: {
@@ -2423,9 +2438,7 @@
         }
       });
     }
-    fetchPreviousPage({
-      ...options
-    } = {}) {
+    fetchPreviousPage(options) {
       return this.fetch({
         ...options,
         meta: {
@@ -2450,8 +2463,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
@@ -2489,6 +2502,7 @@
           observer: this
         });
       }
+      this.#currentMutation?.setOptions(this.options);
     }
     onUnsubscribe() {
       if (!this.listeners.length) {
@@ -2576,24 +2590,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
@@ -2660,6 +2660,7 @@
   exports.isCancelledError = isCancelledError;
   exports.isServer = isServer;
   exports.keepPreviousData = keepPreviousData;
+  exports.matchQuery = matchQuery;
   exports.notifyManager = notifyManager;
   exports.onlineManager = onlineManager;
   exports.replaceEqualDeep = replaceEqualDeep;