Implement the createMap and createCounter methods

Based on [1] at cb11ba8. Implementation and tests by Cursor (both with
some tweaking by me).

TODO look at Cursor's tests and annotate

Haven't implemented:

- the RTO11e etc echoMessages check — deferred to #49
- the RTO11c etc channel mode checking - same reason as 392fae3
- using server time for generating object ID — deferred to #50

[1] ably/specification#353

Author: lawrence-forooghian

Sources/AblyLiveObjects/Internal/InternalDefaultRealtimeObjects.swift

@@ -113,20 +113,88 @@ internal final class InternalDefaultRealtimeObjects: Sendable, LiveMapObjectPool
         }
     }
 
-    internal func createMap(entries _: [String: LiveMapValue]) async throws(ARTErrorInfo) -> any LiveMap {
-        notYetImplemented()
+    internal func createMap(entries: [String: InternalLiveMapValue], coreSDK: CoreSDK) async throws(ARTErrorInfo) -> InternalDefaultLiveMap {
+        do throws(InternalError) {
+            // RTO11d
+            do {
+                try coreSDK.validateChannelState(notIn: [.detached, .failed, .suspended], operationDescription: "RealtimeObjects.createMap")
+            } catch {
+                throw error.toInternalError()
+            }
+
+            // RTO11f
+            // TODO: This is a stopgap; change to use server time per RTO11f5 (https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/50)
+            let timestamp = clock.now
+            let creationOperation = ObjectCreationHelpers.creationOperationForLiveMap(
+                entries: entries,
+                timestamp: timestamp,
+            )
+
+            // RTO11g
+            try await coreSDK.publish(objectMessages: [creationOperation.objectMessage])
+
+            // RTO11h
+            return mutex.withLock {
+                mutableState.objectsPool.getOrCreateMap(
+                    creationOperation: creationOperation,
+                    logger: logger,
+                    userCallbackQueue: userCallbackQueue,
+                    clock: clock,
+                )
+            }
+        } catch {
+            throw error.toARTErrorInfo()
+        }
     }
 
-    internal func createMap() async throws(ARTErrorInfo) -> any LiveMap {
-        notYetImplemented()
+    internal func createMap(coreSDK: CoreSDK) async throws(ARTErrorInfo) -> InternalDefaultLiveMap {
+        // RTO11f4b
+        try await createMap(entries: [:], coreSDK: coreSDK)
     }
 
-    internal func createCounter(count _: Double) async throws(ARTErrorInfo) -> any LiveCounter {
-        notYetImplemented()
+    internal func createCounter(count: Double, coreSDK: CoreSDK) async throws(ARTErrorInfo) -> InternalDefaultLiveCounter {
+        do throws(InternalError) {
+            // RTO12d
+            do {
+                try coreSDK.validateChannelState(notIn: [.detached, .failed, .suspended], operationDescription: "RealtimeObjects.createMap")
+            } catch {
+                throw error.toInternalError()
+            }
+
+            // RTO12f1
+            if !count.isFinite {
+                throw LiveObjectsError.counterInitialValueInvalid(value: count).toARTErrorInfo().toInternalError()
+            }
+
+            // RTO12f
+
+            // TODO: This is a stopgap; change to use server time per RTO12f5 (https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/50)
+            let timestamp = clock.now
+            let creationOperation = ObjectCreationHelpers.creationOperationForLiveCounter(
+                count: count,
+                timestamp: timestamp,
+            )
+
+            // RTO12g
+            try await coreSDK.publish(objectMessages: [creationOperation.objectMessage])
+
+            // RTO12h
+            return mutex.withLock {
+                mutableState.objectsPool.getOrCreateCounter(
+                    creationOperation: creationOperation,
+                    logger: logger,
+                    userCallbackQueue: userCallbackQueue,
+                    clock: clock,
+                )
+            }
+        } catch {
+            throw error.toARTErrorInfo()
+        }
     }
 
-    internal func createCounter() async throws(ARTErrorInfo) -> any LiveCounter {
-        notYetImplemented()
+    internal func createCounter(coreSDK: CoreSDK) async throws(ARTErrorInfo) -> InternalDefaultLiveCounter {
+        // RTO12f2a
+        try await createCounter(count: 0, coreSDK: coreSDK)
     }
 
     internal func batch(callback _: sending BatchCallback) async throws {

Sources/AblyLiveObjects/Internal/InternalLiveMapValue.swift

@@ -6,6 +6,30 @@ internal enum InternalLiveMapValue: Sendable, Equatable {
     case liveMap(InternalDefaultLiveMap)
     case liveCounter(InternalDefaultLiveCounter)
 
+    // MARK: - Creating from a public LiveMapValue
+
+    /// Converts a public ``LiveMapValue`` into an ``InternalLiveMapValue``.
+    ///
+    /// Needed in order to access the internals of user-provided LiveObject-valued LiveMap entries to extract their object ID.
+    internal init(liveMapValue: LiveMapValue) {
+        switch liveMapValue {
+        case let .primitive(primitiveValue):
+            self = .primitive(primitiveValue)
+        case let .liveMap(publicLiveMap):
+            guard let publicDefaultLiveMap = publicLiveMap as? PublicDefaultLiveMap else {
+                // TODO: Try and remove this runtime check and know this type statically, see https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/37
+                preconditionFailure("Expected PublicDefaultLiveMap, got \(publicLiveMap)")
+            }
+            self = .liveMap(publicDefaultLiveMap.proxied)
+        case let .liveCounter(publicLiveCounter):
+            guard let publicDefaultLiveCounter = publicLiveCounter as? PublicDefaultLiveCounter else {
+                // TODO: Try and remove this runtime check and know this type statically, see https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/37
+                preconditionFailure("Expected PublicDefaultLiveCounter, got \(publicLiveCounter)")
+            }
+            self = .liveCounter(publicDefaultLiveCounter.proxied)
+        }
+    }
+
     // MARK: - Representation in the Realtime protocol
 
     /// Converts an `InternalLiveMapValue` to the value that should be used when creating or updating a map entry in the Realtime protocol, per the rules of RTO11f4 and RTLM20e4.

Sources/AblyLiveObjects/Public/Public Proxy Objects/PublicDefaultRealtimeObjects.swift

@@ -36,19 +36,54 @@ internal final class PublicDefaultRealtimeObjects: RealtimeObjects {
     }
 
     internal func createMap(entries: [String: LiveMapValue]) async throws(ARTErrorInfo) -> any LiveMap {
-        try await proxied.createMap(entries: entries)
+        let internalEntries: [String: InternalLiveMapValue] = entries.mapValues { .init(liveMapValue: $0) }
+        let internalMap = try await proxied.createMap(entries: internalEntries, coreSDK: coreSDK)
+
+        return PublicObjectsStore.shared.getOrCreateMap(
+            proxying: internalMap,
+            creationArgs: .init(
+                coreSDK: coreSDK,
+                delegate: proxied,
+                logger: logger,
+            ),
+        )
     }
 
     internal func createMap() async throws(ARTErrorInfo) -> any LiveMap {
-        try await proxied.createMap()
+        let internalMap = try await proxied.createMap(coreSDK: coreSDK)
+
+        return PublicObjectsStore.shared.getOrCreateMap(
+            proxying: internalMap,
+            creationArgs: .init(
+                coreSDK: coreSDK,
+                delegate: proxied,
+                logger: logger,
+            ),
+        )
     }
 
     internal func createCounter(count: Double) async throws(ARTErrorInfo) -> any LiveCounter {
-        try await proxied.createCounter(count: count)
+        let internalCounter = try await proxied.createCounter(count: count, coreSDK: coreSDK)
+
+        return PublicObjectsStore.shared.getOrCreateCounter(
+            proxying: internalCounter,
+            creationArgs: .init(
+                coreSDK: coreSDK,
+                logger: logger,
+            ),
+        )
     }
 
     internal func createCounter() async throws(ARTErrorInfo) -> any LiveCounter {
-        try await proxied.createCounter()
+        let internalCounter = try await proxied.createCounter(coreSDK: coreSDK)
+
+        return PublicObjectsStore.shared.getOrCreateCounter(
+            proxying: internalCounter,
+            creationArgs: .init(
+                coreSDK: coreSDK,
+                logger: logger,
+            ),
+        )
     }
 
     internal func batch(callback: sending BatchCallback) async throws {

Sources/AblyLiveObjects/Utility/Errors.swift

@@ -6,19 +6,26 @@ import Ably
 internal enum LiveObjectsError {
     // operationDescription should be a description of a method like "LiveCounter.value"; it will be interpolated into an error message
     case objectsOperationFailedInvalidChannelState(operationDescription: String, channelState: ARTRealtimeChannelState)
+    case counterInitialValueInvalid(value: Double)
+    case counterIncrementAmountInvalid(amount: Double)
 
     /// The ``ARTErrorInfo/code`` that should be returned for this error.
     internal var code: ARTErrorCode {
         switch self {
         case .objectsOperationFailedInvalidChannelState:
             .channelOperationFailedInvalidState
+        case .counterInitialValueInvalid, .counterIncrementAmountInvalid:
+            // RTO12f1, RTLC12e1
+            .invalidParameterValue
         }
     }
 
     /// The ``ARTErrorInfo/statusCode`` that should be returned for this error.
     internal var statusCode: Int {
         switch self {
-        case .objectsOperationFailedInvalidChannelState:
+        case .objectsOperationFailedInvalidChannelState,
+             .counterInitialValueInvalid,
+             .counterIncrementAmountInvalid:
             400
         }
     }
@@ -28,6 +35,10 @@ internal enum LiveObjectsError {
         switch self {
         case let .objectsOperationFailedInvalidChannelState(operationDescription: operationDescription, channelState: channelState):
             "\(operationDescription) operation failed (invalid channel state: \(channelState))"
+        case let .counterInitialValueInvalid(value: value):
+            "Invalid counter initial value (must be a finite number): \(value)"
+        case let .counterIncrementAmountInvalid(amount: amount):
+            "Invalid counter increment amount (must be a finite number): \(amount)"
         }
     }