List messages per channel.

5 files changed, 75 insertions, 21 deletions

diff --git a/src/message/app.rs b/src/message/app.rs
index 1d34c14..fd6a334 100644
--- a/src/message/app.rs
+++ b/src/message/app.rs
@@ -7,7 +7,7 @@ use crate::{
     channel::{self, repo::Provider as _},
     clock::DateTime,
     db::NotFound as _,
-    event::{broadcaster::Broadcaster, repo::Provider as _, Event, Sequence},
+    event::{broadcaster::Broadcaster, repo::Provider as _, Event, Sequence, Sequenced},
     login::Login,
 };
 
@@ -87,7 +87,7 @@ impl<'a> Messages<'a> {
         self.events.broadcast(
             events
                 .into_iter()
-                .kmerge_by(|a, b| a.instant.sequence < b.instant.sequence)
+                .kmerge_by(Sequence::merge)
                 .map(Event::from)
                 .collect::<Vec<_>>(),
         );
diff --git a/src/message/event.rs b/src/message/event.rs
index bcc2238..66db9b0 100644
--- a/src/message/event.rs
+++ b/src/message/event.rs
@@ -7,14 +7,12 @@ use crate::{
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
 pub struct Event {
     #[serde(flatten)]
-    pub instant: Instant,
-    #[serde(flatten)]
     pub kind: Kind,
 }
 
 impl Sequenced for Event {
     fn instant(&self) -> Instant {
-        self.instant
+        self.kind.instant()
     }
 }
 
@@ -25,12 +23,27 @@ pub enum Kind {
     Deleted(Deleted),
 }
 
+impl Sequenced for Kind {
+    fn instant(&self) -> Instant {
+        match self {
+            Self::Sent(sent) => sent.instant(),
+            Self::Deleted(deleted) => deleted.instant(),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
 pub struct Sent {
     #[serde(flatten)]
     pub message: Message,
 }
 
+impl Sequenced for Sent {
+    fn instant(&self) -> Instant {
+        self.message.sent
+    }
+}
+
 impl From<Sent> for Kind {
     fn from(event: Sent) -> Self {
         Self::Sent(event)
@@ -39,10 +52,18 @@ impl From<Sent> for Kind {
 
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
 pub struct Deleted {
+    #[serde(flatten)]
+    pub instant: Instant,
     pub channel: Channel,
     pub message: Id,
 }
 
+impl Sequenced for Deleted {
+    fn instant(&self) -> Instant {
+        self.instant
+    }
+}
+
 impl From<Deleted> for Kind {
     fn from(event: Deleted) -> Self {
         Self::Deleted(event)
diff --git a/src/message/history.rs b/src/message/history.rs
index 5aca47e..89fc6b1 100644
--- a/src/message/history.rs
+++ b/src/message/history.rs
@@ -7,14 +7,12 @@ use crate::event::Instant;
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct History {
     pub message: Message,
-    pub sent: Instant,
     pub deleted: Option<Instant>,
 }
 
 impl History {
     fn sent(&self) -> Event {
         Event {
-            instant: self.sent,
             kind: Sent {
                 message: self.message.clone(),
             }
@@ -24,8 +22,8 @@ impl History {
 
     fn deleted(&self) -> Option<Event> {
         self.deleted.map(|instant| Event {
-            instant,
             kind: Deleted {
+                instant,
                 channel: self.message.channel.clone(),
                 message: self.message.id.clone(),
             }
diff --git a/src/message/repo.rs b/src/message/repo.rs
index ae41736..fc835c8 100644
--- a/src/message/repo.rs
+++ b/src/message/repo.rs
@@ -48,12 +48,12 @@ impl<'c> Messages<'c> {
         )
         .map(|row| History {
             message: Message {
+                sent: *sent,
                 channel: channel.clone(),
                 sender: sender.clone(),
                 id: row.id,
                 body: row.body,
             },
-            sent: *sent,
             deleted: None,
         })
         .fetch_one(&mut *self.0)
@@ -62,18 +62,51 @@ impl<'c> Messages<'c> {
         Ok(message)
     }
 
-    pub async fn in_channel(&mut self, channel: &Channel) -> Result<Vec<Id>, sqlx::Error> {
-        let messages = sqlx::query_scalar!(
+    pub async fn in_channel(
+        &mut self,
+        channel: &Channel,
+        resume_at: Option<Sequence>,
+    ) -> Result<Vec<History>, sqlx::Error> {
+        let messages = sqlx::query!(
             r#"
                 select
-                    message.id as "id: Id"
+                    channel.id as "channel_id: channel::Id",
+                    channel.name as "channel_name",
+                    sender.id as "sender_id: login::Id",
+                    sender.name as "sender_name",
+                    message.id as "id: Id",
+                    message.body,
+                    sent_at as "sent_at: DateTime",
+                    sent_sequence as "sent_sequence: Sequence"
                 from message
                     join channel on message.channel = channel.id
+                    join login as sender on message.sender = sender.id
                 where channel.id = $1
+                    and coalesce(message.sent_sequence <= $2, true)
                 order by message.sent_sequence
             "#,
             channel.id,
+            resume_at,
         )
+        .map(|row| History {
+            message: Message {
+                sent: Instant {
+                    at: row.sent_at,
+                    sequence: row.sent_sequence,
+                },
+                channel: Channel {
+                    id: row.channel_id,
+                    name: row.channel_name,
+                },
+                sender: Login {
+                    id: row.sender_id,
+                    name: row.sender_name,
+                },
+                id: row.id,
+                body: row.body,
+            },
+            deleted: None,
+        })
         .fetch_all(&mut *self.0)
         .await?;
 
@@ -101,6 +134,10 @@ impl<'c> Messages<'c> {
         )
         .map(|row| History {
             message: Message {
+                sent: Instant {
+                    at: row.sent_at,
+                    sequence: row.sent_sequence,
+                },
                 channel: Channel {
                     id: row.channel_id,
                     name: row.channel_name,
@@ -112,10 +149,6 @@ impl<'c> Messages<'c> {
                 id: row.id,
                 body: row.body,
             },
-            sent: Instant {
-                at: row.sent_at,
-                sequence: row.sent_sequence,
-            },
             deleted: None,
         })
         .fetch_one(&mut *self.0)
@@ -189,6 +222,10 @@ impl<'c> Messages<'c> {
         )
         .map(|row| History {
             message: Message {
+                sent: Instant {
+                    at: row.sent_at,
+                    sequence: row.sent_sequence,
+                },
                 channel: Channel {
                     id: row.channel_id,
                     name: row.channel_name,
@@ -200,10 +237,6 @@ impl<'c> Messages<'c> {
                 id: row.id,
                 body: row.body,
             },
-            sent: Instant {
-                at: row.sent_at,
-                sequence: row.sent_sequence,
-            },
             deleted: None,
         })
         .fetch_all(&mut *self.0)
diff --git a/src/message/snapshot.rs b/src/message/snapshot.rs
index 3adccbe..522c1aa 100644
--- a/src/message/snapshot.rs
+++ b/src/message/snapshot.rs
@@ -2,11 +2,13 @@ use super::{
     event::{Event, Kind, Sent},
     Id,
 };
-use crate::{channel::Channel, login::Login};
+use crate::{channel::Channel, event::Instant, login::Login};
 
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
 #[serde(into = "self::serialize::Message")]
 pub struct Message {
+    #[serde(skip)]
+    pub sent: Instant,
     pub channel: Channel,
     pub sender: Login,
     pub id: Id,