Can you please explain this better to me? Is gcTime a way to avoid the getItem call?

[frederikhors]

I'm using the latest v5 version (which is AMAZING, thanks!) and the experimental_createPersister (it works amazingly too, thanks!).

In the docs there is this statement:

Garbage collecting a Query from memory does not affect the persisted data. That means Queries can be kept in memory for a shorter period of time to be more memory efficient. If they are used the next time, they will just be restored from the persistent storage again.

I have a (big) doubt: if I'm still in gcTime the below getItem() doesn't get called, right?

Is this the logic, right?

import {
  experimental_createPersister,
  type AsyncStorage,
} from "@tanstack/query-persist-client-core";
import { get, set, del, createStore, type UseStore } from "idb-keyval";

function newIdbStorage(idbStore: UseStore): AsyncStorage {
  return {
    getItem: async (key) => await get(key, idbStore),
    setItem: async (key, value) => await set(key, value, idbStore),
    removeItem: async (key) => await del(key, idbStore),
  };
}

export const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      gcTime: 1000 * 30, // 30 seconds
      persister: !browser
        ? undefined
        : experimental_createPersister({
            storage: newIdbStorage(createStore("db_name", "store_name")),
            maxAge: 1000 * 60 * 60 * 12, // 12 hours
          }),
    },
  },
});

[DamianOsipiuk]

This setup will work as follows:

• after queryFn run it will be persisted in idb
• if query becomes unused for less than 30s it will be still referenced from memory (idb will not be called)
• after all observers unmount (query becomes unused), it will be garbage collected after 30s, but persisted state remains unchanged
• after particular query becomes used again, it will be restored from idb, and then refetched in the background for updates.
• If query is unused and last fetch happend more than 12h ago, persisted state will be discarded, and next usage will go trough hard loading state.

This way you can keep your memory usage lower, since unused queries can be garbage collected, while still being stored in idb for example.