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

package/build/lib/queryObserver.mjs

@@ -5,110 +5,105 @@ import { Subscribable } from './subscribable.mjs';
 import { canFetch, isCancelledError } from './retryer.mjs';
 
 class QueryObserver extends Subscribable {
+  #client;
+  #currentQuery = undefined;
+  #currentQueryInitialState = undefined;
+  #currentResult = undefined;
+  #currentResultState;
+  #currentResultOptions;
+  #previousQueryResult;
+  #selectError;
+  #selectFn;
+  #selectResult;
+  #staleTimeoutId;
+  #refetchIntervalId;
+  #currentRefetchInterval;
+  #trackedProps = new Set();
   constructor(client, options) {
     super();
-    this.client = client;
+    this.#client = client;
     this.options = options;
-    this.trackedProps = new Set();
-    this.selectError = null;
+    this.#selectError = null;
     this.bindMethods();
     this.setOptions(options);
   }
-
   bindMethods() {
-    this.remove = this.remove.bind(this);
     this.refetch = this.refetch.bind(this);
   }
-
   onSubscribe() {
     if (this.listeners.length === 1) {
-      this.currentQuery.addObserver(this);
-
-      if (shouldFetchOnMount(this.currentQuery, this.options)) {
-        this.executeFetch();
+      this.#currentQuery.addObserver(this);
+      if (shouldFetchOnMount(this.#currentQuery, this.options)) {
+        this.#executeFetch();
       }
-
-      this.updateTimers();
+      this.#updateTimers();
     }
   }
-
   onUnsubscribe() {
     if (!this.listeners.length) {
       this.destroy();
     }
   }
-
   shouldFetchOnReconnect() {
-    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnReconnect);
+    return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnReconnect);
   }
-
   shouldFetchOnWindowFocus() {
-    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnWindowFocus);
+    return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
   }
-
   destroy() {
     this.listeners = [];
-    this.clearStaleTimeout();
-    this.clearRefetchInterval();
-    this.currentQuery.removeObserver(this);
+    this.#clearStaleTimeout();
+    this.#clearRefetchInterval();
+    this.#currentQuery.removeObserver(this);
   }
-
   setOptions(options, notifyOptions) {
     const prevOptions = this.options;
-    const prevQuery = this.currentQuery;
-    this.options = this.client.defaultQueryOptions(options);
-
-    if (process.env.NODE_ENV !== 'production' && typeof (options == null ? void 0 : options.isDataEqual) !== 'undefined') {
-      this.client.getLogger().error("The isDataEqual option has been deprecated and will be removed in the next major version. You can achieve the same functionality by passing a function as the structuralSharing option");
-    }
-
+    const prevQuery = this.#currentQuery;
+    this.options = this.#client.defaultQueryOptions(options);
     if (!shallowEqualObjects(prevOptions, this.options)) {
-      this.client.getQueryCache().notify({
+      this.#client.getQueryCache().notify({
         type: 'observerOptionsUpdated',
-        query: this.currentQuery,
+        query: this.#currentQuery,
         observer: this
       });
     }
-
     if (typeof this.options.enabled !== 'undefined' && typeof this.options.enabled !== 'boolean') {
       throw new Error('Expected enabled to be a boolean');
-    } // Keep previous query key if the user does not supply one
-
+    }
 
+    // Keep previous query key if the user does not supply one
     if (!this.options.queryKey) {
       this.options.queryKey = prevOptions.queryKey;
     }
+    this.#updateQuery();
+    const mounted = this.hasListeners();
 
-    this.updateQuery();
-    const mounted = this.hasListeners(); // Fetch if there are subscribers
-
-    if (mounted && shouldFetchOptionally(this.currentQuery, prevQuery, this.options, prevOptions)) {
-      this.executeFetch();
-    } // Update result
-
+    // Fetch if there are subscribers
+    if (mounted && shouldFetchOptionally(this.#currentQuery, prevQuery, this.options, prevOptions)) {
+      this.#executeFetch();
+    }
 
-    this.updateResult(notifyOptions); // Update stale interval if needed
+    // Update result
+    this.#updateResult(notifyOptions);
 
-    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
-      this.updateStaleTimeout();
+    // Update stale interval if needed
+    if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
+      this.#updateStaleTimeout();
     }
+    const nextRefetchInterval = this.#computeRefetchInterval();
 
