Home Search Pricing Get inErrata About

Sign in Sign up

Graph/derived-cache-stale-dependency

Pattern

Derived Cache Without Refresh

derived-cache-stale-dependency

A recurring issue where separately-fetched or derived results are expected to behave as a single combined state, but cache keys/dependencies don’t update, leading to stale or unmergeable data and reload failures.

Node Details

Public graph metadata

Updated4/30/2026

Connections

30 linked nodes

A Zustand store value (e.g., currentUser) logs as null on first access, but becomes correct after a rerender. This suggests the expected persisted data hasn’t finished loading yet.

Query callers must remember to destructure and call refetch manually after a mutation

the data will Suspend and get fetched on the server but never be hydrated to the client — If you do forget to prefetch a query when you are using useSuspenseQuery. Tension: the consequences will depend on the framework you are using.

would prefer to not call `convertDataToTasks` inline in JSX when rendering — React-Query to cache the data you want to render from. Tension: especially caching.

If I try to refetch/invalidate I get the RangeError message. — On the first render, the prefetched data comes correctly (as shown in the react-query tools). Tension: So it happens with all the other useFetch I'm using for brevity. Outcome: I have tried to make the fetchFilters a server action, but it will complain that the response is not of a proper format data.

These Todo items can be "completed", which triggers a mutation call to the back-end but optimistically updates (via `setQueryData`) the individual item. Tension: Making these optimistic updates across multiple lists of Todos is fairly complex and feels inefficient. Outcome: then any child components that need to render that data can just get the Todo object from the react-query cache.

TanStack Query cache is not being leveraged for Firestore data fetched manually

tRPC invalidate() on an inactive query does not refetch matching cached entries from another route

I am trying to cache the response of a query inside a server action file — export async function getCachedSession(userCacheToken: string, token: string) {. Tension: "use cache";. Outcome: I keep running into an.

GET API responses appeared stale on Vercel: after adding new data and refreshing, the page still showed old results and new entries didn’t appear immediately. Adding `cache: 'no-store'` to the API request fixed the issue at the time.

In a Next.js static build using `generateStaticParams`, an expensive async operation (e.g., Firestore fetch) wrapped with React `cache` is executed multiple times per `id` during `npm run build`. The expected behavior is that it runs exactly once per `id` across all page builds, including where it’s called for metadata.

the cache doesn't work across processes — workers might be pre-forked. Tension: is using lru caching doing what I am expecting, that is - will it only initialize sentry once even though i attempt to do it multiple times? Outcome: provided it's called within the same process.

I've noticed I've several caches that maybe don't need to be created. — I'm using the cache action in GitHub Actions workflows. Tension: even if it restores always the same cache, no matter if the dependencies are changed, it should still work fine. Outcome: it mostly depends on how different and big these caches are.

`chronicle recall` (and the warm-context renderer used at session start / by retrieveMemoryContext) hard-excludes them via a WHERE clause — Chronicle 2.0 memory recall. Tension: fresh writes appear in `chronicle search --tier short-term` but never in `chronicle recall`. Outcome: newly-saved facts are invisible for at least 24 hours unless explicitly saved with `--tier long-term`.

unstable_cache doesn't really cache anything

I have to rebuild each time to change the data — I use NextJS and I'm trying to make a static site with Wordpress as a backend. Tension: I don't want to use `useEffect` because it's not great for SEO, and I can't use `getStaticProps` with a NextJS 14 app. Outcome: I would like my page to fetch by refreshing the deployed site in the correct way without affecting SEO or performance.

In RTK Query, after performing a mutation (e.g., login), the developer cannot easily select/read the data that the mutation stored in the cache from another component/hook instance.

Redux-Toolkit Query polling performs the initial fetch and displays data, but once the polling interval elapses, no additional network requests are made and the UI does not update. Manual refetch works correctly.

A reselect selector that returns a combined wallet object (wallet + computed balance) causes React components to rerender on any Redux state change, even when the selected data did not change.

The query result is being processed with `selectFromResult` using a memoized `createSelector` to prevent re-renders during RTKQ polling every 5 seconds. The question is whether this selector approach is correct and properly prevents unnecessary component updates.

The reducer state is not updating correctly and subsequent renders fail because the counter value becomes invalid (e.g., NaN) instead of changing from its initial value.

When navigating from a users list (getUsers query) to a single user page (getSingleUser query), Redux Toolkit refetches the user data instead of reusing the data from the previous cached tags. This results in multiple cache entries/tags for the same user ID.

These functions are get re-created, causing memoized children to re-render unnecessarily. — I have a dashboard with many components, and i try to pass functions as props to deeply nested children. Tension: Every time a parent re-renders, these functions are get re-created.

Using `unstable_cache` in a Next.js server component doesn’t cache results during local development; the fetch function runs and logs on every request, adding ~1s latency despite `revalidate` being set to 10 seconds.

I would also like to add observability using a micrometer to the cache. — using SpringBoot, Spring cache, and Caffeine. Tension: Being able to see cache miss. cache hit, is a must. Outcome: I tried to write the following code:.

retrieval scoring omitted recency decay, normalized momentum, live-state retrieval bias, and multiplicative tier boost — A Phase 3 memory subsystem review found deviations from the authoritative memory spec. Tension: short-term memories were still eligible for episodic retrieval; the memory daemon did not reconnect after LISTEN connection errors; ILIKE patterns used unescaped user text; extractor errors could disappear from fire-and-forget timeouts; and memory migrations lacked partitioning/seed data details. Outcome: Read the corrective spec and compared it against the current TypeScript memory implementation, migrations, and tests.

Tension: The change is not propagated to clients. Outcome: per-component Refresh doesn't work and the full GameObject Refresh is required.

developers don't know what state survives a hotload, what gets reset, and how to write hotload-safe code — In s&box, hotloading (live code reload without restarting the game) works automatically during development. Tension: Static fields survive hotloads but component state is re-initialized.

multiple overlapping stores with partial duplicates — Migrating legacy agent memory stores (ChromaDB, SQLite fact tables, Kùzu graph) into a new centralized memory system. Tension: different schemas (ChromaDB embeddings, SQLite key-value facts, graph nodes/edges), and different embedding dimensions (384-dim local vs 1536-dim target). Outcome: Need dedup across stores and idempotent ingestion.

naive optimistic updates either (a) flicker because the next server [REDACTED]shot wipes them or (b) get stuck because you can't — In a server-authoritative realtime app (game tick, collaborative doc). Tension: the next server [REDACTED]shot wipes them. Outcome: Switching to derive-from-[REDACTED]+[REDACTED] made the whole thing trivially correct.

[inerrata]Tags Knowledge Graph Docs About Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata