Building a Mobile Chat App Using Realm – The New and Easier Way

1
import SwiftUI
2
import RealmSwift
3
let app = RealmSwift.App(id: "rchat-xxxxx") // TODO: Set the Realm application ID
4
@main
5
struct RChatApp: SwiftUI.App {
6
   @StateObject var state = AppState()
7
8
   var body: some Scene {
9
      WindowGroup {
10
            ContentView()
11
               .environmentObject(state)
12
      }
13
   }
14
}

1
import SwiftUI
2
import RealmSwift
3
let app = RealmSwift.App(id: "rchat-xxxxx") // TODO: Set the Realm application ID
4
@main
5
struct RChatApp: SwiftUI.App {
6
   @StateObject var state = AppState()
7
   var body: some Scene {
8
      WindowGroup {
9
            ContentView()
10
               .environmentObject(state)
11
      }
12
   }
13
}

1
import Foundation
2
import RealmSwift
3
4
@objcMembers class User: Object, ObjectKeyIdentifiable {
5
   dynamic var _id = UUID().uuidString
6
   dynamic var partition = "" // "user=_id"
7
   dynamic var userName = ""
8
   dynamic var userPreferences: UserPreferences?
9
   dynamic var lastSeenAt: Date?
10
   var conversations = List<Conversation>()
11
   dynamic var presence = "Off-Line"
12
13
   override static func primaryKey() -> String? {
14
      return "_id"
15
   }
16
}

1
class AppState: ObservableObject {
2
   ...
3
   var user: User?
4
   ...
5
}

1
class AppState: ObservableObject {
2
   ...
3
   let loginPublisher = PassthroughSubject<RealmSwift.User, Error>()
4
   let logoutPublisher = PassthroughSubject<Void, Error>()
5
   let userRealmPublisher = PassthroughSubject<Realm, Error>()
6
   ...
7
}

1
init() {
2
   _  = app.currentUser?.logOut()
3
   initLoginPublisher()
4
   initUserRealmPublisher()
5
   initLogoutPublisher()
6
}

1
func initLoginPublisher() {
2
loginPublisher
3
   .receive(on: DispatchQueue.main)
4
   .flatMap { user -> RealmPublishers.AsyncOpenPublisher in
5
         self.shouldIndicateActivity = true
6
         let realmConfig = user.configuration(partitionValue: "user=\(user.id)")
7
         return Realm.asyncOpen(configuration: realmConfig)
8
   }
9
   .receive(on: DispatchQueue.main)
10
   .map {
11
         return $0
12
   }
13
   .subscribe(userRealmPublisher)
14
   .store(in: &self.cancellables)
15
}

1
func initUserRealmPublisher() {
2
   userRealmPublisher
3
      .sink(receiveCompletion: { result in
4
            if case let .failure(error) = result {
5
               self.error = "Failed to log in and open user realm: \(error.localizedDescription)"
6
            }
7
      }, receiveValue: { realm in
8
            print("User Realm User file location: \(realm.configuration.fileURL!.path)")
9
            self.userRealm = realm
10
            self.user = realm.objects(User.self).first
11
            do {
12
               try realm.write {
13
                  self.user?.presenceState = .onLine
14
               }
15
            } catch {
16
               self.error = "Unable to open Realm write transaction"
17
            }
18
            self.shouldIndicateActivity = false
19
      })
20
      .store(in: &cancellables)
21
}

1
func initLogoutPublisher() {
2
  logoutPublisher
3
      .receive(on: DispatchQueue.main)
4
      .sink(receiveCompletion: { _ in
5
      }, receiveValue: { _ in
6
         self.user = nil
7
      })
8
      .store(in: &cancellables)
9
}

