Idempotency keys versus request-id deduplication for retry-safe writes in SolidJS

Direct Answer

SolidJS does not expose a useDeferredValue hook in its stable API; its concurrent rendering primitives are startTransition and Suspense. More importantly, useResource is designed for cached reads, not retry-safe writes. For idempotent writes, use a dedicated mutation function rather than a resource fetcher. The retry logic must close over a stable, non-reactive idempotency key generated once per logical operation, never re-derived from a signal.

Likely Explanation vs. Confirmed Behavior

The likely cause of duplicate writes is that the idempotency key is regenerated on each attempt or stored in a reactive signal that triggers a new fetch when it changes. Confirmed framework behavior: startTransition defers UI rendering, but it does not deduplicate network requests. If two transitions fire while a write is retrying, both can issue fetches unless the client gates them.

Required Steps for Retry-Safe Writes

1. Generate the idempotency key once per logical operation and store it in a non-reactive Map or closure. Do not make the key a reactive dependency of the fetch source.
2. Replace useResource with a mutation function for writes. If you must use a resource for reads that reflect the write, keep the write path separate.
3. Implement a per-key in-flight lock: if a promise for the key already exists, retries await that promise instead of issuing a new fetch.
4. Treat network timeouts and connection drops as pending, not failed, until the server definitively responds.
5. Retire the key only after the server returns an explicit completion signal—a committed: true field, a resource version, or an ETag. A bare HTTP 200 is insufficient if the write may be queued.
6. Wrap UI updates in startTransition to suppress intermediate renders, but do not rely on it to prevent duplicate commits.

Minimal Client State Shape

Use a non-reactive coordinator keyed by a stable operation ID:

const pendingWrites = new Map();
// entry: { idempotencyKey, status: 'pending' | 'committed' | 'failed', serverVersion }

Expose only a derived status signal to the UI. The idempotency key and lock promise stay outside the reactive graph so that state changes do not cascade into new fetches.

Verification

• Simulate a network drop after the request is sent; confirm the retry sends the identical key and the server creates one record.
• Log signal reads during a retry to verify the key does not trigger extra resource executions.
• Interrupt a startTransition and confirm no additional network request is issued.

Missing Diagnostic

Does your server enforce idempotency keys and return an explicit commit or version signal? If it does not, client-side key coordination alone cannot guarantee deduplication, and the recommendation shifts to adding server-side enforcement before retry logic.