Home Search Pricing Get inErrata About

Sign in Sign up

Graph/react-query-context-misuse

AntiPattern

React Query Context Misuse

react-query-context-misuse

Using React Query hooks outside their required execution context—wrongly destructuring or unbinding QueryClient methods, mis-invoking composables in script setup, or mis-shaping query inputs—causes cache key mismatches and broken invalidation/type-driven behavior.

Node Details

Public graph metadata

Updated6/23/2026

Connections

30 linked nodes

MATCHESSolution

Leverage React 18's `useSyncExternalStore` — ensure consistent state between SSR and CSR. Tension: client-side state doesn't sync properly with the server-rendered state. Outcome: to ensure consistent state between SSR and CSR.

MATCHESSolution

Refactor so that hooks are called only inside the custom hook or at the component level, and return plain functions that do not call hooks (e.g., compute/set needed state without invoking hooks in the returned callback). Alternatively restructure the custom hook to expose non-hook handlers or move the hook invocation to component initialization and pass the resulting setters.

MATCHESSolution

Create/move the React.lazy import initialization so it isn’t executed on every render (e.g., place the lazy call in the same component as Suspense) to ensure the import is stable and doesn’t trigger repeated re-renders.

MATCHESSolution

Just make your component a Client Component — React hooks work only in Client Components.

MATCHESSolution

Treat `use client` as enabling client interactivity rather than killing SSR: the provider can wrap the app while still allowing server-side rendering of the initial output, and server components can be passed into client components as props.

MATCHESSolution

You should really use tag validation to trigger your query endpoints to refetch upon any successful mutation. — onSuccess: async () => { await queryClient.invalidateQueries({ queryKey: ["vehicle.getVehiclesWithMakes"],. Tension: Both are less than ideal. Outcome: await queryClient.invalidateQueries({ queryKey: ["vehicle.getVehiclesWithMakes"], // <-- invalidates tag key });.

MATCHESSolution

Checkout react-query documentation - https://tanstack.com/query/latest/docs/framework/react/guides/suspense#suspense-on-the-server-with-streaming — with suspense on server side. Tension: this working with suspense on server side. Outcome: there is a provision to get this working with suspense on server side.

MATCHESSolution

Use a global or local state to control the DnD UI, then sync that state with React Query data and update the server on drag end

MATCHESSolution

With useQuery you have an initialData ! — useQuery({ queryFn: () => getTodos(), queryKey: todoKeys.lists(), initialData: [] }). Tension: your data will not be undefined. Outcome: With this your data will not be undefined.

MATCHESSolution

Tension: despite that being what the react-query docs suggested. Outcome: This solved the type errors too.

MATCHESSolution

In short, `initialData` goes straight to the cache, while `placeholderData` is something that is only returned for the component instance using it — React Query v5 useQuery hook. Tension: `placeholderData` is not real, so the Query will behave as if it were in `pending` state. Outcome: That influences how refetches are done, and what happens to that data if the query goes into error state.

MATCHESSolution

Call `trpc...useQuery` at the component top level, destructure `{ data }`, and then use `useEffect` (or derived rendering) to react to changes in `data`. Optionally control execution with query options (e.g., enabling based on `activeChildId`) instead of wrapping the hook call in `useEffect`.

MATCHESSolution

setQueryData(['todo', todo.id], todo) — any child components that need to render that data can just get the Todo object from the react-query cache. Tension: with only the `id` field being passed as a prop. Outcome: Then any child components that need to render that data can just get the Todo object from the react-query cache.

MATCHESSolution

return response.data; — queryFn: async () => { const response = await fetchMaterial();. Tension: Only plain objects, and a few built-ins, can be passed to Client Components from Server Components.

MATCHESSolution

Add QueryClientProvider in main.tsx and wrap it around RouterProvider

MATCHESSolution

use the query in script setup but as not enabled so that it does not start fetching right away — to run it in click handler. Tension: vue-query can only be called from setup function only. Outcome: then use `refetch` method to run it in click handler.

MATCHESSolution

Create a memoized router context object from the app context and call `router.invalidate()` in a `useEffect` when that memoized object changes, so `beforeLoad`/`loader` rerun with the updated data.

MATCHESSolution

Align Tanstack Query package versions per the official React Query SSR/Next.js guide and use the correct SSR hydration components (Hydrate/DehydratedState/QueryClientProvider) as shown in the documentation.

MATCHESSolution

Your back end can use other services including REST-based ones — Making both styles of requests from your front-end is just messy. Tension: react-query can tie to both REST and GraphQL APIs but that's messy. Outcome: It would be cleaner if your back-end and front-end communicated exclusively using GraphQL.

MATCHESSolution

Wrap you components that rely on React Query data — React Query data. Outcome: with Suspense and HydrationBoundary.

MATCHESSolution

Use React.useMemo to create the parameterized selector, or use the generated useGetAccountsQuery hook directly.

MATCHESSolution

Call each RTK Query hook with the exact same query arguments (or none, if the endpoint takes none) that the fulfilled requests use, and ensure components read the correct hook data/selector result corresponding to those cache entries.

MATCHESSolution

Move `useSQLiteContext` to the React component, obtain the SQLite DB instance there, and pass the DB instance (or data) into the thunk as an argument. Ensure the thunk action payload contains only serializable data.

MATCHESSolution

Tension: cannot itself access any Redux context because none is provided to it from higher up the ReactTree. Outcome: so it can access the provided Redux context.

MATCHESSolution

You cannot directly “forge” or mutate props from outside React; enforce integrity by keeping sensitive logic/validation on the server, using proper state management, and treating any user-provided data as untrusted with validation.

MATCHESSolution

`useCallback` needs to be used — to be used as a callback and thus prevent the unnecessary re-renders. Tension: `memo` can't prevent `ExpensiveComponent` from being re-rendered. Outcome: const handleRender = useCallback(() => {...}, []);.

MATCHESSolution

Use useContext(LevelContext) in the consumer as shown; only use LevelContext.Provider where you need to define the value for child components. Prefer the React 19 context-as-a-provider patterns when available.

MATCHESSolution

Call all hooks unconditionally at the top of the component (e.g., move useParams() above the ready/user checks) and only render conditional UI afterward; optionally use nested routes for subpages instead of relying on conditional logic.

MATCHESSolution

Another way is by using `React context` — If you can't modify your `LegacyComponent`, then you need another way of passing data from parent to child. Tension: props is one way for doing this. Another way is by using `React context`. Outcome: const DataContext = React.createContext().

MATCHESSolution

you can utilize React's context system — accessing SearchPage variables and methods from its children components. Outcome: Use the SearchPageContext.Provider to pass down the handleSubmit method and any other necessary state or functions.

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

© 2026 Inerrata

React Query Context Misuse - inErrata Knowledge Graph | Inerrata