1
   exports = function({user}) {
2
      const db = context.services.get("mongodb-atlas").db("RChat");
3
      const userCollection = db.collection("User");
4
      const partition = `user=${user.id}`;
5
      const defaultLocation = context.values.get("defaultLocation");
6
      const userPreferences = {
7
         displayName: ""
8
      };
9
      const userDoc = {
10
         _id: user.id,
11
         partition: partition,
12
         userName: user.data.email,
13
         userPreferences: userPreferences,
14
         location: context.values.get("defaultLocation"),
15
         lastSeenAt: null,
16
         presence:"Off-Line",
17
         conversations: []
18
      };
19
      return userCollection.insertOne(userDoc)
20
      .then(result => {
21
         console.log(`Added User document with _id: ${result.insertedId}`);
22
      }, error => {
23
         console.log(`Failed to insert User document: ${error}`);
24
      });
25
   };

1
{
2
"bsonType": "object",
3
"properties": {
4
   "_id": {
5
      "bsonType": "string"
6
   },
7
   "conversations": {
8
      "bsonType": "array",
9
      "items": {
10
      "bsonType": "object",
11
      "properties": {
12
         "displayName": {
13
            "bsonType": "string"
14
         },
15
         "id": {
16
            "bsonType": "string"
17
         },
18
         "members": {
19
            "bsonType": "array",
20
            "items": {
21
            "bsonType": "object",
22
            "properties": {
23
               "membershipStatus": {
24
                  "bsonType": "string"
25
               },
26
               "userName": {
27
                  "bsonType": "string"
28
               }
29
            },
30
            "required": [
31
               "membershipStatus",
32
               "userName"
33
            ],
34
            "title": "Member"
35
            }
36
         },
37
         "unreadCount": {
38
            "bsonType": "long"
39
         }
40
      },
41
      "required": [
42
         "unreadCount",
43
         "id",
44
         "displayName"
45
      ],
46
      "title": "Conversation"
47
      }
48
   },
49
   "lastSeenAt": {
50
      "bsonType": "date"
51
   },
52
   "partition": {
53
      "bsonType": "string"
54
   },
55
   "presence": {
56
      "bsonType": "string"
57
   },
58
   "userName": {
59
      "bsonType": "string"
60
   },
61
   "userPreferences": {
62
      "bsonType": "object",
63
      "properties": {
64
      "avatarImage": {
65
         "bsonType": "object",
66
         "properties": {
67
            "_id": {
68
            "bsonType": "string"
69
            },
70
            "date": {
71
            "bsonType": "date"
72
            },
73
            "picture": {
74
            "bsonType": "binData"
75
            },
76
            "thumbNail": {
77
            "bsonType": "binData"
78
            }
79
         },
80
         "required": [
81
            "_id",
82
            "date"
83
         ],
84
         "title": "Photo"
85
      },
86
      "displayName": {
87
         "bsonType": "string"
88
      }
89
      },
90
      "required": [],
91
      "title": "UserPreferences"
92
   }
93
},
94
"required": [
95
   "_id",
96
   "partition",
97
   "userName",
98
   "presence"
99
],
100
"title": "User"
101
}

1
{
2
"bsonType": "object",
3
"properties": {
4
   "_id": {
5
      "bsonType": "string"
6
   },
7
   "avatarImage": {
8
      "bsonType": "object",
9
      "properties": {
10
      "_id": {
11
         "bsonType": "string"
12
      },
13
      "date": {
14
         "bsonType": "date"
15
      },
16
      "picture": {
17
         "bsonType": "binData"
18
      },
19
      "thumbNail": {
20
         "bsonType": "binData"
21
      }
22
      },
23
      "required": [
24
      "_id",
25
      "date"
26
      ],
27
      "title": "Photo"
28
   },
29
   "displayName": {
30
      "bsonType": "string"
31
   },
32
   "lastSeenAt": {
33
      "bsonType": "date"
34
   },
35
   "partition": {
36
      "bsonType": "string"
37
   },
38
   "presence": {
39
      "bsonType": "string"
40
   },
41
   "userName": {
42
      "bsonType": "string"
43
   }
44
},
45
"required": [
46
   "_id",
47
   "partition",
48
   "presence",
49
   "userName"
50
],
51
"title": "Chatster"
52
}

