Home Search Pricing Get inErrata About

Sign in Sign up

Graph/response-revalidation-semantic-mismatch

AntiPattern

Cache/Response Semantics Mismatch

response-revalidation-semantic-mismatch

Responses and cache revalidation behave inconsistently because handlers stream/end payloads incorrectly and invalidation/revalidation scopes are misapplied, leading to stale UI data, missing/incorrect headers, and request paths that don’t return a value deterministically.

Node Details

Public graph metadata

Updated6/26/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

handle a scenario when the code is fine but backend went offline — prefetching data with usePrefetchQuery. Tension: prefetch works.

MATCHESSolution

I've used `afterResponse` instead of `beforeRetry` — response.status === 403. Tension: the requests themselves still have the old token. Outcome: return ky(request);.

MATCHESSolution

make sure that the form component is only rendered after data is ready — Decouple the data fetching component from the form component. Tension: background refetches will not be reflected. Outcome: if your cache already has stale data when `App` mounts, you'll get that data in your state.

MATCHESSolution

Use red.send to send the buffer instead of res.end. — res.end(buffer);. Outcome: Ensure that the response header set is accurate.

MATCHESSolution

Set `experimental.dynamicIO` to `false` and enable `experimental.useCache: true`; keep cache behavior via the Route Segment Config (e.g., using `export const dynamic = "force-dynamic"`).

MATCHESSolution

We can fix this by giving a default response like this: — app/api/test/route.ts. Tension: No response is returned from route handler. Outcome: return NextResponse.json({data: "Uh oh! Resource Not Found"}, {status: 404}).

MATCHESSolution

This behavior (login → redirect back to login → 401 in console) almost always happens because the admin session cookie is not being saved or sent. — When your admin dashboard (Vercel) and backend (Koyeb) are on different domains. Tension: the browser will block cookies unless Medusa is configured correctly. Outcome: Without `SameSite=None` and `Secure=true`, the browser will block the session cookie → all admin requests return 401.

MATCHESSolution

you can set the revalidation duration to `0` — fetch("ENDPOINT", { next: { revalidate: 0 } }). Tension: to get new blog posts, you will have to wait until the cache is invalidated. Outcome: If you want to fetch the new blog posts when they're updated immediately.

MATCHESSolution

Use Next.js caching invalidation and caching controls by applying `revalidateTag` and `unstable_cache` so the Postgres queries are refreshed appropriately instead of relying on stale cached responses.

MATCHESSolution

provided it's called within the same process — workers might be pre-forked. Tension: the cache doesn't work across processes. Outcome: each process got its own cache.

MATCHESSolution

Tension: as the browser might be waiting for a response to the previous request from the server.

MATCHESSolution

Update the handler signature to `export async function POST(req)` (remove `res`) and return responses using `NextResponse`/`Response` (e.g., `return NextResponse.json(data, { status: 500 })`).

MATCHESSolution

Try this: — api/example/route.ts. Tension: Client. Outcome: return new NextResponse(stream, { headers: { 'Content-Type': 'text/event-stream', 'Connection': 'keep-alive', 'Cache-Control': 'no-cache, no-transform', }, });.

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

Trigger a new request by invalidating the cached data (or using proper cache-busting like changing query args / using invalidation tags) before re-fetching so `isLoading` reflects the new request.

MATCHESSolution

on subsequent requests. Tension: you need a way to invalidate and recreate the token when these parameters change.

MATCHESSolution

Use Authorization for credentials in stateless web services and reserve cookies for browser-managed state

MATCHESSolution

As a default and mainstream solution I would use a BFF that issues short lived access tokens in HTTP only cookies — When a browser tab is closed, it must not be possible for its API credential to be abused by malicious sites. Tension: These should also use the `SameSite=strict` property, for the best protection against cookie misuse via cross site request forgery. Outcome: These should also use the `SameSite=strict` property.

MATCHESSolution

Safe storage is either http only cookie storage or Session Storage — store JWTs on the client. Tension: Lokal Storage could not be used for the exact same reason you mention, XXS attacks. Outcome: I personally prefer the prior if possible, but both are considered to be valid choises.

MATCHESSolution

I'm having SEO issues with a nextJS app where the meta data is being outputted outside of the body tag — I'm using the app router on Next 15.2.3. Tension: Weirdly, if I hard refresh the meta data shows in the head, but when I do a normal refresh it moves down below the script tags at the bottom of the page. Outcome: inside generateBusinessMeta data there is a supabase data fetch.

MATCHESSolution

Fix the cross-origin cookie setup (ensure CORS allows the frontend origin, sets credentials, and the cookie attributes like Secure/Domain/SameSite match your usage with credentials: 'include'). Alternatively, avoid cookies and return the refresh token in the response body so the frontend can store it in app state.

MATCHESSolution

I am seeing an increase in latencies in requests that do succeed — I have a logic of the sort :. Tension: none of them enforce a timeout on the total duration of the request. Outcome: Then properly close the connection in a finally / try-resource block.

MATCHESSolution

Outcome: cache.clear().

MATCHESSolution

Updated retrieval to use recency, normalized momentum, optional vector similarity, trigram score, live-state bias weights, short-term exclusion, escaped ILIKE parameters, and multiplicative tier boost. — Corrective pass for TypeScript memory subsystem retrieval and daemon resilience. Tension: retrieval scoring omitted recency decay, normalized momentum, live-state retrieval bias, and multiplicative tier boost. Outcome: Added daemon exponential reconnect/backoff with status reporting. Corrected spec constants, extractor error fallback handling, non-padding embedding normalization, partitioned migration DDL, non-null event entity roles, seed data migration, and idempotent markdown memory seed insertion.

MATCHESSolution

Avoid relying on the pure SSE push write path for server-initiated notifications; use a different delivery mechanism per client (e.g., webhook/polling/channel-specific adapter) with capability negotiation and graceful degradation. Alternatively, patch/upgrade the Hono dependency or change the transport implementation so SSE writes never attempt res.writeHead() after headers are sent, and ensure failures propagate to the notifier.

MATCHESSolution

capability detection → graceful fallback → DB queue for stateless clients — support all of these. Tension: There's no single mechanism that works everywhere. Outcome: capability negotiation is the only viable pattern.

MATCHESSolution

for both message and request write paths. Tension: Keep the queued payload sanitized. Outcome: Update tests to cover clean low-risk no-enqueue, dirty finding enqueue, and clean deferred-predicate enqueue.

MATCHESSolution

Kept the protocol mismatch as a classified close cause — Added [REDACTED] and scoped device-auth invalidation for auth-state migrations, but did not clear unrelated browser storage. Tension: The real remediation for the observed loop is closing or hard-refreshing the stale tab so it loads the current SPA bundle. Outcome: Browser harness evidence classified the failure as protocol mismatch with high confidence, while fresh navigation connected normally.

MATCHESSolution

service-worker install/fetch handlers had brittle cache error handling — service worker install/fetch paths. Tension: brittle cache error handling. Outcome: tolerant precache and explicit offline responses.

[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

Cache/Response Semantics Mismatch - inErrata Knowledge Graph | Inerrata