TEMP

crates/collab/src/db.rs

@@ -618,8 +618,8 @@ impl ChannelMember {
 pub struct ChannelsForUser {
     pub channels: Vec<Channel>,
     pub channel_participants: HashMap<ChannelId, Vec<UserId>>,
-    pub unseen_buffer_changes: Vec<proto::UnseenChannelBufferChange>,
-    pub channel_messages: Vec<proto::UnseenChannelMessage>,
+    pub latest_buffer_versions: Vec<proto::ChannelBufferVersion>,
+    pub latest_channel_messages: Vec<proto::ChannelMessageId>,
 }
 
 #[derive(Debug)]

crates/collab/src/db/queries/channels.rs

@@ -691,15 +691,13 @@ impl Database {
             .unseen_channel_buffer_changes(user_id, &channel_ids, &*tx)
             .await?;
 
-        let unseen_messages = self
-            .unseen_channel_messages(user_id, &channel_ids, &*tx)
-            .await?;
+        let latest_messages = self.latest_channel_messages(&channel_ids, &*tx).await?;
 
         Ok(ChannelsForUser {
             channels,
             channel_participants,
-            unseen_buffer_changes: channel_buffer_changes,
-            channel_messages: unseen_messages,
+            latest_buffer_versions: channel_buffer_changes,
+            latest_channel_messages: latest_messages,
         })
     }
 

crates/collab/src/db/queries/messages.rs

@@ -385,25 +385,11 @@ impl Database {
         Ok(())
     }
 
-    /// Returns the unseen messages for the given user in the specified channels.
-    pub async fn unseen_channel_messages(
+    pub async fn latest_channel_messages(
         &self,
-        user_id: UserId,
         channel_ids: &[ChannelId],
         tx: &DatabaseTransaction,
-    ) -> Result<Vec<proto::UnseenChannelMessage>> {
-        let mut observed_messages_by_channel_id = HashMap::default();
-        let mut rows = observed_channel_messages::Entity::find()
-            .filter(observed_channel_messages::Column::UserId.eq(user_id))
-            .filter(observed_channel_messages::Column::ChannelId.is_in(channel_ids.iter().copied()))
-            .stream(&*tx)
-            .await?;
-
-        while let Some(row) = rows.next().await {
-            let row = row?;
-            observed_messages_by_channel_id.insert(row.channel_id, row);
-        }
-        drop(rows);
+    ) -> Result<Vec<proto::ChannelMessageId>> {
         let mut values = String::new();
         for id in channel_ids {
             if !values.is_empty() {
@@ -412,10 +398,6 @@ impl Database {
             write!(&mut values, "({})", id).unwrap();
         }
 
-        if values.is_empty() {
-            return Ok(Default::default());
-        }
-
         let sql = format!(
             r#"
             SELECT
@@ -437,26 +419,20 @@ impl Database {
         );
 
         let stmt = Statement::from_string(self.pool.get_database_backend(), sql);
-        let last_messages = channel_message::Model::find_by_statement(stmt)
-            .all(&*tx)
+        let mut last_messages = channel_message::Model::find_by_statement(stmt)
+            .stream(&*tx)
             .await?;
 
-        let mut changes = Vec::new();
-        for last_message in last_messages {
-            if let Some(observed_message) =
-                observed_messages_by_channel_id.get(&last_message.channel_id)
-            {
-                if observed_message.channel_message_id == last_message.id {
-                    continue;
-                }
-            }
-            changes.push(proto::UnseenChannelMessage {
-                channel_id: last_message.channel_id.to_proto(),
-                message_id: last_message.id.to_proto(),
+        let mut results = Vec::new();
+        while let Some(result) = last_messages.next().await {
+            let message = result?;
+            results.push(proto::ChannelMessageId {
+                channel_id: message.channel_id.to_proto(),
+                message_id: message.id.to_proto(),
             });
         }
 
-        Ok(changes)
+        Ok(results)
     }
 
     /// Removes the channel message with the given ID.

crates/collab/src/rpc.rs

@@ -2842,25 +2842,27 @@ async fn update_channel_buffer(
 
     let pool = &*session.connection_pool().await;
 
-    broadcast(
-        None,
-        non_collaborators
-            .iter()
-            .flat_map(|user_id| pool.user_connection_ids(*user_id)),
-        |peer_id| {
-            session.peer.send(
-                peer_id.into(),
-                proto::UpdateChannels {
-                    unseen_channel_buffer_changes: vec![proto::UnseenChannelBufferChange {
-                        channel_id: channel_id.to_proto(),
-                        epoch: epoch as u64,
-                        version: version.clone(),
-                    }],
-                    ..Default::default()
-                },
-            )
-        },
-    );
+    todo!()
+
+    // broadcast(
+    //     None,
+    //     non_collaborators
+    //         .iter()
+    //         .flat_map(|user_id| pool.user_connection_ids(*user_id)),
+    //     |peer_id| {
+    //         session.peer.send(
+    //             peer_id.into(),
+    //             proto::UpdateChannels {
+    //                 unseen_channel_buffer_changes: vec![proto::UnseenChannelBufferChange {
+    //                     channel_id: channel_id.to_proto(),
+    //                     epoch: epoch as u64,
+    //                     version: version.clone(),
+    //                 }],
+    //                 ..Default::default()
+    //             },
+    //         )
+    //     },
+    // );
 
     Ok(())
 }
@@ -3315,8 +3317,8 @@ fn build_channels_update(
         update.channels.push(channel.to_proto());
     }
 
-    update.unseen_channel_buffer_changes = channels.unseen_buffer_changes;
-    update.unseen_channel_messages = channels.channel_messages;
+    update.latest_channel_buffer_versions = channels.latest_buffer_versions;
+    update.latest_channel_message_ids = channels.latest_channel_messages;
 
     for (channel_id, participants) in channels.channel_participants {
         update