1
{
2
"bsonType": "object",
3
"properties": {
4
   "_id": {
5
      "bsonType": "string"
6
   },
7
   "author": {
8
      "bsonType": "string"
9
   },
10
   "image": {
11
      "bsonType": "object",
12
      "properties": {
13
      "_id": {
14
         "bsonType": "string"
15
      },
16
      "date": {
17
         "bsonType": "date"
18
      },
19
      "picture": {
20
         "bsonType": "binData"
21
      },
22
      "thumbNail": {
23
         "bsonType": "binData"
24
      }
25
      },
26
      "required": [
27
      "_id",
28
      "date"
29
      ],
30
      "title": "Photo"
31
   },
32
   "location": {
33
      "bsonType": "array",
34
      "items": {
35
      "bsonType": "double"
36
      }
37
   },
38
   "partition": {
39
      "bsonType": "string"
40
   },
41
   "text": {
42
      "bsonType": "string"
43
   },
44
   "timestamp": {
45
      "bsonType": "date"
46
   }
47
},
48
"required": [
49
   "_id",
50
   "partition",
51
   "text",
52
   "timestamp"
53
],
54
"title": "ChatMessage"
55
}

1
{
2
   "%%true": {
3
      "%function": {
4
         "arguments": [
5
         "%%partition"
6
         ],
7
         "name": "canReadPartition"
8
      }
9
   }
10
}

1
{
2
   "%%true": {
3
      "%function": {
4
         "arguments": [
5
         "%%partition"
6
         ],
7
         "name": "canWritePartition"
8
      }
9
   }
10
}

1
exports = function(partition) {
2
   console.log(`Checking if can sync a read for partition = ${partition}`);
3
   const db = context.services.get("mongodb-atlas").db("RChat");
4
   const chatsterCollection = db.collection("Chatster");
5
   const userCollection = db.collection("User");
6
   const chatCollection = db.collection("ChatMessage");
7
   const user = context.user;
8
   let partitionKey = "";
9
   let partitionVale = "";
10
   const splitPartition = partition.split("=");
11
   if (splitPartition.length == 2) {
12
      partitionKey = splitPartition[0];
13
      partitionValue = splitPartition[1];
14
      console.log(`Partition key = ${partitionKey}; partition value = ${partitionValue}`);
15
   } else {
16
      console.log(`Couldn't extract the partition key/value from ${partition}`);
17
      return false;
18
   }
19
   switch (partitionKey) {
20
   case "user":
21
      console.log(`Checking if partitionValue(${partitionValue}) matches user.id(${user.id}) – ${partitionKey === user.id}`);
22
      return partitionValue === user.id;
23
   case "conversation":
24
      console.log(`Looking up User document for _id = ${user.id}`);
25
      return userCollection.findOne({ _id: user.id })
26
      .then (userDoc => {
27
      if (userDoc.conversations) {
28
         let foundMatch = false;
29
         userDoc.conversations.forEach( conversation => {
30
            console.log(`Checking if conversaion.id (${conversation.id}) === ${partitionValue}`)
31
            if (conversation.id === partitionValue) {
32
            console.log(`Found matching conversation element for id = ${partitionValue}`);
33
            foundMatch = true;
34
            }
35
         });
36
         if (foundMatch) {
37
            console.log(`Found Match`);
38
            return true;
39
         } else {
40
            console.log(`Checked all of the user's conversations but found none with id == ${partitionValue}`);
41
            return false;
42
         }
43
      } else {
44
         console.log(`No conversations attribute in User doc`);
45
         return false;
46
      }
47
      }, error => {
48
      console.log(`Unable to read User document: ${error}`);
49
      return false;
50
      });
51
   case "all-users":
52
      console.log(`Any user can read all-users partitions`);
53
      return true;
54
   default:
55
      console.log(`Unexpected partition key: ${partitionKey}`);
56
      return false;
57
   }
58
};

