@tanstack/query-db-collection 1.0.29 → 1.0.31

package/dist/esm/query.js

@@ -3,6 +3,7 @@ import { deepEquals } from "@tanstack/db";
 import { QueryKeyRequiredError, QueryFnRequiredError, QueryClientRequiredError, GetKeyRequiredError } from "./errors.js";
 import { createWriteUtils } from "./manual-sync.js";
 import { serializeLoadSubsetOptions } from "./serialization.js";
+const QUERY_COLLECTION_GC_PREFIX = `queryCollection:gc:`;
 class QueryCollectionUtilsImpl {
   constructor(state, refetch, writeUtils) {
     this.state = state;
@@ -71,6 +72,7 @@ function queryCollectionOptions(config) {
     retry,
     retryDelay,
     staleTime,
+    persistedGcTime,
     getKey,
     onInsert,
     onUpdate,
@@ -79,6 +81,16 @@ function queryCollectionOptions(config) {
     ...baseCollectionConfig
   } = config;
   const syncMode = baseCollectionConfig.syncMode ?? `eager`;
+  const baseKey = typeof queryKey === `function` ? queryKey({}) : queryKey;
+  const validateQueryKeyPrefix = (key) => {
+    if (typeof queryKey !== `function`) return;
+    const isValidPrefix = key.length >= baseKey.length && baseKey.every((segment, i) => deepEquals(segment, key[i]));
+    if (!isValidPrefix) {
+      console.warn(
+        `[QueryCollection] queryKey function must return keys that extend the base key prefix. Base: ${JSON.stringify(baseKey)}, Got: ${JSON.stringify(key)}. This can cause stale cache issues.`
+      );
+    }
+  };
   if (!queryKey) {
     throw new QueryKeyRequiredError();
   }
@@ -120,8 +132,244 @@ function queryCollectionOptions(config) {
     return rowToQueriesSet.size === 0;
   };
   const internalSync = (params) => {
-    const { begin, write, commit, markReady, collection } = params;
+    const { begin, write, commit, markReady, collection, metadata } = params;
+    const persistedMetadata = metadata;
     let syncStarted = false;
+    let startupRetentionSettled = false;
+    const retainedQueriesPendingRevalidation = /* @__PURE__ */ new Set();
+    const effectivePersistedGcTimes = /* @__PURE__ */ new Map();
+    const persistedRetentionTimers = /* @__PURE__ */ new Map();
+    let persistedRetentionMaintenance = Promise.resolve();
+    const getRowMetadata = (rowKey) => {
+      return metadata?.row.get(rowKey) ?? collection._state.syncedMetadata.get(rowKey);
+    };
+    const getPersistedOwners = (rowKey) => {
+      const rowMetadata = getRowMetadata(rowKey);
+      const queryMetadata = rowMetadata?.queryCollection;
+      if (!queryMetadata || typeof queryMetadata !== `object`) {
+        return /* @__PURE__ */ new Set();
+      }
+      const owners = queryMetadata.owners;
+      if (!owners || typeof owners !== `object`) {
+        return /* @__PURE__ */ new Set();
+      }
+      return new Set(Object.keys(owners));
+    };
+    const setPersistedOwners = (rowKey, owners) => {
+      if (!metadata) {
+        return;
+      }
+      const currentMetadata = { ...getRowMetadata(rowKey) ?? {} };
+      if (owners.size === 0) {
+        delete currentMetadata.queryCollection;
+        if (Object.keys(currentMetadata).length === 0) {
+          metadata.row.delete(rowKey);
+        } else {
+          metadata.row.set(rowKey, currentMetadata);
+        }
+        return;
+      }
+      metadata.row.set(rowKey, {
+        ...currentMetadata,
+        queryCollection: {
+          owners: Object.fromEntries(
+            Array.from(owners.values()).map((owner) => [owner, true])
+          )
+        }
+      });
+    };
+    const parsePersistedQueryRetentionEntry = (value, expectedHash) => {
+      if (!value || typeof value !== `object`) {
+        return void 0;
+      }
+      const record = value;
+      if (record.queryHash !== expectedHash) {
+        return void 0;
+      }
+      if (record.mode === `until-revalidated`) {
+        return {
+          queryHash: expectedHash,
+          mode: `until-revalidated`
+        };
+      }
+      if (record.mode === `ttl` && typeof record.expiresAt === `number` && Number.isFinite(record.expiresAt)) {
+        return {
+          queryHash: expectedHash,
+          mode: `ttl`,
+          expiresAt: record.expiresAt
+        };
+      }
+      return void 0;
+    };
+    const runPersistedRetentionMaintenance = (task) => {
+      persistedRetentionMaintenance = persistedRetentionMaintenance.then(
+        task,
+        task
+      );
+      return persistedRetentionMaintenance;
+    };
+    const cancelPersistedRetentionExpiry = (hashedQueryKey) => {
+      const timer = persistedRetentionTimers.get(hashedQueryKey);
+      if (timer) {
+        clearTimeout(timer);
+        persistedRetentionTimers.delete(hashedQueryKey);
+      }
+    };
+    const getHydratedOwnedRowsForQueryBaseline = (hashedQueryKey) => {
+      const knownRows = queryToRows.get(hashedQueryKey);
+      if (knownRows) {
+        return new Set(knownRows);
+      }
+      const ownedRows = /* @__PURE__ */ new Set();
+      for (const [rowKey] of collection._state.syncedData.entries()) {
+        const owners = getPersistedOwners(rowKey);
+        if (owners.size === 0) {
+          continue;
+        }
+        rowToQueries.set(rowKey, new Set(owners));
+        owners.forEach((owner) => {
+          const queryToRowsSet = queryToRows.get(owner) || /* @__PURE__ */ new Set();
+          queryToRowsSet.add(rowKey);
+          queryToRows.set(owner, queryToRowsSet);
+        });
+        if (owners.has(hashedQueryKey)) {
+          ownedRows.add(rowKey);
+        }
+      }
+      return ownedRows;
+    };
+    const loadPersistedBaselineForQuery = async (hashedQueryKey) => {
+      const knownRows = queryToRows.get(hashedQueryKey);
+      if (knownRows && Array.from(knownRows).every((rowKey) => collection.has(rowKey))) {
+        const baseline2 = /* @__PURE__ */ new Map();
+        knownRows.forEach((rowKey) => {
+          const value = collection.get(rowKey);
+          const owners = rowToQueries.get(rowKey);
+          if (value && owners) {
+            baseline2.set(rowKey, {
+              value,
+              owners: new Set(owners)
+            });
+          }
+        });
+        return baseline2;
+      }
+      const scanPersisted = persistedMetadata?.row.scanPersisted;
+      if (!scanPersisted) {
+        const baseline2 = /* @__PURE__ */ new Map();
+        getHydratedOwnedRowsForQueryBaseline(hashedQueryKey).forEach(
+          (rowKey) => {
+            const value = collection.get(rowKey);
+            const owners = rowToQueries.get(rowKey);
+            if (value && owners) {
+              baseline2.set(rowKey, {
+                value,
+                owners: new Set(owners)
+              });
+            }
+          }
+        );
+        return baseline2;
+      }
+      const baseline = /* @__PURE__ */ new Map();
+      const scannedRows = await scanPersisted();
+      scannedRows.forEach((row) => {
+        const rowMetadata = row.metadata;
+        const queryMetadata = rowMetadata?.queryCollection;
+        if (!queryMetadata || typeof queryMetadata !== `object`) {
+          return;
+        }
+        const owners = queryMetadata.owners;
+        if (!owners || typeof owners !== `object`) {
+          return;
+        }
+        const ownerSet = new Set(Object.keys(owners));
+        if (ownerSet.size === 0) {
+          return;
+        }
+        rowToQueries.set(row.key, new Set(ownerSet));
+        ownerSet.forEach((owner) => {
+          const queryToRowsSet = queryToRows.get(owner) || /* @__PURE__ */ new Set();
+          queryToRowsSet.add(row.key);
+          queryToRows.set(owner, queryToRowsSet);
+        });
+        if (ownerSet.has(hashedQueryKey)) {
+          baseline.set(row.key, {
+            value: row.value,
+            owners: ownerSet
+          });
+        }
+      });
+      return baseline;
+    };
+    const cleanupPersistedPlaceholder = async (hashedQueryKey) => {
+      if (!metadata) {
+        return;
+      }
+      const baseline = await loadPersistedBaselineForQuery(hashedQueryKey);
+      const rowsToDelete = [];
+      begin();
+      baseline.forEach(({ value: oldItem, owners }, rowKey) => {
+        owners.delete(hashedQueryKey);
+        setPersistedOwners(rowKey, owners);
+        const needToRemove = removeRow(rowKey, hashedQueryKey);
+        if (needToRemove) {
+          rowsToDelete.push(oldItem);
+        }
+      });
+      rowsToDelete.forEach((row) => {
+        write({ type: `delete`, value: row });
+      });
+      metadata.collection.delete(
+        `${QUERY_COLLECTION_GC_PREFIX}${hashedQueryKey}`
+      );
+      commit();
+    };
+    const schedulePersistedRetentionExpiry = (entry) => {
+      if (entry.mode !== `ttl`) {
+        return;
+      }
+      cancelPersistedRetentionExpiry(entry.queryHash);
+      const delay = Math.max(0, entry.expiresAt - Date.now());
+      const timer = setTimeout(() => {
+        persistedRetentionTimers.delete(entry.queryHash);
+        void runPersistedRetentionMaintenance(async () => {
+          const currentEntry = metadata?.collection.get(
+            `${QUERY_COLLECTION_GC_PREFIX}${entry.queryHash}`
+          );
+          const parsedCurrentEntry = parsePersistedQueryRetentionEntry(
+            currentEntry,
+            entry.queryHash
+          );
+          if (!parsedCurrentEntry || parsedCurrentEntry.mode !== `ttl` || parsedCurrentEntry.expiresAt > Date.now()) {
+            return;
+          }
+          await cleanupPersistedPlaceholder(entry.queryHash);
+        });
+      }, delay);
+      persistedRetentionTimers.set(entry.queryHash, timer);
+    };
+    const consumePersistedQueryRetentionAtStartup = async () => {
+      if (!metadata) {
+        return;
+      }
+      const retentionEntries = metadata.collection.list(
+        QUERY_COLLECTION_GC_PREFIX
+      );
+      const now = Date.now();
+      for (const { key, value } of retentionEntries) {
+        const hashedQueryKey = key.slice(QUERY_COLLECTION_GC_PREFIX.length);
+        const parsed = parsePersistedQueryRetentionEntry(value, hashedQueryKey);
+        if (!parsed) {
+          continue;
+        }
+        if (parsed.mode === `ttl` && parsed.expiresAt <= now) {
+          await cleanupPersistedPlaceholder(parsed.queryHash);
+        } else if (parsed.mode === `ttl`) {
+          schedulePersistedRetentionExpiry(parsed);
+        }
+      }
+    };
     const generateQueryKeyFromOptions = (opts) => {
       if (typeof queryKey === `function`) {
         return queryKey(opts);
@@ -132,10 +380,37 @@ function queryCollectionOptions(config) {
         return queryKey;
       }
     };
+    const startupRetentionEntries = metadata?.collection.list(
+      QUERY_COLLECTION_GC_PREFIX
+    );
+    const startupRetentionMaintenancePromise = !startupRetentionEntries || startupRetentionEntries.length === 0 ? (() => {
+      startupRetentionSettled = true;
+      return Promise.resolve();
+    })() : runPersistedRetentionMaintenance(async () => {
+      try {
+        await consumePersistedQueryRetentionAtStartup();
+      } finally {
+        startupRetentionSettled = true;
+      }
+    });
     const createQueryFromOpts = (opts = {}, queryFunction = queryFn) => {
+      if (!startupRetentionSettled) {
+        return startupRetentionMaintenancePromise.then(() => {
+          const resumed = createQueryFromOpts(opts, queryFunction);
+          return resumed === true ? void 0 : resumed;
+        });
+      }
       const key = generateQueryKeyFromOptions(opts);
       const hashedQueryKey = hashKey(key);
       const extendedMeta = { ...meta, loadSubsetOptions: opts };
+      const retainedEntry = metadata?.collection.get(
+        `${QUERY_COLLECTION_GC_PREFIX}${hashedQueryKey}`
+      );
+      if (parsePersistedQueryRetentionEntry(retainedEntry, hashedQueryKey) !== void 0) {
+        retainedQueriesPendingRevalidation.add(hashedQueryKey);
+      }
+      cancelPersistedRetentionExpiry(hashedQueryKey);
+      validateQueryKeyPrefix(key);
       if (state.observers.has(hashedQueryKey)) {
         queryRefCounts.set(
           hashedQueryKey,
@@ -181,8 +456,18 @@ function queryCollectionOptions(config) {
         ...staleTime !== void 0 && { staleTime }
       };
       const localObserver = new QueryObserver(queryClient, observerOptions);
+      const resolvedQueryGcTime = queryClient.getQueryCache().find({
+        queryKey: key,
+        exact: true
+      })?.gcTime;
+      const effectivePersistedGcTime = persistedGcTime ?? resolvedQueryGcTime;
       hashToQueryKey.set(hashedQueryKey, key);
       state.observers.set(hashedQueryKey, localObserver);
+      if (effectivePersistedGcTime !== void 0) {
+        effectivePersistedGcTimes.set(hashedQueryKey, effectivePersistedGcTime);
+      } else {
+        effectivePersistedGcTimes.delete(hashedQueryKey);
+      }
       queryRefCounts.set(
         hashedQueryKey,
         (queryRefCounts.get(hashedQueryKey) || 0) + 1
@@ -212,47 +497,102 @@ function queryCollectionOptions(config) {
       }
       return readyPromise;
     };
+    const applySuccessfulResult = (queryKey2, result, persistedBaseline) => {
+      const hashedQueryKey = hashKey(queryKey2);
+      if (collection.status === `cleaned-up`) {
+        return;
+      }
+      state.lastError = void 0;
+      state.errorCount = 0;
+      const rawData = result.data;
+      const newItemsArray = select ? select(rawData) : rawData;
+      if (!Array.isArray(newItemsArray) || newItemsArray.some((item) => typeof item !== `object`)) {
+        const errorMessage = select ? `@tanstack/query-db-collection: select() must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey2)}` : `@tanstack/query-db-collection: queryFn must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey2)}`;
+        console.error(errorMessage);
+        return;
+      }
+      const currentSyncedItems = new Map(
+        collection._state.syncedData.entries()
+      );
+      const shouldUsePersistedBaseline = persistedBaseline !== void 0;
+      const previouslyOwnedRows = shouldUsePersistedBaseline ? new Set(persistedBaseline.keys()) : getHydratedOwnedRowsForQueryBaseline(hashedQueryKey);
+      const newItemsMap = /* @__PURE__ */ new Map();
+      newItemsArray.forEach((item) => {
+        const key = getKey(item);
+        newItemsMap.set(key, item);
+      });
+      begin();
+      if (metadata) {
+        metadata.collection.delete(
+          `${QUERY_COLLECTION_GC_PREFIX}${hashedQueryKey}`
+        );
+      }
+      previouslyOwnedRows.forEach((key) => {
+        const oldItem = shouldUsePersistedBaseline ? persistedBaseline.get(key)?.value : currentSyncedItems.get(key);
+        if (!oldItem) {
+          return;
+        }
+        const newItem = newItemsMap.get(key);
+        if (!newItem) {
+          const owners = getPersistedOwners(key);
+          owners.delete(hashedQueryKey);
+          setPersistedOwners(key, owners);
+          const needToRemove = removeRow(key, hashedQueryKey);
+          if (needToRemove) {
+            write({ type: `delete`, value: oldItem });
+          }
+        } else if (!deepEquals(oldItem, newItem)) {
+          write({ type: `update`, value: newItem });
+        }
+      });
+      newItemsMap.forEach((newItem, key) => {
+        const owners = getPersistedOwners(key);
+        if (!owners.has(hashedQueryKey)) {
+          owners.add(hashedQueryKey);
+          setPersistedOwners(key, owners);
+        }
+        addRow(key, hashedQueryKey);
+        if (!currentSyncedItems.has(key)) {
+          write({ type: `insert`, value: newItem });
+        }
+      });
+      commit();
+      retainedQueriesPendingRevalidation.delete(hashedQueryKey);
+      cancelPersistedRetentionExpiry(hashedQueryKey);
+      markReady();
+    };
+    const reconcileSuccessfulResult = async (queryKey2, result) => {
+      const hashedQueryKey = hashKey(queryKey2);
+      const persistedBaseline = await loadPersistedBaselineForQuery(hashedQueryKey);
+      if (collection.status === `cleaned-up`) {
+        return;
+      }
+      applySuccessfulResult(queryKey2, result, persistedBaseline);
+    };
     const makeQueryResultHandler = (queryKey2) => {
       const hashedQueryKey = hashKey(queryKey2);
       const handleQueryResult = (result) => {
         if (result.isSuccess) {
-          state.lastError = void 0;
-          state.errorCount = 0;
-          const rawData = result.data;
-          const newItemsArray = select ? select(rawData) : rawData;
-          if (!Array.isArray(newItemsArray) || newItemsArray.some((item) => typeof item !== `object`)) {
-            const errorMessage = select ? `@tanstack/query-db-collection: select() must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey2)}` : `@tanstack/query-db-collection: queryFn must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey2)}`;
-            console.error(errorMessage);
+          if (collection.deferDataRefresh) {
+            collection.deferDataRefresh.then(() => {
+              const observer = state.observers.get(hashedQueryKey);
+              if (observer) {
+                observer.refetch().catch(() => {
+                });
+              }
+            });
             return;
           }
-          const currentSyncedItems = new Map(
-            collection._state.syncedData.entries()
-          );
-          const newItemsMap = /* @__PURE__ */ new Map();
-          newItemsArray.forEach((item) => {
-            const key = getKey(item);
-            newItemsMap.set(key, item);
-          });
-          begin();
-          currentSyncedItems.forEach((oldItem, key) => {
-            const newItem = newItemsMap.get(key);
-            if (!newItem) {
-              const needToRemove = removeRow(key, hashedQueryKey);
-              if (needToRemove) {
-                write({ type: `delete`, value: oldItem });
-              }
-            } else if (!deepEquals(oldItem, newItem)) {
-              write({ type: `update`, value: newItem });
-            }
-          });
-          newItemsMap.forEach((newItem, key) => {
-            addRow(key, hashedQueryKey);
-            if (!currentSyncedItems.has(key)) {
-              write({ type: `insert`, value: newItem });
-            }
-          });
-          commit();
-          markReady();
+          if (retainedQueriesPendingRevalidation.has(hashedQueryKey)) {
+            void reconcileSuccessfulResult(queryKey2, result).catch((error) => {
+              console.error(
+                `[QueryCollection] Error reconciling query ${String(queryKey2)}:`,
+                error
+              );
+            });
+          } else {
+            applySuccessfulResult(queryKey2, result);
+          }
         } else if (result.isError) {
           const isNewError = result.errorUpdatedAt !== state.lastErrorUpdatedAt || result.error !== state.lastError;
           if (isNewError) {
@@ -311,7 +651,13 @@ function queryCollectionOptions(config) {
         });
       }
     } else {
-      markReady();
+      if (startupRetentionSettled) {
+        markReady();
+      } else {
+        void startupRetentionMaintenancePromise.then(() => {
+          markReady();
+        });
+      }
     }
     subscribeToQueries();
     state.observers.forEach((observer, hashedQueryKey) => {
@@ -322,36 +668,56 @@ function queryCollectionOptions(config) {
     const cleanupQueryInternal = (hashedQueryKey) => {
       unsubscribes.get(hashedQueryKey)?.();
       unsubscribes.delete(hashedQueryKey);
+      cancelPersistedRetentionExpiry(hashedQueryKey);
+      retainedQueriesPendingRevalidation.delete(hashedQueryKey);
       const rowKeys = queryToRows.get(hashedQueryKey) ?? /* @__PURE__ */ new Set();
+      const nextOwnersByRow = /* @__PURE__ */ new Map();
       const rowsToDelete = [];
       rowKeys.forEach((rowKey) => {
         const queries = rowToQueries.get(rowKey);
         if (!queries) {
           return;
         }
-        queries.delete(hashedQueryKey);
-        if (queries.size === 0) {
+        const nextOwners = new Set(queries);
+        nextOwners.delete(hashedQueryKey);
+        nextOwnersByRow.set(rowKey, nextOwners);
+        if (nextOwners.size === 0 && collection.has(rowKey)) {
+          rowsToDelete.push(collection.get(rowKey));
+        }
+      });
+      const shouldWriteMetadata = metadata !== void 0 && nextOwnersByRow.size > 0;
+      const needsTransaction = shouldWriteMetadata || rowsToDelete.length > 0;
+      if (needsTransaction) {
+        begin();
+      }
+      nextOwnersByRow.forEach((owners, rowKey) => {
+        if (owners.size === 0) {
           rowToQueries.delete(rowKey);
-          if (collection.has(rowKey)) {
-            rowsToDelete.push(collection.get(rowKey));
-          }
+        } else {
+          rowToQueries.set(rowKey, owners);
+        }
+        if (shouldWriteMetadata) {
+          setPersistedOwners(rowKey, owners);
         }
       });
       if (rowsToDelete.length > 0) {
-        begin();
         rowsToDelete.forEach((row) => {
           write({ type: `delete`, value: row });
         });
+      }
+      if (needsTransaction) {
         commit();
       }
       state.observers.delete(hashedQueryKey);
       queryToRows.delete(hashedQueryKey);
       hashToQueryKey.delete(hashedQueryKey);
       queryRefCounts.delete(hashedQueryKey);
+      effectivePersistedGcTimes.delete(hashedQueryKey);
     };
     const cleanupQueryIfIdle = (hashedQueryKey) => {
       const refcount = queryRefCounts.get(hashedQueryKey) || 0;
       const observer = state.observers.get(hashedQueryKey);
+      const effectivePersistedGcTime = effectivePersistedGcTimes.get(hashedQueryKey);
       if (refcount <= 0) {
         unsubscribes.get(hashedQueryKey)?.();
         unsubscribes.delete(hashedQueryKey);
@@ -367,6 +733,31 @@ function queryCollectionOptions(config) {
           { hashedQueryKey }
         );
       }
+      if (effectivePersistedGcTime !== void 0 && metadata && persistedMetadata?.row.scanPersisted) {
+        begin();
+        metadata.collection.set(
+          `${QUERY_COLLECTION_GC_PREFIX}${hashedQueryKey}`,
+          {
+            queryHash: hashedQueryKey,
+            mode: effectivePersistedGcTime === Number.POSITIVE_INFINITY ? `until-revalidated` : `ttl`,
+            ...effectivePersistedGcTime === Number.POSITIVE_INFINITY ? {} : { expiresAt: Date.now() + effectivePersistedGcTime }
+          }
+        );
+        commit();
+        if (effectivePersistedGcTime !== Number.POSITIVE_INFINITY) {
+          schedulePersistedRetentionExpiry({
+            queryHash: hashedQueryKey,
+            mode: `ttl`,
+            expiresAt: Date.now() + effectivePersistedGcTime
+          });
+        }
+        unsubscribes.get(hashedQueryKey)?.();
+        unsubscribes.delete(hashedQueryKey);
+        state.observers.delete(hashedQueryKey);
+        hashToQueryKey.delete(hashedQueryKey);
+        queryRefCounts.set(hashedQueryKey, 0);
+        return;
+      }
       cleanupQueryInternal(hashedQueryKey);
     };
     const forceCleanupQuery = (hashedQueryKey) => {
@@ -383,6 +774,10 @@ function queryCollectionOptions(config) {
     const cleanup = async () => {
       unsubscribeFromCollectionEvents();
       unsubscribeFromQueries();
+      persistedRetentionTimers.forEach((timer) => {
+        clearTimeout(timer);
+      });
+      persistedRetentionTimers.clear();
       const allQueryKeys = [...hashToQueryKey.values()];
       const allHashedKeys = [...state.observers.keys()];
       for (const hashedKey of allHashedKeys) {
@@ -463,13 +858,12 @@ function queryCollectionOptions(config) {
     }
   };
   const updateCacheData = (items) => {
-    const activeQueryKeys = Array.from(hashToQueryKey.values());
-    if (activeQueryKeys.length > 0) {
-      for (const key of activeQueryKeys) {
-        updateCacheDataForKey(key, items);
+    const allCached = queryClient.getQueryCache().findAll({ queryKey: baseKey });
+    if (allCached.length > 0) {
+      for (const query of allCached) {
+        updateCacheDataForKey(query.queryKey, items);
       }
     } else {
-      const baseKey = typeof queryKey === `function` ? queryKey({}) : queryKey;
       updateCacheDataForKey(baseKey, items);
     }
   };