fix(zero-swift): list the group's running clients in activeClients

Two Zero instances of one client group in one process sent only themselves
in initConnection's activeClients, so zero-cache deleted the other client
and its queries while it ran. The instances on one ReplicaDatabase now
track each other, as ActiveClientsManager does in JS, and when one closes
the others of its group send deleteClients for it once.

Amp-Thread-ID: https://ampcode.com/threads/T-c513a037-a257-45e0-b9a9-15c15edfe859
Co-authored-by: tmm <tmm@tmm.dev>

Author: ampagent

.changeset/active-clients.md

@@ -0,0 +1,5 @@
+---
+'zero-swift': patch
+---
+
+Two `Zero` instances of one client group in one process (the same user, `storageKey`, and storage, such as two windows) no longer drop each other's queries: `initConnection` lists every running client of the group in `activeClients`, as in JS, so zero-cache doesn't delete the other one. When one closes, the others send `deleteClients` for it once.

swift/Sources/Zero/Client/Engine.swift

@@ -92,7 +92,10 @@ final class Engine {
   isolated deinit {
     loop.stop()
     for t in lifecycleTimers { t.cancel() }
-    if !repClosed { database.release() }
+    if !repClosed {
+      database.clientStopped(clientID)
+      database.release()
+    }
   }
   private let socketFactory: (any SocketFactory)?
   private let socketOrigin: String?
@@ -236,6 +239,14 @@ final class Engine {
         store.advance(to: store.snapshot, main: main, pending: replayed, touched: touched))
     }
     database.onWriteFailure = { [weak self] failure in self?.storageFailed(failure) }
+    // Another client of the group stopped (the `onDelete` of
+    // `makeActiveClientsManager`): tell the server, if connected.
+    database.clientStarted(clientID, clientGroupID: clientGroupID) { [weak self] id in
+      guard let self else { return }
+      self.loop.dispatch {
+        self.sendIfConnected(.deleteClients(DeleteClientsBody(clientIDs: [id])))
+      }
+    }
     if let openFailure {
       log.warn(
         "Local store storage failed (\(openFailure.kind.rawValue)) opening \(name); "
@@ -673,7 +684,10 @@ final class Engine {
       clientSchema: connectCookie.isNull ? clientSchema : nil, deleted: deleted,
       userPushURL: options.mutateURL, userPushHeaders: options.mutateHeaders,
       userQueryURL: options.queryURL, userQueryHeaders: options.queryHeaders,
-      activeClients: [clientID])
+      activeClients: [clientID]
+        + database.activeClients(ofGroup: clientGroupID).filter {
+          $0 != clientID
+        })
     let authToken = auth.flatMap { $0.isEmpty ? nil : $0 }
     var secProtocol = SecProtocols.encode(initConnection: initConnection, authToken: authToken)
     if secProtocol.utf8.count > options.maxHeaderLength {
@@ -1012,6 +1026,7 @@ final class Engine {
     pushTimer = nil
     for t in lifecycleTimers { t.cancel() }
     lifecycleTimers = []
+    database.clientStopped(clientID)
     database.release()
     connectionManager.closed()
   }

swift/Sources/Zero/Storage/ReplicaDatabase.swift

@@ -162,6 +162,12 @@ final class ReplicaDatabase {
   /// Hears about the first write failure.
   var onWriteFailure: ((StorageFailure) -> Void)?
 
+  /// The clients running on this database in this process, in the order
+  /// they started (`ActiveClientsManager`, which JS keeps across tabs
+  /// with Web Locks). Each hears when another of its group stops.
+  private var running: [(clientID: String, clientGroupID: String, onDelete: (String) -> Void)] =
+    []
+
   private static var open: [String: ReplicaDatabase] = [:]
   /// The profile ID of memory databases, one per process as in JS.
   private static var memoryProfileID: String?
@@ -233,6 +239,29 @@ final class ReplicaDatabase {
     sqlite.close()
   }
 
+  /// Records that `clientID` runs until `clientStopped`. `onDelete` gets
+  /// the clients of its group that stop before it.
+  func clientStarted(
+    _ clientID: String, clientGroupID: String, onDelete: @escaping (String) -> Void
+  ) {
+    running.append((clientID, clientGroupID, onDelete))
+  }
+
+  /// Tells the other running clients of its group, once, that `clientID`
+  /// stopped (`ActiveClientsManager.onDelete`).
+  func clientStopped(_ clientID: String) {
+    guard let i = running.firstIndex(where: { $0.clientID == clientID }) else { return }
+    let stopped = running.remove(at: i)
+    for other in running where other.clientGroupID == stopped.clientGroupID {
+      other.onDelete(clientID)
+    }
+  }
+
+  /// The running clients of group `id` (`ActiveClientsManager.activeClients`).
+  func activeClients(ofGroup id: String) -> [String] {
+    running.filter { $0.clientGroupID == id }.map(\.clientID)
+  }
+
   /// Waits for the writes queued so far.
   func flush() { sqlite?.flush() }
 

swift/Tests/E2ETests/ClientE2ETests.swift

@@ -103,4 +103,35 @@ struct ClientE2ETests {
     #expect(Set(["i1", "i3", "i4"]).isSubset(of: cached.map(\.id)))
     #expect(!cached.contains { $0.id == id })
   }
+
+  /// Two clients of one client group (two windows) both keep their
+  /// queries: each lists the other in `activeClients`, so zero-cache
+  /// doesn't delete it.
+  @Test func twoClientsOfAGroupBothKeepTheirQueries() async throws {
+    defer { try? FileManager.default.removeItem(atPath: directory) }
+    let key = UUID().uuidString
+    let first = try makeZero(storageKey: key)
+    defer { first.close() }
+    // Without a TTL, a query of a client the server deletes goes at once.
+    let open = try first.liveQuery(E2EApp.open(), ttl: .none)
+    try await eventually("the first client's issues") { open.resultType == .complete }
+
+    let second = try makeZero(storageKey: key)
+    defer { second.close() }
+    #expect(second.clientGroupID == first.clientGroupID)
+    let byID = try second.liveQuery(E2EApp.byID("i1"))
+    try await eventually("the second client's issue") { byID.resultType == .complete }
+
+    // The first client's query still syncs a row only it asks for.
+    let id = "swift-\(UUID().uuidString)"
+    let created = second.mutate(E2EApp.create(.init(id: id, title: "Two windows", ownerId: nil)))
+    #expect(try await created.server.value == .success(data: nil))
+    try await eventually("the first client to see the new issue") {
+      open.data.contains { $0.id == id }
+    }
+    #expect(open.resultType == .complete)
+    #expect(byID.data?.id == "i1")
+    let closed = second.mutate(E2EApp.close(id))
+    #expect(try await closed.server.value == .success(data: nil))
+  }
 }