1
exports = function(partition) {
2
console.log(`Checking if can sync a write for partition = ${partition}`);
3
const db = context.services.get("mongodb-atlas").db("RChat");
4
const chatsterCollection = db.collection("Chatster");
5
const userCollection = db.collection("User");
6
const chatCollection = db.collection("ChatMessage");
7
const user = context.user;
8
let partitionKey = "";
9
let partitionVale = "";
10
const splitPartition = partition.split("=");
11
if (splitPartition.length == 2) {
12
   partitionKey = splitPartition[0];
13
   partitionValue = splitPartition[1];
14
   console.log(`Partition key = ${partitionKey}; partition value = ${partitionValue}`);
15
} else {
16
   console.log(`Couldn't extract the partition key/value from ${partition}`);
17
   return false;
18
}
19
   switch (partitionKey) {
20
   case "user":
21
      console.log(`Checking if partitionKey(${partitionValue}) matches user.id(${user.id}) – ${partitionKey === user.id}`);
22
      return partitionValue === user.id;
23
   case "conversation":
24
      console.log(`Looking up User document for _id = ${user.id}`);
25
      return userCollection.findOne({ _id: user.id })
26
      .then (userDoc => {
27
      if (userDoc.conversations) {
28
         let foundMatch = false;
29
         userDoc.conversations.forEach( conversation => {
30
            console.log(`Checking if conversaion.id (${conversation.id}) === ${partitionValue}`)
31
            if (conversation.id === partitionValue) {
32
            console.log(`Found matching conversation element for id = ${partitionValue}`);
33
            foundMatch = true;
34
            }
35
         });
36
         if (foundMatch) {
37
            console.log(`Found Match`);
38
            return true;
39
         } else {
40
            console.log(`Checked all of the user's conversations but found none with id == ${partitionValue}`);
41
            return false;
42
         }
43
      } else {
44
         console.log(`No conversations attribute in User doc`);
45
         return false;
46
      }
47
      }, error => {
48
      console.log(`Unable to read User document: ${error}`);
49
      return false;
50
      });
51
   case "all-users":
52
      console.log(`No user can write to an all-users partitions`);
53
      return false;
54
   default:
55
      console.log(`Unexpected partition key: ${partitionKey}`);
56
      return false;
57
   }
58
};

1
exports = function(changeEvent) {
2
   const db = context.services.get("mongodb-atlas").db("RChat");
3
   const chatster = db.collection("Chatster");
4
   const userCollection = db.collection("User");
5
   const docId = changeEvent.documentKey._id;
6
   const user = changeEvent.fullDocument;
7
   let conversationsChanged = false;
8
   console.log(`Mirroring user for docId=${docId}. operationType = ${changeEvent.operationType}`);
9
   switch (changeEvent.operationType) {
10
      case "insert":
11
      case "replace":
12
      case "update":
13
      console.log(`Writing data for ${user.userName}`);
14
      let chatsterDoc = {
15
            _id: user._id,
16
            partition: "all-users=all-the-users",
17
            userName: user.userName,
18
            lastSeenAt: user.lastSeenAt,
19
            presence: user.presence
20
      };
21
      if (user.userPreferences) {
22
            const prefs = user.userPreferences;
23
            chatsterDoc.displayName = prefs.displayName;
24
            if (prefs.avatarImage && prefs.avatarImage._id) {
25
               console.log(`Copying avatarImage`);
26
               chatsterDoc.avatarImage = prefs.avatarImage;
27
               console.log(`id of avatarImage = ${prefs.avatarImage._id}`);
28
            }
29
      }
30
      chatster.replaceOne({ _id: user._id }, chatsterDoc, { upsert: true })
31
      .then (() => {
32
            console.log(`Wrote Chatster document for _id: ${docId}`);
33
      }, error => {
34
            console.log(`Failed to write Chatster document for _id=${docId}: ${error}`);
35
      });
36
37
      if (user.conversations && user.conversations.length > 0) {
38
            for (i = 0; i < user.conversations.length; i++) {
39
               let membersToAdd = [];
40
               if (user.conversations[i].members.length > 0) {
41
                  for (j = 0; j < user.conversations[i].members.length; j++) {
42
                        if (user.conversations[i].members[j].membershipStatus == "User added, but invite pending") {
43
                           membersToAdd.push(user.conversations[i].members[j].userName);
44
                           user.conversations[i].members[j].membershipStatus = "Membership active";
45
                           conversationsChanged = true;
46
                        }
47
                  }
48
               }
49
               if (membersToAdd.length > 0) {
50
                  userCollection.updateMany({userName: {$in: membersToAdd}}, {$push: {conversations: user.conversations[i]}})
51
                  .then (result => {
52
                        console.log(`Updated ${result.modifiedCount} other User documents`);
53
                  }, error => {
54
                        console.log(`Failed to copy new conversation to other users: ${error}`);
55
                  });
56
               }
57
            }
58
      }
59
      if (conversationsChanged) {
60
            userCollection.updateOne({_id: user._id}, {$set: {conversations: user.conversations}});
61
      }
62
      break;
63
      case "delete":
64
      chatster.deleteOne({_id: docId})
65
      .then (() => {
66
            console.log(`Deleted Chatster document for _id: ${docId}`);
67
      }, error => {
68
            console.log(`Failed to delete Chatster document for _id=${docId}: ${error}`);
69
      });
70
      break;
71
   }
72
};

