1 files changed, 38 insertions, 21 deletions

diff --git a/src/channel/repo/messages.rs b/src/channel/repo/messages.rs
index 0d74ea9..fe833b6 100644
--- a/src/channel/repo/messages.rs
+++ b/src/channel/repo/messages.rs
@@ -4,7 +4,10 @@ use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 
 use super::channels::Id as ChannelId;
 use crate::{
-    clock::DateTime, error::BoxedError, id::Id as BaseId, login::repo::logins::Id as LoginId,
+    clock::DateTime,
+    error::BoxedError,
+    id::Id as BaseId,
+    login::repo::logins::{Id as LoginId, Login, Logins},
 };
 
 pub trait Provider {
@@ -19,13 +22,10 @@ impl<'c> Provider for Transaction<'c, Sqlite> {
 
 pub struct Messages<'t>(&'t mut SqliteConnection);
 
-#[derive(Clone, Debug)]
-pub struct Message {
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct BroadcastMessage {
     pub id: Id,
-    pub sender: LoginId,
-    // Field not actually used at this time, but you can reinstate it if you
-    // need to. It's not omitted out of any greater design intention.
-    // pub channel: ChannelId,
+    pub sender: Login,
     pub body: String,
     pub sent_at: DateTime,
 }
@@ -37,50 +37,67 @@ impl<'c> Messages<'c> {
         channel: &ChannelId,
         body: &str,
         sent_at: &DateTime,
-    ) -> Result<Message, BoxedError> {
+    ) -> Result<BroadcastMessage, BoxedError> {
         let id = Id::generate();
 
-        let message = sqlx::query_as!(
-            Message,
+        let sender = Logins::from(&mut *self.0).by_id(sender).await?;
+
+        let message = sqlx::query!(
             r#"
                 insert into message
                     (id, sender, channel, body, sent_at)
                 values ($1, $2, $3, $4, $5)
                 returning
                     id as "id: Id",
-                    sender as "sender: LoginId",
-                    -- channel as "channel: ChannelId",
                     body,
                     sent_at as "sent_at: DateTime"
             "#,
             id,
-            sender,
+            sender.id,
             channel,
             body,
             sent_at,
         )
+        .map(|row| BroadcastMessage {
+            sender: sender.clone(),
+            id: row.id,
+            body: row.body,
+            sent_at: row.sent_at,
+        })
         .fetch_one(&mut *self.0)
         .await?;
 
         Ok(message)
     }
 
-    pub async fn all(&mut self, channel: &ChannelId) -> Result<Vec<Message>, BoxedError> {
-        let messages = sqlx::query_as!(
-            Message,
+    pub async fn for_replay(
+        &mut self,
+        channel: &ChannelId,
+    ) -> Result<Vec<BroadcastMessage>, BoxedError> {
+        let messages = sqlx::query!(
             r#"
                 select
-                    id as "id: Id",
-                    sender as "sender: LoginId",
-                    -- channel as "channel: ChannelId",
-                    body,
-                    sent_at as "sent_at: DateTime"
+                    message.id as "id: Id",
+                    login.id as "sender_id: LoginId",
+                    login.name as sender_name,
+                    message.body,
+                    message.sent_at as "sent_at: DateTime"
                 from message
+                    join login on message.sender = login.id
                 where channel = $1
                 order by sent_at asc
             "#,
             channel,
         )
+        .map(|row| BroadcastMessage {
+            id: row.id,
+            sender: Login {
+                id: row.sender_id,
+                name: row.sender_name,
+            },
+            body: row.body,
+            sent_at: row.sent_at,
+        })
         .fetch_all(&mut *self.0)
         .await?;