2 files changed, 23 insertions, 87 deletions
diff --git a/src/boot/app.rs b/src/boot/app.rs
index fc84b3a..ef48b2f 100644
--- a/src/boot/app.rs
+++ b/src/boot/app.rs
@@ -1,8 +1,9 @@
 use sqlx::sqlite::SqlitePool;
 
-use super::{Channel, Snapshot};
+use super::Snapshot;
 use crate::{
-    channel::repo::Provider as _, event::repo::Provider as _, message::repo::Provider as _,
+    channel::repo::Provider as _, event::repo::Provider as _, login::repo::Provider as _,
+    message::repo::Provider as _,
 };
 
 pub struct Boot<'a> {
@@ -17,38 +18,33 @@ impl<'a> Boot<'a> {
     pub async fn snapshot(&self) -> Result<Snapshot, sqlx::Error> {
         let mut tx = self.db.begin().await?;
         let resume_point = tx.sequence().current().await?;
-        let channels = tx.channels().all(resume_point.into()).await?;
-
-        let channels = {
-            let mut snapshots = Vec::with_capacity(channels.len());
-
-            let channels = channels.into_iter().filter_map(|channel| {
-                channel
-                    .as_of(resume_point)
-                    .map(|snapshot| (channel, snapshot))
-            });
 
-            for (channel, snapshot) in channels {
-                let messages = tx
-                    .messages()
-                    .in_channel(&channel, resume_point.into())
-                    .await?;
+        let logins = tx.logins().all(resume_point.into()).await?;
+        let channels = tx.channels().all(resume_point.into()).await?;
+        let messages = tx.messages().all(resume_point.into()).await?;
 
-                let messages = messages
-                    .into_iter()
-                    .filter_map(|message| message.as_of(resume_point));
+        tx.commit().await?;
 
-                snapshots.push(Channel::new(snapshot, messages));
-            }
+        let logins = logins
+            .into_iter()
+            .filter_map(|login| login.as_of(resume_point))
+            .collect();
 
-            snapshots
-        };
+        let channels = channels
+            .into_iter()
+            .filter_map(|channel| channel.as_of(resume_point))
+            .collect();
 
-        tx.commit().await?;
+        let messages = messages
+            .into_iter()
+            .filter_map(|message| message.as_of(resume_point))
+            .collect();
 
         Ok(Snapshot {
             resume_point,
+            logins,
             channels,
+            messages,
         })
     }
 }
diff --git a/src/boot/mod.rs b/src/boot/mod.rs
index bd0da0a..ed4764a 100644
--- a/src/boot/mod.rs
+++ b/src/boot/mod.rs
@@ -1,74 +1,14 @@
 pub mod app;
 mod routes;
 
-use crate::{
-    channel,
-    event::{Instant, Sequence},
-    login::Login,
-    message,
-};
+use crate::{channel::Channel, event::Sequence, login::Login, message::Message};
 
 pub use self::routes::router;
 
 #[derive(serde::Serialize)]
 pub struct Snapshot {
     pub resume_point: Sequence,
+    pub logins: Vec<Login>,
     pub channels: Vec<Channel>,
-}
-
-#[derive(serde::Serialize)]
-pub struct Channel {
-    pub id: channel::Id,
-    pub name: String,
     pub messages: Vec<Message>,
 }
-
-impl Channel {
-    fn new(
-        channel: channel::Channel,
-        messages: impl IntoIterator<Item = message::Message>,
-    ) -> Self {
-        // The declarations are like this to guarantee that we aren't omitting any important fields from the corresponding types.
-        let channel::Channel { id, name } = channel;
-
-        Self {
-            id,
-            name,
-            messages: messages.into_iter().map(Message::from).collect(),
-        }
-    }
-}
-
-#[derive(serde::Serialize)]
-pub struct Message {
-    #[serde(flatten)]
-    pub sent: Instant,
-    pub sender: Login,
-    // Named this way for serialization reasons
-    #[allow(clippy::struct_field_names)]
-    pub message: Body,
-}
-
-impl From<message::Message> for Message {
-    fn from(message: message::Message) -> Self {
-        let message::Message {
-            sent,
-            channel: _,
-            sender,
-            id,
-            body,
-        } = message;
-
-        Self {
-            sent,
-            sender,
-            message: Body { id, body },
-        }
-    }
-}
-
-#[derive(serde::Serialize)]
-pub struct Body {
-    id: message::Id,
-    body: String,
-}