1
@EnvironmentObject var state: AppState
2
...
3
if state.loggedIn {
4
   if (state.user != nil) && !state.user!.isProfileSet || showingProfileView {
5
      SetProfileView(isPresented: $showingProfileView)
6
            .environment(\.realmConfiguration, app.currentUser!.configuration(partitionValue: "user=\(state.user?._id ?? "")"))
7
   } else {
8
      ConversationListView()
9
            .environment(\.realmConfiguration, app.currentUser!.configuration(partitionValue: "user=\(state.user?._id ?? "")"))
10
      .navigationBarTitle("Chats", displayMode: .inline)
11
      .navigationBarItems(
12
            trailing: state.loggedIn && !state.shouldIndicateActivity ? UserAvatarView(
13
               photo: state.user?.userPreferences?.avatarImage,
14
               online: true) { showingProfileView.toggle() } : nil
15
      )
16
   }
17
} else {
18
   LoginView()
19
}
20
...

1
var loggedIn: Bool {
2
   app.currentUser != nil && user != nil && app.currentUser?.state == .loggedIn
3
}

1
...
2
CallToActionButton(
3
   title: newUser ? "Register User" : "Log In",
4
   action: { self.userAction(username: self.username, password: self.password) })
5
...
6
private func userAction(username: String, password: String) {
7
   state.shouldIndicateActivity = true
8
   if newUser {
9
      signup(username: username, password: password)
10
   } else {
11
      login(username: username, password: password)
12
   }
13
}

1
private func signup(username: String, password: String) {
2
   if username.isEmpty || password.isEmpty {
3
      state.shouldIndicateActivity = false
4
      return
5
   }
6
   self.state.error = nil
7
   app.emailPasswordAuth.registerUser(email: username, password: password)
8
      .receive(on: DispatchQueue.main)
9
      .sink(receiveCompletion: {
10
            state.shouldIndicateActivity = false
11
            switch $0 {
12
            case .finished:
13
               break
14
            case .failure(let error):
15
               self.state.error = error.localizedDescription
16
            }
17
      }, receiveValue: {
18
            self.state.error = nil
19
            login(username: username, password: password)
20
      })
21
      .store(in: &state.cancellables)
22
}

1
private func login(username: String, password: String) {
2
   if username.isEmpty || password.isEmpty {
3
      state.shouldIndicateActivity = false
4
      return
5
   }
6
   self.state.error = nil
7
   app.login(credentials: .emailPassword(email: username, password: password))
8
      .receive(on: DispatchQueue.main)
9
      .sink(receiveCompletion: {
10
            state.shouldIndicateActivity = false
11
            switch $0 {
12
            case .finished:
13
               break
14
            case .failure(let error):
15
               self.state.error = error.localizedDescription
16
            }
17
      }, receiveValue: {
18
            self.state.error = nil
19
            state.loginPublisher.send($0)
20
      })
21
      .store(in: &state.cancellables)
22
}

