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

package/build/lib/queryClient.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var utils = require('./utils.js');
 var queryCache = require('./queryCache.js');
 var mutationCache = require('./mutationCache.js');
@@ -9,78 +7,73 @@ var focusManager = require('./focusManager.js');
 var onlineManager = require('./onlineManager.js');
 var notifyManager = require('./notifyManager.js');
 var infiniteQueryBehavior = require('./infiniteQueryBehavior.js');
-var logger = require('./logger');
 
 // CLASS
+
 class QueryClient {
+  #queryCache;
+  #mutationCache;
+  #defaultOptions;
+  #queryDefaults;
+  #mutationDefaults;
+  #mountCount;
+  #unsubscribeFocus;
+  #unsubscribeOnline;
   constructor(config = {}) {
-    this.queryCache = config.queryCache || new queryCache.QueryCache();
-    this.mutationCache = config.mutationCache || new mutationCache.MutationCache();
-    this.logger = config.logger || logger.defaultLogger;
-    this.defaultOptions = config.defaultOptions || {};
-    this.queryDefaults = [];
-    this.mutationDefaults = [];
-    this.mountCount = 0;
-
-    if (process.env.NODE_ENV !== 'production' && config.logger) {
-      this.logger.error("Passing a custom logger has been deprecated and will be removed in the next major version.");
-    }
+    this.#queryCache = config.queryCache || new queryCache.QueryCache();
+    this.#mutationCache = config.mutationCache || new mutationCache.MutationCache();
+    this.#defaultOptions = config.defaultOptions || {};
+    this.#queryDefaults = new Map();
+    this.#mutationDefaults = new Map();
+    this.#mountCount = 0;
   }
-
   mount() {
-    this.mountCount++;
-    if (this.mountCount !== 1) return;
-    this.unsubscribeFocus = focusManager.focusManager.subscribe(() => {
+    this.#mountCount++;
+    if (this.#mountCount !== 1) return;
+    this.#unsubscribeFocus = focusManager.focusManager.subscribe(() => {
       if (focusManager.focusManager.isFocused()) {
         this.resumePausedMutations();
-        this.queryCache.onFocus();
+        this.#queryCache.onFocus();
       }
     });
-    this.unsubscribeOnline = onlineManager.onlineManager.subscribe(() => {
+    this.#unsubscribeOnline = onlineManager.onlineManager.subscribe(() => {
       if (onlineManager.onlineManager.isOnline()) {
         this.resumePausedMutations();
-        this.queryCache.onOnline();
+        this.#queryCache.onOnline();
       }
     });
   }
-
   unmount() {
-    var _this$unsubscribeFocu, _this$unsubscribeOnli;
-
-    this.mountCount--;
-    if (this.mountCount !== 0) return;
-    (_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);
-    this.unsubscribeFocus = undefined;
-    (_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);
-    this.unsubscribeOnline = undefined;
-  }
-
-  isFetching(arg1, arg2) {
-    const [filters] = utils.parseFilterArgs(arg1, arg2);
-    filters.fetchStatus = 'fetching';
-    return this.queryCache.findAll(filters).length;
+    this.#mountCount--;
+    if (this.#mountCount !== 0) return;
+    this.#unsubscribeFocus?.();
+    this.#unsubscribeFocus = undefined;
+    this.#unsubscribeOnline?.();
+    this.#unsubscribeOnline = undefined;
+  }
+  isFetching(filters) {
+    return this.#queryCache.findAll({
+      ...filters,
+      fetchStatus: 'fetching'
+    }).length;
   }
-
   isMutating(filters) {
-    return this.mutationCache.findAll({ ...filters,
-      fetching: true
+    return this.#mutationCache.findAll({
+      ...filters,
+      status: 'pending'
     }).length;
   }
-
-  getQueryData(queryKey, filters) {
-    var _this$queryCache$find;
-
-    return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;
+  getQueryData(queryKey) {
+    return this.#queryCache.find({
+      queryKey
+    })?.state.data;
   }
