@tanstack/vue-query 5.0.0-alpha.1 → 5.0.0-alpha.10

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) {
@@ -3661,7 +3675,6 @@
     };
   }
 
-  /* istanbul ignore file */
   // eslint-disable-next-line no-shadow
   var QueryState;
   (function (QueryState) {
@@ -3739,7 +3752,6 @@
     'Last Updated': dateSort
   };
 
-  /* istanbul ignore file */
   const pluginId = 'vue-query';
   const pluginName = 'Vue Query';
   function setupDevtools(app, queryClient) {
@@ -3747,8 +3759,8 @@
       id: pluginId,
       label: pluginName,
       packageName: 'vue-query',
-      homepage: 'https://tanstack.com/query/v4',
-      logo: 'https://vue-query.vercel.app/vue-query.svg',
+      homepage: 'https://tanstack.com/query/latest',
+      logo: 'https://raw.githubusercontent.com/TanStack/query/main/packages/vue-query/media/vue-query.svg',
       app,
       settings: {
         baseSort: {
@@ -3772,16 +3784,31 @@
             value: key
           })),
           defaultValue: Object.keys(sortFns)[0]
+        },
+        onlineMode: {
+          type: 'choice',
+          component: 'button-group',
+          label: 'Online mode',
+          options: [{
+            label: 'Online',
+            value: 1
+          }, {
+            label: 'Offline',
+            value: 0
+          }],
+          defaultValue: 1
         }
       }
     }, api => {
+      const initialSettings = api.getSettings();
+      onlineManager.setOnline(Boolean(initialSettings.onlineMode.valueOf()));
       const queryCache = queryClient.getQueryCache();
       api.addInspector({
         id: pluginId,
         label: pluginName,
         icon: 'api',
         nodeActions: [{
-          icon: 'cloud_download',
+          icon: 'file_download',
           tooltip: 'Refetch',
           action: queryHash => {
             queryCache.get(queryHash)?.fetch();
@@ -3806,6 +3833,27 @@
             const query = queryCache.get(queryHash);
             queryCache.remove(query);
           }
+        }, {
+          icon: 'hourglass_empty',
+          tooltip: 'Force loading',
+          action: queryHash => {
+            const query = queryCache.get(queryHash);
+            query.setState({
+              data: undefined,
+              status: 'pending'
+            });
+          }
+        }, {
+          icon: 'error_outline',
+          tooltip: 'Force error',
+          action: queryHash => {
+            const query = queryCache.get(queryHash);
+            query.setState({
+              data: undefined,
+              status: 'error',
+              error: new Error('Unknown error from devtools')
+            });
+          }
         }]
       });
       api.addTimelineLayer({
@@ -3816,9 +3864,7 @@
       queryCache.subscribe(event => {
         api.sendInspectorTree(pluginId);
         api.sendInspectorState(pluginId);
-        if (
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        event && ['queryAdded', 'queryRemoved', 'queryUpdated'].includes(event.type)) {
+        if (['added', 'removed', 'updated'].includes(event.type)) {
           api.addTimelineEvent({
             layerId: pluginId,
             event: {
@@ -3833,6 +3879,11 @@
           });
         }
       });
+      api.on.setPluginSettings(payload => {
+        if (payload.key === 'onlineMode') {
+          onlineManager.setOnline(Boolean(payload.newValue));
+        }
+      });
       api.on.getInspectorTree(payload => {
         if (payload.inspectorId === pluginId) {
           const queries = queryCache.getAll();
@@ -3925,8 +3976,6 @@
           originalUnmount();
         };
       }
-
-      /* istanbul ignore next */
       if (vueDemi.isVue2) {
         app.mixin({
           beforeCreate() {
@@ -4026,9 +4075,8 @@
 
   /* eslint-disable @typescript-eslint/no-explicit-any */
   function useQueries({
-    queries,
-    queryClient
-  }) {
+    queries
+  }, queryClient) {
     const client = queryClient || useQueryClient();
     const defaultedQueries = vueDemi.computed(() => cloneDeepUnref(queries).map(options => {
       const defaulted = client.defaultQueryOptions(options);
@@ -4047,14 +4095,14 @@
           state.value.splice(0, result.length, ...result);
         });
         // Subscription would not fire for persisted results
-        state.value.splice(0, state.value.length, ...observer.getOptimisticResult(defaultedQueries.value));
+        state.value = observer.getOptimisticResult(defaultedQueries.value);
       }
     }, {
       immediate: true
     });
     vueDemi.watch(defaultedQueries, () => {
       observer.setQueries(defaultedQueries.value);
-      state.value.splice(0, state.value.length, ...observer.getCurrentResult());
+      state.value = observer.getCurrentResult();
     }, {
       deep: true
     });
@@ -4127,22 +4175,31 @@
     return isFetching;
   }
 
-  function useIsMutating(mutationFilters = {}, queryClient) {
-    const filters = vueDemi.computed(() => cloneDeepUnref(mutationFilters));
+  function useIsMutating(filters = {}, queryClient) {
     const client = queryClient || useQueryClient();
-    const isMutating = vueDemi.ref(client.isMutating(filters));
-    const unsubscribe = client.getMutationCache().subscribe(() => {
-      isMutating.value = client.isMutating(filters);
-    });
-    vueDemi.watch(filters, () => {
-      isMutating.value = client.isMutating(filters);
-    }, {
-      deep: true
+    const unreffedFilters = vueDemi.computed(() => ({
+      ...cloneDeepUnref(filters),
+      status: 'pending'
+    }));
+    const length = vueDemi.computed(() => useMutationState({
+      filters: unreffedFilters
+    }, client).value.length);
+    return length;
+  }
+  function getResult(mutationCache, options) {
+    return mutationCache.findAll(options.filters).map(mutation => options.select ? options.select(mutation) : mutation.state);
+  }
+  function useMutationState(options = {}, queryClient) {
+    const mutationCache = (queryClient || useQueryClient()).getMutationCache();
+    const state = vueDemi.ref(getResult(mutationCache, options));
+    const unsubscribe = mutationCache.subscribe(() => {
+      const result = getResult(mutationCache, options);
+      state.value = result;
     });
     vueDemi.onScopeDispose(() => {
       unsubscribe();
     });
-    return isMutating;
+    return vueDemi.readonly(state);
   }
 
   exports.CancelledError = CancelledError;
@@ -4164,6 +4221,7 @@
   exports.isCancelledError = isCancelledError;
   exports.isServer = isServer;
   exports.keepPreviousData = keepPreviousData;
+  exports.matchQuery = matchQuery;
   exports.notifyManager = notifyManager;
   exports.onlineManager = onlineManager;
   exports.replaceEqualDeep = replaceEqualDeep;
@@ -4171,6 +4229,7 @@
   exports.useIsFetching = useIsFetching;
   exports.useIsMutating = useIsMutating;
   exports.useMutation = useMutation;
+  exports.useMutationState = useMutationState;
   exports.useQueries = useQueries;
   exports.useQuery = useQuery;
   exports.useQueryClient = useQueryClient;