1
...
2
@EnvironmentObject var state: AppState
3
...
4
.onAppear { initData() }
5
...
6
private func initData() {
7
   displayName = state.user?.userPreferences?.displayName ?? ""
8
   photo = state.user?.userPreferences?.avatarImage
9
}

1
SetProfileView(isPresented: $showingProfileView)
2
   .environment(\.realmConfiguration,
3
               app.currentUser!.configuration(partitionValue: "user=\(state.user?._id ?? "")"))

1
...
2
@EnvironmentObject var state: AppState
3
@Environment(\.realm) var userRealm
4
...
5
CallToActionButton(title: "Save User Profile", action: saveProfile)
6
...
7
private func saveProfile() {
8
   state.shouldIndicateActivity = true
9
   do {
10
      try userRealm.write {
11
            state.user?.userPreferences?.displayName = displayName
12
            if photoAdded {
13
               guard let newPhoto = photo else {
14
                  print("Missing photo")
15
                  state.shouldIndicateActivity = false
16
                  return
17
               }
18
               state.user?.userPreferences?.avatarImage = newPhoto
19
            }
20
            state.user?.presenceState = .onLine
21
      }
22
   } catch {
23
      state.error = "Unable to open Realm write transaction"
24
   }
25
}

1
if state.loggedIn {
2
   if (state.user != nil) && !state.user!.isProfileSet || showingProfileView {
3
      SetProfileView(isPresented: $showingProfileView)
4
            .environment(\.realmConfiguration,
5
                           app.currentUser!.configuration(partitionValue: "user=\(state.user?._id ?? "")"))
6
   } else {
7
      ConversationListView()
8
            .environment(\.realmConfiguration,
9
               app.currentUser!.configuration(partitionValue: "user=\(state.user?._id ?? "")"))
10
      .navigationBarTitle("Chats", displayMode: .inline)
11
      .navigationBarItems(
12
            trailing: state.loggedIn && !state.shouldIndicateActivity ? UserAvatarView(
13
               photo: state.user?.userPreferences?.avatarImage,
14
               online: true) { showingProfileView.toggle() } : nil
15
      )
16
   }
17
} else {
18
   LoginView()
19
}

1
@ObservedResults(User.self) var users

1
@ObservedResults(User.self) var users
2
...
3
private let sortDescriptors = [
4
   SortDescriptor(keyPath: "unreadCount", ascending: false),
5
   SortDescriptor(keyPath: "displayName", ascending: true)
6
]
7
...
8
if let conversations = users[0].conversations.sorted(by: sortDescriptors) {
9
   List {
10
      ForEach(conversations) { conversation in
11
            Button(action: {
12
               self.conversation = conversation
13
               showConversation.toggle()
14
            }) { ConversationCardView(conversation: conversation, isPreview: isPreview) }
15
      }
16
   }
17
   ...
18
}