-    const nextRefetchInterval = this.computeRefetchInterval(); // Update refetch interval if needed
-
-    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.currentRefetchInterval)) {
-      this.updateRefetchInterval(nextRefetchInterval);
+    // Update refetch interval if needed
+    if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.#currentRefetchInterval)) {
+      this.#updateRefetchInterval(nextRefetchInterval);
     }
   }
-
   getOptimisticResult(options) {
-    const query = this.client.getQueryCache().build(this.client, options);
+    const query = this.#client.getQueryCache().build(this.#client, options);
     return this.createResult(query, options);
   }
-
   getCurrentResult() {
-    return this.currentResult;
+    return this.#currentResult;
   }
-
   trackResult(result) {
     const trackedResult = {};
     Object.keys(result).forEach(key => {
@@ -116,243 +111,199 @@ class QueryObserver extends Subscribable {
         configurable: false,
         enumerable: true,
         get: () => {
-          this.trackedProps.add(key);
+          this.#trackedProps.add(key);
           return result[key];
         }
       });
     });
     return trackedResult;
   }
-
   getCurrentQuery() {
-    return this.currentQuery;
-  }
-
-  remove() {
-    this.client.getQueryCache().remove(this.currentQuery);
+    return this.#currentQuery;
   }
-
   refetch({
-    refetchPage,
     ...options
   } = {}) {
-    return this.fetch({ ...options,
-      meta: {
-        refetchPage
-      }
+    return this.fetch({
+      ...options
     });
   }
-
   fetchOptimistic(options) {
-    const defaultedOptions = this.client.defaultQueryOptions(options);
-    const query = this.client.getQueryCache().build(this.client, defaultedOptions);
+    const defaultedOptions = this.#client.defaultQueryOptions(options);
+    const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
     query.isFetchingOptimistic = true;
     return query.fetch().then(() => this.createResult(query, defaultedOptions));
   }
-
   fetch(fetchOptions) {
-    var _fetchOptions$cancelR;
-
-    return this.executeFetch({ ...fetchOptions,
-      cancelRefetch: (_fetchOptions$cancelR = fetchOptions.cancelRefetch) != null ? _fetchOptions$cancelR : true
+    return this.#executeFetch({
+      ...fetchOptions,
+      cancelRefetch: fetchOptions.cancelRefetch ?? true
     }).then(() => {
-      this.updateResult();
-      return this.currentResult;
+      this.#updateResult();
+      return this.#currentResult;
     });
   }
-
-  executeFetch(fetchOptions) {
+  #executeFetch(fetchOptions) {
     // Make sure we reference the latest query as the current one might have been removed
-    this.updateQuery(); // Fetch
+    this.#updateQuery();
 
-    let promise = this.currentQuery.fetch(this.options, fetchOptions);
-
-    if (!(fetchOptions != null && fetchOptions.throwOnError)) {
+    // Fetch
+    let promise = this.#currentQuery.fetch(this.options, fetchOptions);
+    if (!fetchOptions?.throwOnError) {
       promise = promise.catch(noop);
     }
-
     return promise;
   }
-
-  updateStaleTimeout() {
-    this.clearStaleTimeout();
-
-    if (isServer || this.currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
+  #updateStaleTimeout() {
+    this.#clearStaleTimeout();
+    if (isServer || this.#currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
       return;
     }
+    const time = timeUntilStale(this.#currentResult.dataUpdatedAt, this.options.staleTime);
 
-    const time = timeUntilStale(this.currentResult.dataUpdatedAt, this.options.staleTime); // The timeout is sometimes triggered 1 ms before the stale time expiration.
+    // The timeout is sometimes triggered 1 ms before the stale time expiration.
     // To mitigate this issue we always add 1 ms to the timeout.
-
     const timeout = time + 1;
-    this.staleTimeoutId = setTimeout(() => {
-      if (!this.currentResult.isStale) {
-        this.updateResult();
+    this.#staleTimeoutId = setTimeout(() => {
+      if (!this.#currentResult.isStale) {
+        this.#updateResult();
       }
     }, timeout);
   }
-
-  computeRefetchInterval() {
-    var _this$options$refetch;
-
-    return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.currentResult.data, this.currentQuery) : (_this$options$refetch = this.options.refetchInterval) != null ? _this$options$refetch : false;
+  #computeRefetchInterval() {
+    return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval ?? false;
   }
-
-  updateRefetchInterval(nextInterval) {
-    this.clearRefetchInterval();
-    this.currentRefetchInterval = nextInterval;
-
-    if (isServer || this.options.enabled === false || !isValidTimeout(this.currentRefetchInterval) || this.currentRefetchInterval === 0) {
+  #updateRefetchInterval(nextInterval) {
+    this.#clearRefetchInterval();
+    this.#currentRefetchInterval = nextInterval;
+    if (isServer || this.options.enabled === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
       return;
     }
-
-    this.refetchIntervalId = setInterval(() => {
+    this.#refetchIntervalId = setInterval(() => {
       if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
-        this.executeFetch();
+        this.#executeFetch();
       }
-    }, this.currentRefetchInterval);
+    }, this.#currentRefetchInterval);
   }
-
-  updateTimers() {
-    this.updateStaleTimeout();
-    this.updateRefetchInterval(this.computeRefetchInterval());
+  #updateTimers() {
+    this.#updateStaleTimeout();
+    this.#updateRefetchInterval(this.#computeRefetchInterval());
   }
-
-  clearStaleTimeout() {
-    if (this.staleTimeoutId) {
-      clearTimeout(this.staleTimeoutId);
-      this.staleTimeoutId = undefined;
+  #clearStaleTimeout() {
+    if (this.#staleTimeoutId) {
+      clearTimeout(this.#staleTimeoutId);
+      this.#staleTimeoutId = undefined;
     }
   }
-
-  clearRefetchInterval() {
-    if (this.refetchIntervalId) {
-      clearInterval(this.refetchIntervalId);
-      this.refetchIntervalId = undefined;
+  #clearRefetchInterval() {
+    if (this.#refetchIntervalId) {
+      clearInterval(this.#refetchIntervalId);
+      this.#refetchIntervalId = undefined;
     }
   }
-
   createResult(query, options) {
-    const prevQuery = this.currentQuery;
+    const prevQuery = this.#currentQuery;
     const prevOptions = this.options;
-    const prevResult = this.currentResult;
-    const prevResultState = this.currentResultState;
-    const prevResultOptions = this.currentResultOptions;
+    const prevResult = this.#currentResult;
+    const prevResultState = this.#currentResultState;
+    const prevResultOptions = this.#currentResultOptions;
     const queryChange = query !== prevQuery;
-    const queryInitialState = queryChange ? query.state : this.currentQueryInitialState;
-    const prevQueryResult = queryChange ? this.currentResult : this.previousQueryResult;
+    const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
+    const prevQueryResult = queryChange ? this.#currentResult : this.#previousQueryResult;
     const {
       state
     } = query;
     let {
-      dataUpdatedAt,
       error,
       errorUpdatedAt,
       fetchStatus,
       status
     } = state;
-    let isPreviousData = false;
     let isPlaceholderData = false;
-    let data; // Optimistically set result in fetching state if needed
+    let data;
 
+    // Optimistically set result in fetching state if needed
     if (options._optimisticResults) {
       const mounted = this.hasListeners();
       const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
       const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
-
       if (fetchOnMount || fetchOptionally) {
         fetchStatus = canFetch(query.options.networkMode) ? 'fetching' : 'paused';
-
-        if (!dataUpdatedAt) {
-          status = 'loading';
+        if (!state.dataUpdatedAt) {
+          status = 'pending';
         }
       }
-
       if (options._optimisticResults === 'isRestoring') {
         fetchStatus = 'idle';
       }
-    } // Keep previous data if needed
-
+    }
 
-    if (options.keepPreviousData && !state.dataUpdatedAt && prevQueryResult != null && prevQueryResult.isSuccess && status !== 'error') {
-      data = prevQueryResult.data;
-      dataUpdatedAt = prevQueryResult.dataUpdatedAt;
-      status = prevQueryResult.status;
-      isPreviousData = true;
-    } // Select data if needed
-    else if (options.select && typeof state.data !== 'undefined') {
+    // Select data if needed
+    if (options.select && typeof state.data !== 'undefined') {
       // Memoize select result
-      if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === this.selectFn) {
-        data = this.selectResult;
+      if (prevResult && state.data === prevResultState?.data && options.select === this.#selectFn) {
+        data = this.#selectResult;
       } else {
         try {
-          this.selectFn = options.select;
+          this.#selectFn = options.select;
           data = options.select(state.data);
-          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
-          this.selectResult = data;
-          this.selectError = null;
+          data = replaceData(prevResult?.data, data, options);
+          this.#selectResult = data;
+          this.#selectError = null;
         } catch (selectError) {
-          if (process.env.NODE_ENV !== 'production') {
-            this.client.getLogger().error(selectError);
-          }
-
-          this.selectError = selectError;
+          this.#selectError = selectError;
         }
       }
-    } // Use query data
+    }
+    // Use query data
     else {
       data = state.data;
-    } // Show placeholder data if needed
-
+    }
 
-    if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'loading') {
-      let placeholderData; // Memoize placeholder data
+    // Show placeholder data if needed
+    if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'pending') {
+      let placeholderData;
 
-      if (prevResult != null && prevResult.isPlaceholderData && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
+      // Memoize placeholder data
+      if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
         placeholderData = prevResult.data;
       } else {
-        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData() : options.placeholderData;
-
+        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(prevQueryResult?.data) : options.placeholderData;
         if (options.select && typeof placeholderData !== 'undefined') {
           try {
             placeholderData = options.select(placeholderData);
-            this.selectError = null;
+            this.#selectError = null;
           } catch (selectError) {
-            if (process.env.NODE_ENV !== 'production') {
-              this.client.getLogger().error(selectError);
-            }
-
-            this.selectError = selectError;
+            this.#selectError = selectError;
           }
         }
       }
-
       if (typeof placeholderData !== 'undefined') {
         status = 'success';
-        data = replaceData(prevResult == null ? void 0 : prevResult.data, placeholderData, options);
+        data = replaceData(prevResult?.data, placeholderData, options);
         isPlaceholderData = true;
       }
     }
-
-    if (this.selectError) {
-      error = this.selectError;
-      data = this.selectResult;
+    if (this.#selectError) {
+      error = this.#selectError;
+      data = this.#selectResult;
       errorUpdatedAt = Date.now();
       status = 'error';
     }
-
     const isFetching = fetchStatus === 'fetching';
-    const isLoading = status === 'loading';
+    const isPending = status === 'pending';
     const isError = status === 'error';
+    const isLoading = isPending && isFetching;
     const result = {
       status,
       fetchStatus,
-      isLoading,
+      isPending,
       isSuccess: status === 'success',
       isError,
-      isInitialLoading: isLoading && isFetching,
+      isInitialLoading: isLoading,
+      isLoading,
       data,
-      dataUpdatedAt,
+      dataUpdatedAt: state.dataUpdatedAt,
       error,
       errorUpdatedAt,
       failureCount: state.fetchFailureCount,
@@ -361,159 +312,126 @@ class QueryObserver extends Subscribable {
       isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
       isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,
       isFetching,
-      isRefetching: isFetching && !isLoading,
+      isRefetching: isFetching && !isPending,
       isLoadingError: isError && state.dataUpdatedAt === 0,
       isPaused: fetchStatus === 'paused',
       isPlaceholderData,
-      isPreviousData,
       isRefetchError: isError && state.dataUpdatedAt !== 0,
       isStale: isStale(query, options),
-      refetch: this.refetch,
-      remove: this.remove
+      refetch: this.refetch
     };
     return result;
   }
+  #updateResult(notifyOptions) {
+    const prevResult = this.#currentResult;
+    const nextResult = this.createResult(this.#currentQuery, this.options);
+    this.#currentResultState = this.#currentQuery.state;
+    this.#currentResultOptions = this.options;
 
-  updateResult(notifyOptions) {
-    const prevResult = this.currentResult;
-    const nextResult = this.createResult(this.currentQuery, this.options);
-    this.currentResultState = this.currentQuery.state;
-    this.currentResultOptions = this.options; // Only notify and update result if something has changed
-
+    // Only notify and update result if something has changed
     if (shallowEqualObjects(nextResult, prevResult)) {
       return;
     }
+    this.#currentResult = nextResult;
 
-    this.currentResult = nextResult; // Determine which callbacks to trigger
-
-    const defaultNotifyOptions = {
-      cache: true
-    };
-
+    // Determine which callbacks to trigger
+    const defaultNotifyOptions = {};
     const shouldNotifyListeners = () => {
       if (!prevResult) {
         return true;
       }
-
       const {
         notifyOnChangeProps
       } = this.options;
-
-      if (notifyOnChangeProps === 'all' || !notifyOnChangeProps && !this.trackedProps.size) {
+      if (notifyOnChangeProps === 'all' || !notifyOnChangeProps && !this.#trackedProps.size) {
         return true;
       }
-
-      const includedProps = new Set(notifyOnChangeProps != null ? notifyOnChangeProps : this.trackedProps);
-
-      if (this.options.useErrorBoundary) {
+      const includedProps = new Set(notifyOnChangeProps ?? this.#trackedProps);
+      if (this.options.throwErrors) {
         includedProps.add('error');
       }
-
-      return Object.keys(this.currentResult).some(key => {
+      return Object.keys(this.#currentResult).some(key => {
         const typedKey = key;
-        const changed = this.currentResult[typedKey] !== prevResult[typedKey];
+        const changed = this.#currentResult[typedKey] !== prevResult[typedKey];
         return changed && includedProps.has(typedKey);
       });
     };
-
-    if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && shouldNotifyListeners()) {
+    if (notifyOptions?.listeners !== false && shouldNotifyListeners()) {
       defaultNotifyOptions.listeners = true;
     }
-
-    this.notify({ ...defaultNotifyOptions,
+    this.#notify({
+      ...defaultNotifyOptions,
       ...notifyOptions
     });
   }
-
-  updateQuery() {
-    const query = this.client.getQueryCache().build(this.client, this.options);
-
-    if (query === this.currentQuery) {
+  #updateQuery() {
+    const query = this.#client.getQueryCache().build(this.#client, this.options);
+    if (query === this.#currentQuery) {
       return;
     }
-
-    const prevQuery = this.currentQuery;
-    this.currentQuery = query;
-    this.currentQueryInitialState = query.state;
-    this.previousQueryResult = this.currentResult;
-
+    const prevQuery = this.#currentQuery;
+    this.#currentQuery = query;
+    this.#currentQueryInitialState = query.state;
+    this.#previousQueryResult = this.#currentResult;
     if (this.hasListeners()) {
-      prevQuery == null ? void 0 : prevQuery.removeObserver(this);
+      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);
-
+    this.#updateResult(notifyOptions);
     if (this.hasListeners()) {
-      this.updateTimers();
+      this.#updateTimers();
     }
   }
-
-  notify(notifyOptions) {
+  #notify(notifyOptions) {
     notifyManager.batch(() => {
       // First trigger the configuration callbacks
       if (notifyOptions.onSuccess) {
-        var _this$options$onSucce, _this$options, _this$options$onSettl, _this$options2;
-
-        (_this$options$onSucce = (_this$options = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options, this.currentResult.data);
-        (_this$options$onSettl = (_this$options2 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options2, this.currentResult.data, null);
+        this.options.onSuccess?.(this.#currentResult.data);
+        this.options.onSettled?.(this.#currentResult.data, null);
       } else if (notifyOptions.onError) {
-        var _this$options$onError, _this$options3, _this$options$onSettl2, _this$options4;
-
-        (_this$options$onError = (_this$options3 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options3, this.currentResult.error);
-        (_this$options$onSettl2 = (_this$options4 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options4, undefined, this.currentResult.error);
-      } // Then trigger the listeners
-
+        this.options.onError?.(this.#currentResult.error);
+        this.options.onSettled?.(undefined, this.#currentResult.error);
+      }
 
+      // Then trigger the listeners
       if (notifyOptions.listeners) {
         this.listeners.forEach(listener => {
-          listener(this.currentResult);
-        });
-      } // Then the cache listeners
-
-
-      if (notifyOptions.cache) {
-        this.client.getQueryCache().notify({
-          query: this.currentQuery,
-          type: 'observerResultsUpdated'
+          listener(this.#currentResult);
         });
       }
+
+      // Then the cache listeners
+      this.#client.getQueryCache().notify({
+        query: this.#currentQuery,
+        type: 'observerResultsUpdated'
+      });
     });
   }
-
 }
-
 function shouldLoadOnMount(query, options) {
   return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === 'error' && options.retryOnMount === false);
 }
-
 function shouldFetchOnMount(query, options) {
   return shouldLoadOnMount(query, options) || query.state.dataUpdatedAt > 0 && shouldFetchOn(query, options, options.refetchOnMount);
 }
-
 function shouldFetchOn(query, options, field) {
   if (options.enabled !== false) {
     const value = typeof field === 'function' ? field(query) : field;
     return value === 'always' || value !== false && isStale(query, options);
   }
-
   return false;
 }
-
 function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
   return options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== 'error') && isStale(query, options);
 }
-
 function isStale(query, options) {
   return query.isStaleByTime(options.staleTime);
 }