[ECO-5342] Refactor roomID to name and roomName across SDK (#308)

* Refactor `roomID` to `name` and `roomName` across `Rooms` interface and related components for consistency.

* Removed "roomID" field from Message

* Update comments and arguments to use "name" instead of "ID"

[ECO-5342]

Author: ttypic

CONTRIBUTING.md

@@ -56,7 +56,7 @@ If you haven't worked with typed throws before, be aware of a few sharp edges:
 - It is possible to crash the compiler when using Swift Testing's `#expect(throws: …)` in combination with an `expression` that throws a typed error. See https://github.com/ably/ably-chat-swift/issues/233. A workaround that seems to work, which we're using at the moment (will be able to remove once Xcode 16.3 is released) is to move the code with a typed throw into a separate, non-typed-throw function; for example:
   ```swift
   let doIt = {
-      try await rooms.get(roomID: roomID, options: differentOptions)
+      try await rooms.get(name: name, options: differentOptions)
   }
   await #expect {
       try await doIt()

Example/AblyChatExample/ContentView.swift

@@ -40,8 +40,8 @@ struct ContentView: View {
         let screenHeight = UIScreen.main.bounds.height
     #endif
 
-    // Can be replaced with your own room ID
-    private let roomID = "DemoRoom"
+    // Can be replaced with your own room name
+    private let roomName = "DemoRoom"
 
     @State private var chatClient = Environment.current.createChatClient()
 
@@ -78,7 +78,7 @@ struct ContentView: View {
     }
 
     private func room() async throws -> Room {
-        try await chatClient.rooms.get(roomID: roomID, options: .init(occupancy: .init(enableEvents: true)))
+        try await chatClient.rooms.get(name: roomName, options: .init(occupancy: .init(enableEvents: true)))
     }
 
     private var sendTitle: String {
@@ -101,7 +101,7 @@ struct ContentView: View {
     var body: some View {
         ZStack {
             VStack {
-                Text("In \(roomID) as \(currentClientID)")
+                Text("In \(roomName) as \(currentClientID)")
                     .font(.headline)
                     .padding(5)
                 HStack {

Example/AblyChatExample/Mocks/Misc.swift

@@ -5,7 +5,7 @@ final class MockMessagesPaginatedResult: PaginatedResult {
     typealias Item = Message
 
     let clientID: String
-    let roomID: String
+    let roomName: String
     let numberOfMockMessages: Int
 
     var items: [Item] {
@@ -14,7 +14,6 @@ final class MockMessagesPaginatedResult: PaginatedResult {
                 serial: "\(Date().timeIntervalSince1970)",
                 action: .create,
                 clientID: self.clientID,
-                roomID: self.roomID,
                 text: MockStrings.randomPhrase(),
                 createdAt: Date(),
                 metadata: [:],
@@ -36,9 +35,9 @@ final class MockMessagesPaginatedResult: PaginatedResult {
 
     var current: any PaginatedResult<Item> { fatalError("Not implemented") }
 
-    init(clientID: String, roomID: String, numberOfMockMessages: Int = 3) {
+    init(clientID: String, roomName: String, numberOfMockMessages: Int = 3) {
         self.clientID = clientID
-        self.roomID = roomID
+        self.roomName = roomName
         self.numberOfMockMessages = numberOfMockMessages
     }
 

Example/AblyChatExample/Mocks/MockClients.swift

@@ -23,16 +23,16 @@ class MockRooms: Rooms {
     let clientOptions: ChatClientOptions
     private var rooms = [String: MockRoom]()
 
-    func get(roomID: String, options: RoomOptions) async throws(ARTErrorInfo) -> any Room {
-        if let room = rooms[roomID] {
+    func get(name: String, options: RoomOptions) async throws(ARTErrorInfo) -> any Room {
+        if let room = rooms[name] {
             return room
         }
-        let room = MockRoom(roomID: roomID, options: options)
-        rooms[roomID] = room
+        let room = MockRoom(name: name, options: options)
+        rooms[name] = room
         return room
     }
 
-    func release(roomID _: String) async {
+    func release(name _: String) async {
         fatalError("Not yet implemented")
     }
 
@@ -44,7 +44,7 @@ class MockRooms: Rooms {
 class MockRoom: Room {
     private let clientID = "AblyTest"
 
-    nonisolated let roomID: String
+    nonisolated let name: String
     nonisolated let options: RoomOptions
     nonisolated let messages: any Messages
     nonisolated let presence: any Presence
@@ -54,14 +54,14 @@ class MockRoom: Room {
 
     let channel: any RealtimeChannelProtocol = MockRealtime.Channel()
 
-    init(roomID: String, options: RoomOptions) {
-        self.roomID = roomID
+    init(name: String, options: RoomOptions) {
+        self.name = name
         self.options = options
-        messages = MockMessages(clientID: clientID, roomID: roomID)
-        presence = MockPresence(clientID: clientID, roomID: roomID)
-        reactions = MockRoomReactions(clientID: clientID, roomID: roomID)
-        typing = MockTyping(clientID: clientID, roomID: roomID)
-        occupancy = MockOccupancy(clientID: clientID, roomID: roomID)
+        messages = MockMessages(clientID: clientID, roomName: name)
+        presence = MockPresence(clientID: clientID, roomName: name)
+        reactions = MockRoomReactions(clientID: clientID, roomName: name)
+        typing = MockTyping(clientID: clientID, roomName: name)
+        occupancy = MockOccupancy(clientID: clientID, roomName: name)
     }
 
     var status: RoomStatus = .initialized
@@ -73,7 +73,7 @@ class MockRoom: Room {
     }
 
     func attach() async throws(ARTErrorInfo) {
-        print("Mock client attached to room with roomID: \(roomID)")
+        print("Mock client attached to room with roomName: \(name)")
     }
 
     func detach() async throws(ARTErrorInfo) {
@@ -105,7 +105,7 @@ class MockRoom: Room {
 
 class MockMessages: Messages {
     let clientID: String
-    let roomID: String
+    let roomName: String
 
     var reactions: any MessageReactions
 
@@ -116,10 +116,10 @@ class MockMessages: Messages {
 
     private let mockSubscriptions = MockMessageSubscriptionStorage<Message>()
 
-    init(clientID: String, roomID: String) {
+    init(clientID: String, roomName: String) {
         self.clientID = clientID
-        self.roomID = roomID
-        reactions = MockMessageReactions(clientID: clientID, roomID: roomID)
+        self.roomName = roomName
+        reactions = MockMessageReactions(clientID: clientID, roomName: roomName)
     }
 
     func subscribe(_ callback: @escaping @MainActor (Message) -> Void) async throws(ARTErrorInfo) -> MessageSubscriptionResponseProtocol {
@@ -129,7 +129,6 @@ class MockMessages: Messages {
                     serial: "\(Date().timeIntervalSince1970)",
                     action: .create,
                     clientID: MockStrings.names.randomElement()!,
-                    roomID: self.roomID,
                     text: MockStrings.randomPhrase(),
                     createdAt: Date(),
                     metadata: [:],
@@ -145,23 +144,22 @@ class MockMessages: Messages {
                 return message
             },
             previousMessages: { _ in
-                MockMessagesPaginatedResult(clientID: self.clientID, roomID: self.roomID)
+                MockMessagesPaginatedResult(clientID: self.clientID, roomName: self.roomName)
             },
             interval: 3.0,
             callback: callback
         )
     }
 
     func get(options _: QueryOptions) async throws(ARTErrorInfo) -> any PaginatedResult<Message> {
-        MockMessagesPaginatedResult(clientID: clientID, roomID: roomID)
+        MockMessagesPaginatedResult(clientID: clientID, roomName: roomName)
     }
 
     func send(params: SendMessageParams) async throws(ARTErrorInfo) -> Message {
         let message = Message(
             serial: "\(Date().timeIntervalSince1970)",
             action: .create,
             clientID: clientID,
-            roomID: roomID,
             text: params.text,
             createdAt: Date(),
             metadata: params.metadata ?? [:],
@@ -179,7 +177,6 @@ class MockMessages: Messages {
             serial: newMessage.serial,
             action: .update,
             clientID: clientID,
-            roomID: roomID,
             text: newMessage.text,
             createdAt: Date(),
             metadata: newMessage.metadata,
@@ -197,7 +194,6 @@ class MockMessages: Messages {
             serial: message.serial,
             action: .delete,
             clientID: clientID,
-            roomID: roomID,
             text: message.text,
             createdAt: Date(),
             metadata: message.metadata,
@@ -213,7 +209,7 @@ class MockMessages: Messages {
 
 class MockMessageReactions: MessageReactions {
     let clientID: String
-    let roomID: String
+    let roomName: String
 
     var clientIDs: Set<String> = []
     var messageSerials: [String] = []
@@ -241,9 +237,9 @@ class MockMessageReactions: MessageReactions {
         )
     }
 
-    init(clientID: String, roomID: String) {
+    init(clientID: String, roomName: String) {
         self.clientID = clientID
-        self.roomID = roomID
+        self.roomName = roomName
     }
 
     func send(to messageSerial: String, params: SendMessageReactionParams) async throws(ARTErrorInfo) {
@@ -310,13 +306,13 @@ class MockMessageReactions: MessageReactions {
 
 class MockRoomReactions: RoomReactions {
     let clientID: String
-    let roomID: String
+    let roomName: String
 
     private let mockSubscriptions = MockSubscriptionStorage<Reaction>()
 
-    init(clientID: String, roomID: String) {
+    init(clientID: String, roomName: String) {
         self.clientID = clientID
-        self.roomID = roomID
+        self.roomName = roomName
     }
 
     func send(params: SendReactionParams) async throws(ARTErrorInfo) {
@@ -352,13 +348,13 @@ class MockRoomReactions: RoomReactions {
 
 class MockTyping: Typing {
     let clientID: String
-    let roomID: String
+    let roomName: String
 
     private let mockSubscriptions = MockSubscriptionStorage<TypingSetEvent>()
 
-    init(clientID: String, roomID: String) {
+    init(clientID: String, roomName: String) {
         self.clientID = clientID
-        self.roomID = roomID
+        self.roomName = roomName
     }
 
     @discardableResult
@@ -406,13 +402,13 @@ class MockTyping: Typing {
 
 class MockPresence: Presence {
     let clientID: String
-    let roomID: String
+    let roomName: String
 
     private let mockSubscriptions = MockSubscriptionStorage<PresenceEvent>()
 
-    init(clientID: String, roomID: String) {
+    init(clientID: String, roomName: String) {
         self.clientID = clientID
-        self.roomID = roomID
+        self.roomName = roomName
     }
 
     private func createSubscription(callback: @escaping @MainActor (PresenceEvent) -> Void) -> SubscriptionProtocol {
@@ -526,13 +522,13 @@ class MockPresence: Presence {
 
 class MockOccupancy: Occupancy {
     let clientID: String
-    let roomID: String
+    let roomName: String
 
     private let mockSubscriptions = MockSubscriptionStorage<OccupancyEvent>()
 
-    init(clientID: String, roomID: String) {
+    init(clientID: String, roomName: String) {
         self.clientID = clientID
-        self.roomID = roomID
+        self.roomName = roomName
     }
 
     @discardableResult

README.md

@@ -111,7 +111,7 @@ Task {
 
 // Get a chat room for the tutorial
 let room = try await chatClient.rooms.get(
-    roomID: "readme-getting-started")
+    name: "readme-getting-started")
 
 // Add a listener to observe changes to the chat rooms status
 let statusSubscription = room.onStatusChange()
@@ -140,7 +140,7 @@ _ = try await room.messages.send(
 // Wait 5 seconds before closing the connection so we have plenty of time to receive the message we just sent
 // This disconnects the client from Ably servers
 try await Task.sleep(nanoseconds: 5 * NSEC_PER_SEC)
-await chatClient.rooms.release(roomID: "readme-getting-started")
+await chatClient.rooms.release(name: "readme-getting-started")
 realtime.close()
 print("Connection closed")
 ```