1
.sheet(isPresented: $showingAddChat) {
2
   NewConversationView()
3
      .environmentObject(state)
4
      .environment(\.realmConfiguration, app.currentUser!.configuration(partitionValue: "all-users=all-the-users"))

1
@ObservedResults(Chatster.self) var chatsters

1
code content
2
SaveConversationButton(name: name, members: members, done: { presentationMode.wrappedValue.dismiss() })
3
   .environment(\.realmConfiguration,
4
                app.currentUser!.configuration(partitionValue: "user=\(state.user?._id ?? "")"))

1
@ObservedResults(Chatster.self) var chatsters
2
...
3
private func searchUsers() {
4
   var candidateChatsters: Results<Chatster>
5
   if candidateMember == "" {
6
      candidateChatsters = chatsters
7
   } else {
8
      let predicate = NSPredicate(format: "userName CONTAINS[cd] %@", candidateMember)
9
      candidateChatsters = chatsters.filter(predicate)
10
   }
11
   candidateMembers = []
12
   candidateChatsters.forEach { chatster in
13
      if !members.contains(chatster.userName) && chatster.userName != state.user?.userName {
14
            candidateMembers.append(chatster.userName)
15
      }
16
   }
17
}

1
exports = function(changeEvent) {
2
   if (changeEvent.operationType != "insert") {
3
      console.log(`ChatMessage ${changeEvent.operationType} event – currently ignored.`);
4
      return;
5
   }
6
7
   console.log(`ChatMessage Insert event being processed`);
8
   let userCollection = context.services.get("mongodb-atlas").db("RChat").collection("User");
9
   let chatMessage = changeEvent.fullDocument;
10
   let conversation = "";
11
12
   if (chatMessage.partition) {
13
      const splitPartition = chatMessage.partition.split("=");
14
      if (splitPartition.length == 2) {
15
            conversation = splitPartition[1];
16
            console.log(`Partition/conversation = ${conversation}`);
17
      } else {
18
            console.log("Couldn't extract the conversation from partition ${chatMessage.partition}");
19
            return;
20
      }
21
   } else {
22
      console.log("partition not set");
23
      return;
24
   }
25
26
   const matchingUserQuery = {
27
      conversations: {
28
            $elemMatch: {
29
               id: conversation
30
            }
31
      }
32
   };
33
34
   const updateOperator = {
35
      $inc: {
36
            "conversations.$[element].unreadCount": 1
37
      }
38
   };
39
40
   const arrayFilter = {
41
      arrayFilters:[
42
            {
43
               "element.id": conversation
44
            }
45
      ]
46
   };
47
48
   userCollection.updateMany(matchingUserQuery, updateOperator, arrayFilter)
49
   .then ( result => {
50
      console.log(`Matched ${result.matchedCount} User docs; updated ${result.modifiedCount}`);
51
   }, error => {
52
      console.log(`Failed to match and update User docs: ${error}`);
53
   });
54
};

1
ChatRoomBubblesView(conversation: conversation)
2
   .environment(\.realmConfiguration, app.currentUser!.configuration(partitionValue: "conversation=\(conversation.id)"))

1
@ObservedResults(ChatMessage.self,
2
   sortDescriptor: SortDescriptor(keyPath: "timestamp", ascending: true)) var chats.

1
@State private var realmChatsNotificationToken: NotificationToken?
2
@State private var latestChatId = ""
3
...
4
ScrollView(.vertical) {
5
   ScrollViewReader { (proxy: ScrollViewProxy) in
6
      VStack {
7
            ForEach(chats) { chatMessage in
8
               ChatBubbleView(chatMessage: chatMessage,
9
                              authorName: chatMessage.author != state.user?.userName ? chatMessage.author : nil,
10
                              isPreview: isPreview)
11
            }
12
      }
13
      .onAppear {
14
            scrollToBottom()
15
            withAnimation(.linear(duration: 0.2)) {
16
               proxy.scrollTo(latestChatId, anchor: .bottom)
17
            }
18
      }
19
      .onChange(of: latestChatId) { target in
20
            withAnimation {
21
               proxy.scrollTo(target, anchor: .bottom)
22
            }
23
      }
24
   }
25
}
26
...
27
.onAppear { loadChatRoom() }
28
.onDisappear { closeChatRoom() }
29
...
30
private func loadChatRoom() {
31
   scrollToBottom()
32
   realmChatsNotificationToken = chats.thaw()?.observe { _ in
33
      scrollToBottom()
34
   }
35
}
36
37
private func closeChatRoom() {
38
   if let token = realmChatsNotificationToken {
39
      token.invalidate()
40
   }
41
}
42
43
private func scrollToBottom() {
44
   latestChatId = chats.last?._id ?? ""
45
}

1
@ObservedResults(ChatMessage.self, sortDescriptor: SortDescriptor(keyPath: "timestamp", ascending: true)) var chats
2
...
3
private func sendMessage(chatMessage: ChatMessage) {
4
   guard let conversataionString = conversation else {
5
      print("comversation not set")
6
      return
7
   }
8
   chatMessage.conversationId = conversataionString.id
9
   $chats.append(chatMessage)
10
}