CBL-7841: Handle conflict when revision history appears broken (#2489)

* CBL-7841: Handle conflict when revision history appears broken

This is a fallback for cases where the general comparison algorithm
yields a Conflict while applying a remote revision to the local
document. The target scenario is a deleted document being resurrected
in CBS -- when that happens, the resurrected document has no history
prior to the deletion.

Author: jianminzhao

LiteCore/Database/VectorDocument.cc

@@ -428,6 +428,47 @@ namespace litecore {
             } else {
                 // Compare it with the current document revision:
                 order = VersionVecWithLegacy::compare(newVers, curVers);
+
+                // CBL-7841: Handle the case where the revision history may appear broken.
+                //   This happens when a deleted doc is resurrected on the CB Server
+                // without going through SGW. Manifested here, 'order' as yielded by the
+                // above comparison shows Conflict. However, we want to resolve it here by simply
+                // accepting the new version from the remote, provided the following conditions are
+                // true:
+                // 1. Conflict with a genuine remote (remote != RemoteID::Local)
+                // 2. curVers is a tombstone
+                // 3. Remote revision is available at `remote`
+                // 4. curVers == RemoteRevision(remote)
+                // 5. curVers.vector shares no version with newVers.vector
+                // 6. curVers.legacy[0] is not in newVers.legacy (RevTree parent)
+
+                // Make a block that we can "break" out of if any of the above conditions fail.
+                do {
+                    // 1. Conflict with genuine remote
+                    if ( order != kConflicting || remote == RemoteID::Local ) break;
+
+                    // 2. curVers is a tombstone
+                    if ( !(_doc.flags() & DocumentFlags::kDeleted) ) break;
+
+                    // 3. Remote revision is available
+                    optional<Revision> rev = _doc.loadRemoteRevision(remote);
+                    if ( !rev ) break;
+
+                    // 4. curVers == RemoteRevision(remote)
+                    VersionVecWithLegacy lastSynced{rev->revID};
+                    if ( curVers.legacy != lastSynced.legacy || curVers.vector != lastSynced.vector ) break;
+
+                    // 5. curVers.vector shares no version with newVers.vector
+                    if ( curVers.vector.sharesVersion(newVers.vector) ) break;
+
+                    // 6. curVers.legacy[0] is not in newVers.legacy (RevTree parent)
+                    if ( !curVers.legacy.empty()
+                         && std::ranges::find(newVers.legacy, curVers.legacy[0]) != newVers.legacy.end() )
+                        break;
+
+                    order = kNewer;
+                } while ( false );
+
                 logPutExisting(curVers, newVers, order, remote);
 
                 // Check for no-op or conflict:

LiteCore/RevTrees/VersionVector.cc

@@ -278,6 +278,22 @@ namespace litecore {
         return true;
     }
 
+    bool VersionVector::sharesVersion(const VersionVector& other) const {
+        unordered_map<SourceID, logicalTime> myVersions;
+        optional<Version>                    myExtraVersion;  // A merge version may share author with the current.
+        for ( auto& v : _vers ) {
+            if ( !myVersions.insert({v.author(), v.time()}).second ) myExtraVersion = v;
+        }
+
+        for ( auto& v : other._vers ) {
+            auto i = myVersions.find(v.author());
+            if ( i != myVersions.end() && i->second == v.time() ) return true;
+            if ( myExtraVersion && *myExtraVersion == v ) return true;
+        }
+
+        return false;
+    }
+
 #pragma mark - MODIFICATION:
 
     void VersionVector::prune(size_t maxCount, logicalTime before) {

LiteCore/RevTrees/VersionVector.hh

@@ -152,6 +152,9 @@ namespace litecore {
 
         bool operator>=(const Version& v) const { return compareTo(v) != kOlder; }
 
+        // Whether this and `other` share a version.
+        bool sharesVersion(const VersionVector& other) const;
+
         using CompareBySourceFn = function_ref<bool(SourceID, logicalTime, logicalTime)>;
 
         /** For each SourceID found in either `this` or `other`, calls the callback with that ID