Fetch older messages when scrolling up in the chat message list

Co-Authored-By: Nathan Sobo <nathan@zed.dev>

server/src/admin.rs

@@ -85,7 +85,7 @@ async fn post_user(mut request: Request) -> tide::Result {
 async fn put_user(mut request: Request) -> tide::Result {
     request.require_admin().await?;
 
-    let user_id = request.param("id")?.parse::<i32>()?;
+    let user_id = request.param("id")?.parse()?;
 
     #[derive(Deserialize)]
     struct Body {
@@ -104,14 +104,14 @@ async fn put_user(mut request: Request) -> tide::Result {
 
 async fn delete_user(request: Request) -> tide::Result {
     request.require_admin().await?;
-    let user_id = db::UserId(request.param("id")?.parse::<i32>()?);
+    let user_id = db::UserId(request.param("id")?.parse()?);
     request.db().delete_user(user_id).await?;
     Ok(tide::Redirect::new("/admin").into())
 }
 
 async fn delete_signup(request: Request) -> tide::Result {
     request.require_admin().await?;
-    let signup_id = db::SignupId(request.param("id")?.parse::<i32>()?);
+    let signup_id = db::SignupId(request.param("id")?.parse()?);
     request.db().delete_signup(signup_id).await?;
     Ok(tide::Redirect::new("/admin").into())
 }

server/src/db.rs

@@ -380,6 +380,7 @@ impl Db {
         &self,
         channel_id: ChannelId,
         count: usize,
+        before_id: Option<MessageId>,
     ) -> Result<Vec<ChannelMessage>> {
         test_support!(self, {
             let query = r#"
@@ -389,14 +390,16 @@ impl Db {
                     FROM
                         channel_messages
                     WHERE
-                        channel_id = $1
+                        channel_id = $1 AND
+                        id < $2
                     ORDER BY id DESC
-                    LIMIT $2
+                    LIMIT $3
                 ) as recent_messages
                 ORDER BY id ASC
             "#;
             sqlx::query_as(query)
                 .bind(channel_id.0)
+                .bind(before_id.unwrap_or(MessageId::MAX))
                 .bind(count as i64)
                 .fetch_all(&self.pool)
                 .await
@@ -412,6 +415,9 @@ macro_rules! id_type {
         pub struct $name(pub i32);
 
         impl $name {
+            #[allow(unused)]
+            pub const MAX: Self = Self(i32::MAX);
+
             #[allow(unused)]
             pub fn from_proto(value: u64) -> Self {
                 Self(value as i32)
@@ -512,10 +518,22 @@ pub mod tests {
                 .unwrap();
         }
 
-        let messages = db.get_recent_channel_messages(channel, 5).await.unwrap();
+        let messages = db
+            .get_recent_channel_messages(channel, 5, None)
+            .await
+            .unwrap();
         assert_eq!(
             messages.iter().map(|m| &m.body).collect::<Vec<_>>(),
             ["5", "6", "7", "8", "9"]
         );
+
+        let prev_messages = db
+            .get_recent_channel_messages(channel, 4, Some(messages[0].id))
+            .await
+            .unwrap();
+        assert_eq!(
+            prev_messages.iter().map(|m| &m.body).collect::<Vec<_>>(),
+            ["1", "2", "3", "4"]
+        );
     }
 }

server/src/rpc.rs

@@ -1,6 +1,6 @@
 use super::{
     auth,
-    db::{ChannelId, UserId},
+    db::{ChannelId, MessageId, UserId},
     AppState,
 };
 use anyhow::anyhow;
@@ -77,6 +77,8 @@ struct Channel {
     connection_ids: HashSet<ConnectionId>,
 }
 
+const MESSAGE_COUNT_PER_PAGE: usize = 50;
+
 impl Server {
     pub fn new(
         app_state: Arc<AppState>,
@@ -105,7 +107,8 @@ impl Server {
             .add_handler(Server::get_users)
             .add_handler(Server::join_channel)
             .add_handler(Server::leave_channel)
-            .add_handler(Server::send_channel_message);
+            .add_handler(Server::send_channel_message)
+            .add_handler(Server::get_channel_messages);
 
         Arc::new(server)
     }
@@ -592,7 +595,7 @@ impl Server {
         let messages = self
             .app_state
             .db
-            .get_recent_channel_messages(channel_id, 50)
+            .get_recent_channel_messages(channel_id, MESSAGE_COUNT_PER_PAGE, None)
             .await?
             .into_iter()
             .map(|msg| proto::ChannelMessage {
@@ -601,9 +604,15 @@ impl Server {
                 timestamp: msg.sent_at.unix_timestamp() as u64,
                 sender_id: msg.sender_id.to_proto(),
             })
-            .collect();
+            .collect::<Vec<_>>();
         self.peer
-            .respond(request.receipt(), proto::JoinChannelResponse { messages })
+            .respond(
+                request.receipt(),
+                proto::JoinChannelResponse {
+                    done: messages.len() < MESSAGE_COUNT_PER_PAGE,
+                    messages,
+                },
+            )
             .await?;
         Ok(())
     }
@@ -685,6 +694,54 @@ impl Server {
         Ok(())
     }
 
+    async fn get_channel_messages(
+        self: Arc<Self>,
+        request: TypedEnvelope<proto::GetChannelMessages>,
+    ) -> tide::Result<()> {
+        let user_id = self
+            .state
+            .read()
+            .await
+            .user_id_for_connection(request.sender_id)?;
+        let channel_id = ChannelId::from_proto(request.payload.channel_id);
+        if !self
+            .app_state
+            .db
+            .can_user_access_channel(user_id, channel_id)
+            .await?
+        {
+            Err(anyhow!("access denied"))?;
+        }
+
+        let messages = self
+            .app_state
+            .db
+            .get_recent_channel_messages(
+                channel_id,
+                MESSAGE_COUNT_PER_PAGE,
+                Some(MessageId::from_proto(request.payload.before_message_id)),
+            )
+            .await?
+            .into_iter()
+            .map(|msg| proto::ChannelMessage {
+                id: msg.id.to_proto(),
+                body: msg.body,
+                timestamp: msg.sent_at.unix_timestamp() as u64,
+                sender_id: msg.sender_id.to_proto(),
+            })
+            .collect::<Vec<_>>();
+        self.peer
+            .respond(
+                request.receipt(),
+                proto::GetChannelMessagesResponse {
+                    done: messages.len() < MESSAGE_COUNT_PER_PAGE,
+                    messages,
+                },
+            )
+            .await?;
+        Ok(())
+    }
+
     async fn broadcast_in_worktree<T: proto::EnvelopedMessage>(
         &self,
         worktree_id: u64,