Add TypingMember type, currentTypers property, and bump ably-cocoa to 1.2.58

AndyTWF · claude · AndyTWF · commit 9c1ec6db8aa9 · 2026-02-25T16:55:58.000Z
- Bump ably-cocoa dependency from 1.2.51 to 1.2.58 for userClaim support
- Add TypingMember struct pairing clientID with userClaim metadata
- Add currentTypers property to Typing protocol and TypingSetEvent
- Add currentlyTypingMembers() to TypingTimerManager
- Consolidate createSandboxChatClient/createSandboxChatClientWithJWT into
  a single helper with optional JWT parameters
- Add JWT auth helper (Sandbox.createJWT) for integration tests
- Add integration test for userClaim propagation across all event types
- Stub new ARTChannelProtocol methods from ably-cocoa 1.2.58 in mock

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/Package.resolved b/Package.resolved
diff --git a/Package.swift b/Package.swift
@@ -26,7 +26,7 @@ let package = Package(
         // This is the SDK's only dependency.
         .package(
             url: "https://github.com/ably/ably-cocoa",
-            from: "1.2.51",
+            from: "1.2.58",
         ),
 
         // All of the following dependencies are only used for internal purposes (testing or build tooling).
diff --git a/Sources/AblyChat/DefaultTyping.swift b/Sources/AblyChat/DefaultTyping.swift
@@ -66,6 +66,7 @@ internal final class DefaultTyping: Typing {
                     TypingSetEvent(
                         type: .setChanged,
                         currentlyTyping: typingTimerManager.currentlyTypingClientIDs(),
+                        currentTypers: typingTimerManager.currentlyTypingMembers(),
                         change: .init(clientID: messageClientID, type: .stopped, userClaim: expiredUserClaim),
                     ),
                 )
@@ -78,6 +79,7 @@ internal final class DefaultTyping: Typing {
                     TypingSetEvent(
                         type: .setChanged,
                         currentlyTyping: typingTimerManager.currentlyTypingClientIDs(),
+                        currentTypers: typingTimerManager.currentlyTypingMembers(),
                         change: .init(clientID: messageClientID, type: .started, userClaim: typingTimerManager.userClaimForClient(messageClientID)),
                     ),
                 )
@@ -109,6 +111,7 @@ internal final class DefaultTyping: Typing {
                     TypingSetEvent(
                         type: .setChanged,
                         currentlyTyping: typingTimerManager.currentlyTypingClientIDs(),
+                        currentTypers: typingTimerManager.currentlyTypingMembers(),
                         change: .init(clientID: messageClientID, type: .stopped, userClaim: userClaim),
                     ),
                 )
@@ -131,6 +134,11 @@ internal final class DefaultTyping: Typing {
         typingTimerManager.currentlyTypingClientIDs()
     }
 
+    // (CHA-T18)
+    internal var currentTypers: [TypingMember] {
+        typingTimerManager.currentlyTypingMembers()
+    }
+
     // (CHA-T4) Users may indicate that they have started typing using the keystroke method.
     internal func keystroke() async throws(ErrorInfo) {
         try await keyboardOperationQueue.enqueue { [weak self] () throws(ErrorInfo) in
diff --git a/Sources/AblyChat/Message.swift b/Sources/AblyChat/Message.swift
@@ -84,13 +84,13 @@ public struct Message: Sendable, Equatable {
      */
     public var reactions: MessageReactionSummary
 
+    // @spec CHA-M2h
     /**
      * The user claim attached to this message by the server.
      *
      * Set automatically by the Ably server when a JWT contains a matching
      * `ably.room.<roomName>` claim. This is a read-only, server-provided value.
      */
-    // @spec CHA-M2h
     public var userClaim: String?
 
     /// Memberwise initializer to create a `Message`.
diff --git a/Sources/AblyChat/MessageReaction.swift b/Sources/AblyChat/MessageReaction.swift
@@ -280,13 +280,13 @@ public struct MessageReactionRawEvent: Sendable {
          */
         public var clientID: String
 
+        // @spec CHA-MR7d
         /**
          * The user claim attached to this reaction event by the server.
          *
          * Set automatically by the Ably server when a JWT contains a matching
          * `ably.room.<roomName>` claim. This is a read-only, server-provided value.
          */
-        // @spec CHA-MR7d
         public var userClaim: String?
 
         /// Memberwise initializer to create a `Reaction`.
diff --git a/Sources/AblyChat/Presence.swift b/Sources/AblyChat/Presence.swift
@@ -182,13 +182,13 @@ public struct PresenceMember: Sendable {
     // swiftlint:disable:next missing_docs
     public var updatedAt: Date
 
+    // @spec CHA-PR6g
     /**
      * The user claim attached to this presence event by the server.
      *
      * Set automatically by the Ably server when a JWT contains a matching
      * `ably.room.<roomName>` claim. This is a read-only, server-provided value.
      */
-    // @spec CHA-PR6g
     public var userClaim: String?
 }
 
diff --git a/Sources/AblyChat/RoomReaction.swift b/Sources/AblyChat/RoomReaction.swift
@@ -46,13 +46,13 @@ public struct RoomReaction: Sendable {
      */
     public var isSelf: Bool
 
+    // @spec CHA-ER2a
     /**
      * The user claim attached to this reaction by the server.
      *
      * Set automatically by the Ably server when a JWT contains a matching
      * `ably.room.<roomName>` claim. This is a read-only, server-provided value.
      */
-    // @spec CHA-ER2a
     public var userClaim: String?
 
     /// Memberwise initializer to create a `RoomReaction`.
diff --git a/Sources/AblyChat/Typing.swift b/Sources/AblyChat/Typing.swift
@@ -1,5 +1,24 @@
 import Ably
 
+/**
+ * Represents a user in the set of currently typing users, with associated metadata.
+ */
+public struct TypingMember: Sendable {
+    /// The client ID of the typing user.
+    public var clientID: String
+
+    /// The user claim attached to this user's typing event, if any.
+    public var userClaim: String?
+
+    /// Memberwise initializer to create a `TypingMember`.
+    ///
+    /// - Note: You should not need to use this initializer when using the Chat SDK. It is exposed only to allow users to create mock versions of the SDK's protocols.
+    public init(clientID: String, userClaim: String? = nil) {
+        self.clientID = clientID
+        self.userClaim = userClaim
+    }
+}
+
 /**
  * This interface is used to interact with typing in a chat room including subscribing to typing events and
  * fetching the current set of typing clients.
@@ -22,13 +41,24 @@ public protocol Typing: AnyObject, Sendable {
     @discardableResult
     func subscribe(_ callback: @escaping @MainActor (TypingSetEvent) -> Void) -> Subscription
 
+    // @spec CHA-T16
     /**
      * Get the current typers, a set of clientIds.
      *
+     * Deprecated per CHA-T16; use ``currentTypers`` (CHA-T18) instead.
+     *
      * - Returns: A set of clientIds that are currently typing.
      */
     var current: Set<String> { get }
 
+    // @spec CHA-T18
+    /**
+     * Gets the current set of users who are typing, with associated metadata.
+     *
+     * - Returns: An array of ``TypingMember`` for users currently typing.
+     */
+    var currentTypers: [TypingMember] { get }
+
     /**
      * Keystroke indicates that the current user is typing. This will emit a ``TypingEvent`` event to inform listening clients and begin a timer,
      * once the timer expires, another ``TypingEvent`` event will be emitted. In both cases ``TypingEvent/currentlyTyping``
@@ -95,6 +125,12 @@ public struct TypingSetEvent: Sendable {
      */
     public var currentlyTyping: Set<String>
 
+    // @spec CHA-T6d
+    /**
+     * The set of users currently typing, with associated metadata.
+     */
+    public var currentTypers: [TypingMember]
+
     /**
      * Get the details of the operation that modified the typing event.
       */
@@ -103,9 +139,10 @@ public struct TypingSetEvent: Sendable {
     /// Memberwise initializer to create a `TypingSetEvent`.
     ///
     /// - Note: You should not need to use this initializer when using the Chat SDK. It is exposed only to allow users to create mock versions of the SDK's protocols.
-    public init(type: TypingSetEventType, currentlyTyping: Set<String>, change: Change) {
+    public init(type: TypingSetEventType, currentlyTyping: Set<String>, currentTypers: [TypingMember], change: Change) {
         self.type = type
         self.currentlyTyping = currentlyTyping
+        self.currentTypers = currentTypers
         self.change = change
     }
 
@@ -116,6 +153,7 @@ public struct TypingSetEvent: Sendable {
         // swiftlint:disable:next missing_docs
         public var type: TypingEventType
 
+        // @spec CHA-T13a1
         /**
          * The user claim attached to this typing event by the server.
          *
@@ -125,7 +163,6 @@ public struct TypingSetEvent: Sendable {
          * The `userClaim` must persist across heartbeat events and inactivity timeouts
          * for a given `clientId`.
          */
-        // @spec CHA-T13a1
         public var userClaim: String?
 
         /// Memberwise initializer to create a `Change`.
diff --git a/Sources/AblyChat/TypingTimerManager.swift b/Sources/AblyChat/TypingTimerManager.swift
@@ -99,6 +99,13 @@ internal final class TypingTimerManager<AnyClock: ClockProtocol>: TypingTimerMan
         Set(whoIsTypingState.keys)
     }
 
+    /// Returns the currently typing users with associated metadata.
+    internal func currentlyTypingMembers() -> [TypingMember] {
+        whoIsTypingState.map { clientID, state in
+            TypingMember(clientID: clientID, userClaim: state.userClaim)
+        }
+    }
+
     /// Returns the stored `userClaim` for a given client, if any (CHA-T13a1).
     internal func userClaimForClient(_ clientID: String) -> String? {
         whoIsTypingState[clientID]?.userClaim
@@ -126,6 +133,8 @@ internal protocol TypingTimerManagerProtocol {
     func isCurrentlyTyping(clientID: String) -> Bool
     /// Returns the set of client IDs that we consider to currently be typing (also referred to in the spec as the "typing set").
     func currentlyTypingClientIDs() -> Set<String>
+    /// Returns the currently typing users with associated metadata.
+    func currentlyTypingMembers() -> [TypingMember]
     /// Returns the stored `userClaim` for a given client, if any (CHA-T13a1).
     func userClaimForClient(_ clientID: String) -> String?
 }
diff --git a/Tests/AblyChatTests/DefaultTypingTests.swift b/Tests/AblyChatTests/DefaultTypingTests.swift
@@ -81,6 +81,7 @@ struct DefaultTypingTests {
 
     // @specOneOf(1/2) CHA-T6a - Tests subscription receives started event
     // @specOneOf(1/2) CHA-T4a3 - Tests that publish has correct name and data
+    // @specOneOf(1/2) CHA-T6d - Tests that currentTypers is populated in started event
     @Test
     @available(iOS 16.0, tvOS 16.0, *)
     func subscribe_ReceivesStartedTypingEvent() async throws {
@@ -94,6 +95,7 @@ struct DefaultTypingTests {
             TypingSetEvent(
                 type: .setChanged,
                 currentlyTyping: [clientId],
+                currentTypers: [.init(clientID: clientId)],
                 change: .init(clientID: clientId, type: .started),
             ),
         )
@@ -103,9 +105,12 @@ struct DefaultTypingTests {
         #expect(typingEvent.change.type == .started)
         #expect(typingEvent.change.clientID == clientId)
         #expect(typingEvent.currentlyTyping == [clientId])
+        #expect(typingEvent.currentTypers.count == 1)
+        #expect(typingEvent.currentTypers[0].clientID == clientId)
     }
 
     // @specOneOf(2/2) CHA-T6a - Tests subscription receives stopped event
+    // @specOneOf(2/2) CHA-T6d - Tests that currentTypers is populated in stopped event
     @Test
     @available(iOS 16.0, tvOS 16.0, *)
     func subscribe_ReceivesStoppedTypingEvent() async throws {
@@ -119,6 +124,7 @@ struct DefaultTypingTests {
             TypingSetEvent(
                 type: .setChanged,
                 currentlyTyping: [],
+                currentTypers: [],
                 change: .init(clientID: clientId, type: .stopped),
             ),
         )
@@ -128,9 +134,12 @@ struct DefaultTypingTests {
         #expect(typingEvent.change.type == .stopped)
         #expect(typingEvent.change.clientID == clientId)
         #expect(typingEvent.currentlyTyping.isEmpty)
+        #expect(typingEvent.currentTypers.isEmpty)
     }
 
     // @spec CHA-T9 - Tests retrieving currently typing clients
+    // @spec CHA-T16 - Tests current property returns typing client IDs
+    // @spec CHA-T18 - Tests currentTypers property returns typing members
     @Test
     @available(iOS 16.0, tvOS 16.0, *)
     func get_ReturnsCurrentlyTypingClients() async throws {
@@ -147,9 +156,12 @@ struct DefaultTypingTests {
 
         // When
         let typingClients = typing.current
+        let typingMembers = typing.currentTypers
 
         // Then
         #expect(typingClients.contains("test-client"))
+        #expect(typingMembers.count == 1)
+        #expect(typingMembers[0].clientID == "test-client")
     }
 
     // @specOneOf(2/2) CHA-T4a3 - Tests that publish has ephemeral flag
diff --git a/Tests/AblyChatTests/Helpers/Sandbox.swift b/Tests/AblyChatTests/Helpers/Sandbox.swift
@@ -1,7 +1,62 @@
+import CryptoKit
 import Foundation
 
 /// Provides the ``createAPIKey()`` function to create an API key for the Ably sandbox environment.
 enum Sandbox {
+    // MARK: - JWT
+
+    /// Creates a signed Ably JWT (HS256) containing the given `userClaim` under the `ably.room.<roomName>` key.
+    ///
+    /// The returned string can be passed to `ARTTokenDetails(token:)` and used via `authCallback`.
+    static func createJWT(
+        apiKey: String,
+        clientID: String,
+        roomName: String,
+        userClaim: String,
+        ttl: TimeInterval = 3600,
+    ) -> String {
+        let parts = apiKey.split(separator: ":", maxSplits: 1)
+        let keyName = String(parts[0])
+        let keySecret = String(parts[1])
+
+        let header: [String: Any] = [
+            "typ": "JWT",
+            "alg": "HS256",
+            "kid": keyName,
+        ]
+
+        let now = Date()
+        let payload: [String: Any] = [
+            "iat": Int(now.timeIntervalSince1970),
+            "exp": Int(now.timeIntervalSince1970 + ttl),
+            "x-ably-clientId": clientID,
+            "x-ably-capability": "{\"*\":[\"*\"]}",
+            "ably.room.\(roomName)": userClaim,
+        ]
+
+        let headerData = try! JSONSerialization.data(withJSONObject: header) // swiftlint:disable:this force_try
+        let payloadData = try! JSONSerialization.data(withJSONObject: payload) // swiftlint:disable:this force_try
+
+        let headerB64 = base64URLEncode(headerData)
+        let payloadB64 = base64URLEncode(payloadData)
+
+        let signingInput = "\(headerB64).\(payloadB64)"
+        let key = SymmetricKey(data: Data(keySecret.utf8))
+        let signature = HMAC<SHA256>.authenticationCode(for: Data(signingInput.utf8), using: key)
+        let signatureB64 = base64URLEncode(Data(signature))
+
+        return "\(headerB64).\(payloadB64).\(signatureB64)"
+    }
+
+    private static func base64URLEncode(_ data: Data) -> String {
+        data.base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+    }
+
+    // MARK: - Sandbox API key
+
     private struct TestApp: Codable {
         var keys: [Key]
 
diff --git a/Tests/AblyChatTests/IntegrationTests.swift b/Tests/AblyChatTests/IntegrationTests.swift
diff --git a/Tests/AblyChatTests/Mocks/MockAblyCocoaRealtime.swift b/Tests/AblyChatTests/Mocks/MockAblyCocoaRealtime.swift
diff --git a/Tests/AblyChatTests/UserClaimTests.swift b/Tests/AblyChatTests/UserClaimTests.swift

Original file line number	Diff line number	Diff line change
`@@ -182,13 +182,13 @@ public struct PresenceMember: Sendable {`
`182`	`182`	`// swiftlint:disable:next missing_docs`
`183`	`183`	`public var updatedAt: Date`
`184`	`184`
	`185`	`+ // @spec CHA-PR6g`
`185`	`186`	`/**`
`186`	`187`	`* The user claim attached to this presence event by the server.`
`187`	`188`	`*`
`188`	`189`	`* Set automatically by the Ably server when a JWT contains a matching`
`189`	`190`	* `ably.room.<roomName>` claim. This is a read-only, server-provided value.
`190`	`191`	`*/`
`191`		`- // @spec CHA-PR6g`
`192`	`192`	`public var userClaim: String?`
`193`	`193`	`}`
`194`	`194`