-
-  ensureQueryData(arg1, arg2, arg3) {
-    const parsedOptions = utils.parseQueryArgs(arg1, arg2, arg3);
-    const cachedData = this.getQueryData(parsedOptions.queryKey);
-    return cachedData ? Promise.resolve(cachedData) : this.fetchQuery(parsedOptions);
+  ensureQueryData(options) {
+    const cachedData = this.getQueryData(options.queryKey);
+    return cachedData ? Promise.resolve(cachedData) : this.fetchQuery(options);
   }
-
-  getQueriesData(queryKeyOrFilters) {
-    return this.getQueryCache().findAll(queryKeyOrFilters).map(({
+  getQueriesData(filters) {
+    return this.getQueryCache().findAll(filters).map(({
       queryKey,
       state
     }) => {
@@ -88,48 +81,43 @@ class QueryClient {
       return [queryKey, data];
     });
   }
-
   setQueryData(queryKey, updater, options) {
-    const query = this.queryCache.find(queryKey);
-    const prevData = query == null ? void 0 : query.state.data;
+    const query = this.#queryCache.find({
+      queryKey
+    });
+    const prevData = query?.state.data;
     const data = utils.functionalUpdate(updater, prevData);
-
     if (typeof data === 'undefined') {
       return undefined;
     }
-
-    const parsedOptions = utils.parseQueryArgs(queryKey);
-    const defaultedOptions = this.defaultQueryOptions(parsedOptions);
-    return this.queryCache.build(this, defaultedOptions).setData(data, { ...options,
+    const defaultedOptions = this.defaultQueryOptions({
+      queryKey
+    });
+    return this.#queryCache.build(this, defaultedOptions).setData(data, {
+      ...options,
       manual: true
     });
   }
-
-  setQueriesData(queryKeyOrFilters, updater, options) {
-    return notifyManager.notifyManager.batch(() => this.getQueryCache().findAll(queryKeyOrFilters).map(({
+  setQueriesData(filters, updater, options) {
+    return notifyManager.notifyManager.batch(() => this.getQueryCache().findAll(filters).map(({
       queryKey
     }) => [queryKey, this.setQueryData(queryKey, updater, options)]));
   }
-
-  getQueryState(queryKey, filters) {
-    var _this$queryCache$find2;
-
-    return (_this$queryCache$find2 = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find2.state;
+  getQueryState(queryKey) {
+    return this.#queryCache.find({
+      queryKey
+    })?.state;
   }
-
-  removeQueries(arg1, arg2) {
-    const [filters] = utils.parseFilterArgs(arg1, arg2);
-    const queryCache = this.queryCache;
+  removeQueries(filters) {
+    const queryCache = this.#queryCache;
     notifyManager.notifyManager.batch(() => {
       queryCache.findAll(filters).forEach(query => {
         queryCache.remove(query);
       });
     });
   }
-
-  resetQueries(arg1, arg2, arg3) {
-    const [filters, options] = utils.parseFilterArgs(arg1, arg2, arg3);
-    const queryCache = this.queryCache;
+  resetQueries(filters, options) {
+    const queryCache = this.#queryCache;
     const refetchFilters = {
       type: 'active',
       ...filters
@@ -141,219 +129,150 @@ class QueryClient {
       return this.refetchQueries(refetchFilters, options);
     });
   }
-
-  cancelQueries(arg1, arg2, arg3) {
-    const [filters, cancelOptions = {}] = utils.parseFilterArgs(arg1, arg2, arg3);
-
+  cancelQueries(filters = {}, cancelOptions = {}) {
     if (typeof cancelOptions.revert === 'undefined') {
       cancelOptions.revert = true;
     }
-
-    const promises = notifyManager.notifyManager.batch(() => this.queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
+    const promises = notifyManager.notifyManager.batch(() => this.#queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
     return Promise.all(promises).then(utils.noop).catch(utils.noop);
   }
-
-  invalidateQueries(arg1, arg2, arg3) {
-    const [filters, options] = utils.parseFilterArgs(arg1, arg2, arg3);
+  invalidateQueries(filters = {}, options = {}) {
     return notifyManager.notifyManager.batch(() => {
-      var _ref, _filters$refetchType;
-
-      this.queryCache.findAll(filters).forEach(query => {
+      this.#queryCache.findAll(filters).forEach(query => {
         query.invalidate();
       });
-
       if (filters.refetchType === 'none') {
         return Promise.resolve();
       }
-
-      const refetchFilters = { ...filters,
-        type: (_ref = (_filters$refetchType = filters.refetchType) != null ? _filters$refetchType : filters.type) != null ? _ref : 'active'
+      const refetchFilters = {
+        ...filters,
+        type: filters.refetchType ?? filters.type ?? 'active'
       };
       return this.refetchQueries(refetchFilters, options);
     });
   }
-
-  refetchQueries(arg1, arg2, arg3) {
-    const [filters, options] = utils.parseFilterArgs(arg1, arg2, arg3);
-    const promises = notifyManager.notifyManager.batch(() => this.queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {
-      var _options$cancelRefetc;
-
-      return query.fetch(undefined, { ...options,
-        cancelRefetch: (_options$cancelRefetc = options == null ? void 0 : options.cancelRefetch) != null ? _options$cancelRefetc : true,
-        meta: {
-          refetchPage: filters.refetchPage
-        }
-      });
-    }));
+  refetchQueries(filters = {}, options) {
+    const promises = notifyManager.notifyManager.batch(() => this.#queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => query.fetch(undefined, {
+      ...options,
+      cancelRefetch: options?.cancelRefetch ?? true
+    })));
     let promise = Promise.all(promises).then(utils.noop);
-
-    if (!(options != null && options.throwOnError)) {
+    if (!options?.throwOnError) {
       promise = promise.catch(utils.noop);
     }
-
     return promise;
   }
+  fetchQuery(options) {
+    const defaultedOptions = this.defaultQueryOptions(options);
 
-  fetchQuery(arg1, arg2, arg3) {
-    const parsedOptions = utils.parseQueryArgs(arg1, arg2, arg3);
-    const defaultedOptions = this.defaultQueryOptions(parsedOptions); // https://github.com/tannerlinsley/react-query/issues/652
-
+    // https://github.com/tannerlinsley/react-query/issues/652
     if (typeof defaultedOptions.retry === 'undefined') {
       defaultedOptions.retry = false;
     }
-
-    const query = this.queryCache.build(this, defaultedOptions);
+    const query = this.#queryCache.build(this, defaultedOptions);
     return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
   }
-
-  prefetchQuery(arg1, arg2, arg3) {
-    return this.fetchQuery(arg1, arg2, arg3).then(utils.noop).catch(utils.noop);
+  prefetchQuery(options) {
+    return this.fetchQuery(options).then(utils.noop).catch(utils.noop);
   }
-
-  fetchInfiniteQuery(arg1, arg2, arg3) {
-    const parsedOptions = utils.parseQueryArgs(arg1, arg2, arg3);
-    parsedOptions.behavior = infiniteQueryBehavior.infiniteQueryBehavior();
-    return this.fetchQuery(parsedOptions);
+  fetchInfiniteQuery(options) {
+    options.behavior = infiniteQueryBehavior.infiniteQueryBehavior();
+    return this.fetchQuery(options);
   }
-
-  prefetchInfiniteQuery(arg1, arg2, arg3) {
-    return this.fetchInfiniteQuery(arg1, arg2, arg3).then(utils.noop).catch(utils.noop);
+  prefetchInfiniteQuery(options) {
+    return this.fetchInfiniteQuery(options).then(utils.noop).catch(utils.noop);
   }
-
   resumePausedMutations() {
-    return this.mutationCache.resumePausedMutations();
+    return this.#mutationCache.resumePausedMutations();
   }
-
   getQueryCache() {
-    return this.queryCache;
+    return this.#queryCache;
   }
-
   getMutationCache() {
-    return this.mutationCache;
+    return this.#mutationCache;
   }
-
-  getLogger() {
-    return this.logger;
-  }
-
   getDefaultOptions() {
-    return this.defaultOptions;
+    return this.#defaultOptions;
   }
-
   setDefaultOptions(options) {
-    this.defaultOptions = options;
+    this.#defaultOptions = options;
   }
-
   setQueryDefaults(queryKey, options) {
-    const result = this.queryDefaults.find(x => utils.hashQueryKey(queryKey) === utils.hashQueryKey(x.queryKey));
-
-    if (result) {
-      result.defaultOptions = options;
-    } else {
-      this.queryDefaults.push({
-        queryKey,
-        defaultOptions: options
-      });
-    }
+    this.#queryDefaults.set(utils.hashKey(queryKey), {
+      queryKey,
+      defaultOptions: options
+    });
   }
-
   getQueryDefaults(queryKey) {
-    if (!queryKey) {
-      return undefined;
-    } // Get the first matching defaults
-
-
-    const firstMatchingDefaults = this.queryDefaults.find(x => utils.partialMatchKey(queryKey, x.queryKey)); // Additional checks and error in dev mode
-
-    if (process.env.NODE_ENV !== 'production') {
-      // Retrieve all matching defaults for the given key
-      const matchingDefaults = this.queryDefaults.filter(x => utils.partialMatchKey(queryKey, x.queryKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key
-
-      if (matchingDefaults.length > 1) {
-        this.logger.error("[QueryClient] Several query defaults match with key '" + JSON.stringify(queryKey) + "'. The first matching query defaults are used. Please check how query defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetquerydefaults.");
+    const defaults = [...this.#queryDefaults.values()];
+    let result = {};
+    defaults.forEach(queryDefault => {
+      if (utils.partialMatchKey(queryKey, queryDefault.queryKey)) {
+        result = {
+          ...result,
+          ...queryDefault.defaultOptions
+        };
       }
-    }
-
-    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
+    });
+    return result;
   }
-
   setMutationDefaults(mutationKey, options) {
-    const result = this.mutationDefaults.find(x => utils.hashQueryKey(mutationKey) === utils.hashQueryKey(x.mutationKey));
-
-    if (result) {
-      result.defaultOptions = options;
-    } else {
-      this.mutationDefaults.push({
-        mutationKey,
-        defaultOptions: options
-      });
-    }
+    this.#mutationDefaults.set(utils.hashKey(mutationKey), {
+      mutationKey,
+      defaultOptions: options
+    });
   }
-
   getMutationDefaults(mutationKey) {
-    if (!mutationKey) {
-      return undefined;
-    } // Get the first matching defaults
-
-
-    const firstMatchingDefaults = this.mutationDefaults.find(x => utils.partialMatchKey(mutationKey, x.mutationKey)); // Additional checks and error in dev mode
-
-    if (process.env.NODE_ENV !== 'production') {
-      // Retrieve all matching defaults for the given key
-      const matchingDefaults = this.mutationDefaults.filter(x => utils.partialMatchKey(mutationKey, x.mutationKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key
-
-      if (matchingDefaults.length > 1) {
-        this.logger.error("[QueryClient] Several mutation defaults match with key '" + JSON.stringify(mutationKey) + "'. The first matching mutation defaults are used. Please check how mutation defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetmutationdefaults.");
+    const defaults = [...this.#mutationDefaults.values()];
+    let result = {};
+    defaults.forEach(queryDefault => {
+      if (utils.partialMatchKey(mutationKey, queryDefault.mutationKey)) {
+        result = {
+          ...result,
+          ...queryDefault.defaultOptions
+        };
       }
-    }
-
-    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
+    });
+    return result;
   }
-
   defaultQueryOptions(options) {
-    if (options != null && options._defaulted) {
+    if (options?._defaulted) {
       return options;
     }
-
-    const defaultedOptions = { ...this.defaultOptions.queries,
-      ...this.getQueryDefaults(options == null ? void 0 : options.queryKey),
+    const defaultedOptions = {
+      ...this.#defaultOptions.queries,
+      ...(options?.queryKey && this.getQueryDefaults(options.queryKey)),
       ...options,
       _defaulted: true
     };
-
-    if (!defaultedOptions.queryHash && defaultedOptions.queryKey) {
+    if (!defaultedOptions.queryHash) {
       defaultedOptions.queryHash = utils.hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);
-    } // dependent default values
-
+    }
 
+    // dependent default values
     if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {
       defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';
     }
-
-    if (typeof defaultedOptions.useErrorBoundary === 'undefined') {
-      defaultedOptions.useErrorBoundary = !!defaultedOptions.suspense;
+    if (typeof defaultedOptions.throwErrors === 'undefined') {
+      defaultedOptions.throwErrors = !!defaultedOptions.suspense;
     }
-
     return defaultedOptions;
   }
-
   defaultMutationOptions(options) {
-    if (options != null && options._defaulted) {
+    if (options?._defaulted) {
       return options;
     }
-
-    return { ...this.defaultOptions.mutations,
-      ...this.getMutationDefaults(options == null ? void 0 : options.mutationKey),
+    return {
+      ...this.#defaultOptions.mutations,
+      ...(options?.mutationKey && this.getMutationDefaults(options.mutationKey)),
       ...options,
       _defaulted: true
     };
   }
-
   clear() {
-    this.queryCache.clear();
-    this.mutationCache.clear();
+    this.#queryCache.clear();
+    this.#mutationCache.clear();
   }
-
 }
 
 exports.QueryClient = QueryClient;