Refactor document updates to Redis CAS + async Mongo write-back with retry

[Copilot]

This PR introduces a high-concurrency document update path that prioritizes cache-side atomicity and eventual consistency. Updates now use Redis CAS semantics with retry/backoff and persist to Mongo asynchronously to reduce synchronous contention while preventing stale overwrites.

• Atomic cache update (Redis + Lua)

  • Added an atomic versioned CAS contract (IAtomicVersionCache) for cache implementations.
  • Implemented Redis Lua-based compare-and-swap in RedisCache.CompareAndSwapCache(...):
    • validates expected version
    • writes payload + next version atomically
  • Added compatibility fallback for existing cache entries missing explicit :version key.

• Optimistic concurrency control (version/CAS)

  • DocumentBase.Update(...) now uses cache CAS when supported.
  • Version conflict remains retryable via existing bounded retry + exponential backoff flow.
  • Update payload now uses a stable cloned snapshot to avoid races between in-memory mutation and persistence.

• Async Mongo write-back (eventual consistency)

  • After successful cache CAS, persistence is moved to background write-back (asyncWriteBack).
  • Background persistence uses versioned CAS against the document store and retries with exponential backoff.
  • On persistent write-back failure, cache entry is invalidated to avoid long-lived divergence.

• Focused behavior coverage

  • Added a dedicated unit test for:
    • CAS conflict retry path
    • async write-back retry/success path

if atomicCache, ok := d.cache.(diface.IAtomicVersionCache); ok {
    nextVersion := d.version + 1
    snapshot, _ := cloneAny(d.data)

    _, err := atomicCache.CompareAndSwapCache(
        d.ctx, d.Key, d.version,
        &VersionCache{Version: nextVersion, Data: snapshot},
        DefaultCacheTTL,
    )
    if err == nil {
        prevVersion := d.version
        d.version = nextVersion
        go d.asyncWriteBack(snapshot, prevVersion)
    }
}

[Copilot]

Pull request overview

This PR refactors DocumentBase.Update to prefer an atomic cache-side compare-and-swap (CAS) path when supported (intended for Redis), and moves the database persistence step into an asynchronous write-back with bounded retries to reduce synchronous contention.

Changes:

• Added a new cache contract (diface.IAtomicVersionCache) for version-checked atomic updates.
• Updated DocumentBase.Update to use cache CAS + background persistence, including snapshot cloning for async write-back.
• Implemented Redis Lua-based CAS and added a focused unit test covering CAS retry + async write-back retry/success.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 4 comments.

File	Description
orm/nosql/document.go	Cache-first CAS update flow plus async Mongo write-back and JSON-based snapshot cloning.
orm/nosql/document_update_test.go	New unit test for CAS conflict retry and async write-back retry/success.
orm/nosql/diface/icache.go	Introduces IAtomicVersionCache interface for atomic versioned cache updates.
orm/nosql/cache/redis_cache.go	Adds Redis Lua CAS implementation plus version-key management helpers.

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.