Use server time for object ID per spec

This was skipped in dcdb350 due to time constraints. Resolves #50.

Author: lawrence-forooghian

AblyLiveObjects.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -20,12 +20,14 @@ let package = Package(
     dependencies: [
         .package(
             url: "https://github.com/ably/ably-cocoa",
-            from: "1.2.46",
+            // TODO: Unpin before next release
+            revision: "c43c3fbaa9fadd0d6b185645a16b6fd7a55106ff",
         ),
         .package(
             url: "https://github.com/ably/ably-cocoa-plugin-support",
             // Be sure to use `exact` here and not `from`; SPM does not have any special handling of 0.x versions and will resolve 'from: "0.2.0"' to anything less than 1.0.0.
-            exact: "0.2.0",
+            // TODO: Unpin before next release
+            revision: "37ad19df2cc6063c74ec88ecefc2ddf491db5ebf",
         ),
         .package(
             url: "https://github.com/apple/swift-argument-parser",

Package.resolved

@@ -8,6 +8,9 @@ internal protocol CoreSDK: AnyObject, Sendable {
     /// Implements the internal `#publish` method of RTO15.
     func publish(objectMessages: [OutboundObjectMessage]) async throws(ARTErrorInfo)
 
+    /// Implements the server time fetch of RTO16, including the storing and usage of the local clock offset.
+    func fetchServerTime() async throws(ARTErrorInfo) -> Date
+
     /// Replaces the implementation of ``publish(objectMessages:)``.
     ///
     /// Used by integration tests, for example to disable `ObjectMessage` publishing so that a test can verify that a behaviour is not a side effect of an `ObjectMessage` sent by the SDK.
@@ -81,6 +84,28 @@ internal final class DefaultCoreSDK: CoreSDK {
         }
     }
 
+    internal func fetchServerTime() async throws(ARTErrorInfo) -> Date {
+        try await withCheckedContinuation { (continuation: CheckedContinuation<Result<Date, ARTErrorInfo>, _>) in
+            let internalQueue = pluginAPI.internalQueue(for: client)
+
+            internalQueue.async { [client, pluginAPI] in
+                pluginAPI.nosync_fetchServerTime(for: client) { serverTime, error in
+                    // We don't currently rely on this documented behaviour of `noSync_fetchServerTime` but we may do later, so assert it to be sure it's happening.
+                    dispatchPrecondition(condition: .onQueue(internalQueue))
+
+                    if let error {
+                        continuation.resume(returning: .failure(ARTErrorInfo.castPluginPublicErrorInfo(error)))
+                    } else {
+                        guard let serverTime else {
+                            preconditionFailure("nosync_fetchServerTime gave nil serverTime and nil error")
+                        }
+                        continuation.resume(returning: .success(serverTime))
+                    }
+                }
+            }
+        }.get()
+    }
+
     internal var nosync_channelState: _AblyPluginSupportPrivate.RealtimeChannelState {
         pluginAPI.nosync_state(for: channel)
     }

Package.swift

@@ -172,14 +172,17 @@ internal final class InternalDefaultRealtimeObjects: Sendable, LiveMapObjectsPoo
     }
 
     internal func createMap(entries: [String: InternalLiveMapValue], coreSDK: CoreSDK) async throws(ARTErrorInfo) -> InternalDefaultLiveMap {
-        let creationOperation = try mutableStateMutex.withSync { _ throws(ARTErrorInfo) in
+        try mutableStateMutex.withSync { _ throws(ARTErrorInfo) in
             // RTO11d
             try coreSDK.nosync_validateChannelState(notIn: [.detached, .failed, .suspended], operationDescription: "RealtimeObjects.createMap")
+        }
 
+        // RTO11f7
+        let timestamp = try await coreSDK.fetchServerTime()
+
+        let creationOperation = mutableStateMutex.withSync { _ in
             // RTO11f
-            // TODO: This is a stopgap; change to use server time per RTO11f5 (https://github.com/ably/ably-liveobjects-swift-plugin/issues/50)
-            let timestamp = clock.now
-            return ObjectCreationHelpers.nosync_creationOperationForLiveMap(
+            ObjectCreationHelpers.nosync_creationOperationForLiveMap(
                 entries: entries,
                 timestamp: timestamp,
             )
@@ -218,8 +221,9 @@ internal final class InternalDefaultRealtimeObjects: Sendable, LiveMapObjectsPoo
 
         // RTO12f
 
-        // TODO: This is a stopgap; change to use server time per RTO12f5 (https://github.com/ably/ably-liveobjects-swift-plugin/issues/50)
-        let timestamp = clock.now
+        // RTO12f5
+        let timestamp = try await coreSDK.fetchServerTime()
+
         let creationOperation = ObjectCreationHelpers.creationOperationForLiveCounter(
             count: count,
             timestamp: timestamp,

Sources/AblyLiveObjects/Internal/CoreSDK.swift

@@ -1202,15 +1202,15 @@ struct InternalDefaultRealtimeObjectsTests {
             }
         }
 
+        // @spec RTO11f7
         // @spec RTO11g
         // @spec RTO11h3a
         // @spec RTO11h3b
         @Test
         func publishesObjectMessageAndCreatesMap() async throws {
             let internalQueue = TestFactories.createInternalQueue()
-            let clock = MockSimpleClock(currentTime: .init(timeIntervalSince1970: 1_754_042_434))
-            let realtimeObjects = InternalDefaultRealtimeObjectsTests.createDefaultRealtimeObjects(clock: clock, internalQueue: internalQueue)
-            let coreSDK = MockCoreSDK(channelState: .attached, internalQueue: internalQueue)
+            let realtimeObjects = InternalDefaultRealtimeObjectsTests.createDefaultRealtimeObjects(internalQueue: internalQueue)
+            let coreSDK = MockCoreSDK(channelState: .attached, serverTime: .init(timeIntervalSince1970: 1_754_042_434), internalQueue: internalQueue)
 
             // Track published messages
             var publishedMessages: [OutboundObjectMessage] = []
@@ -1234,8 +1234,7 @@ struct InternalDefaultRealtimeObjectsTests {
             #expect(publishedMessage.operation?.action == .known(.mapCreate))
             let objectID = try #require(publishedMessage.operation?.objectId)
             #expect(objectID.hasPrefix("map:"))
-            // TODO: This is a stopgap; change to use server time per RTO11f5 (https://github.com/ably/ably-liveobjects-swift-plugin/issues/50)
-            #expect(objectID.contains("1754042434000")) // check contains the mock clock's timestamp in milliseconds
+            #expect(objectID.contains("1754042434000")) // check contains the server timestamp in milliseconds per RTO11f7
             #expect(publishedMessage.operation?.map?.entries == [
                 "stringKey": .init(data: .init(string: "stringValue")),
             ])
@@ -1336,15 +1335,15 @@ struct InternalDefaultRealtimeObjectsTests {
                 }
             }
 
+            // @spec RTO12f5
             // @spec RTO12g
             // @spec RTO12h3a
             // @spec RTO12h3b
             @Test
             func publishesObjectMessageAndCreatesCounter() async throws {
                 let internalQueue = TestFactories.createInternalQueue()
-                let clock = MockSimpleClock(currentTime: .init(timeIntervalSince1970: 1_754_042_434))
-                let realtimeObjects = InternalDefaultRealtimeObjectsTests.createDefaultRealtimeObjects(clock: clock, internalQueue: internalQueue)
-                let coreSDK = MockCoreSDK(channelState: .attached, internalQueue: internalQueue)
+                let realtimeObjects = InternalDefaultRealtimeObjectsTests.createDefaultRealtimeObjects(internalQueue: internalQueue)
+                let coreSDK = MockCoreSDK(channelState: .attached, serverTime: .init(timeIntervalSince1970: 1_754_042_434), internalQueue: internalQueue)
 
                 // Track published messages
                 var publishedMessages: [OutboundObjectMessage] = []
@@ -1363,8 +1362,7 @@ struct InternalDefaultRealtimeObjectsTests {
                 #expect(publishedMessage.operation?.action == .known(.counterCreate))
                 let objectID = try #require(publishedMessage.operation?.objectId)
                 #expect(objectID.hasPrefix("counter:"))
-                // TODO: This is a stopgap; change to use server time per RTO11f5 (https://github.com/ably/ably-liveobjects-swift-plugin/issues/50)
-                #expect(objectID.contains("1754042434000")) // check contains the mock clock's timestamp in milliseconds
+                #expect(objectID.contains("1754042434000")) // check contains the server timestamp in milliseconds per RTO12f5
                 #expect(publishedMessage.operation?.counter?.count == 10.5)
 
                 // Verify initial value was merged per RTO12h3a

Sources/AblyLiveObjects/Internal/InternalDefaultRealtimeObjects.swift

@@ -8,9 +8,11 @@ final class MockCoreSDK: CoreSDK {
     private nonisolated(unsafe) var _publishHandler: (([OutboundObjectMessage]) async throws(ARTErrorInfo) -> Void)?
 
     private let channelStateMutex: DispatchQueueMutex<_AblyPluginSupportPrivate.RealtimeChannelState>
+    private let serverTime: Date
 
-    init(channelState: _AblyPluginSupportPrivate.RealtimeChannelState, internalQueue: DispatchQueue) {
+    init(channelState: _AblyPluginSupportPrivate.RealtimeChannelState, serverTime: Date = .init(), internalQueue: DispatchQueue) {
         channelStateMutex = DispatchQueueMutex(dispatchQueue: internalQueue, initialValue: channelState)
+        self.serverTime = serverTime
     }
 
     func publish(objectMessages: [OutboundObjectMessage]) async throws(ARTErrorInfo) {
@@ -35,4 +37,8 @@ final class MockCoreSDK: CoreSDK {
             _publishHandler = handler
         }
     }
+
+    func fetchServerTime() async throws(ARTErrorInfo) -> Date {
+        serverTime
+    }
 }