Optimistic Updates

[j]

I like the reactivity pattern, but can I run a mutation that may return the same shape as some query and just bypass the query fetching call?

Basically:

getUser RPC returns User
updateUser RPC returns User

I want to just update instead of invalidate and refetch without having to sync another atom.

I'm used to TanStack query and want to try this but want Stale Queries and Optimistic Updates

[tim-smart]

There is a demo here https://github.com/ethanniser/effect-atom-optimistic-update-demo/tree/main

[andresmarpz]

I have a related but slightly different use case that isn't covered by Atom.optimistic + Atom.optimisticFn (I think):

Scenario: I have a read-only RPC query atom (e.g., session.get). A WebSocket streaming event tells me the server already renamed the session, with some event session-renamed. I want to:

• Update the query atom's cache immediately with the new title (instant UI)
• Trigger a refresh to revalidate the query atom, just in case

The difference from the mutation pattern is that I'm not calling a mutation - the server already changed, and I'm just reacting to an external event. My sessionAtom is a query that needs cache update in-place.

Currently registry.set() / registry.update() only work with Writable atoms. For read-only query atoms, I can only call registry.refresh(), which shows the previous cached value during revalidation - not the new value I already know.

Desired API (something like):

// Set cache value for any atom, then refresh
registry.setValue(sessionAtom, Result.success({ ...session, title: newTitle }));
registry.refresh(sessionAtom);

// Or: refresh with a known stale value
registry.refresh(sessionAtom, { 
  staleValue: Result.success({ ...session, title: newTitle }) 
});

This would enable some "stale-while-revalidate" pattern where the "stale" value comes from an external event rather than the existing data.