Represent channels and messages using a split "History" and "Snapshot" model.

This separates the code that figures out what happened to an entity from the code that represents it to a user, and makes it easier to compute a snapshot at a point in time (for things like bootstrap). It also makes the internal logic a bit easier to follow, since it's easier to tell whether you're working with a point in time or with the whole recorded history.

This hefty.

1 files changed, 53 insertions, 41 deletions

diff --git a/src/channel/repo.rs b/src/channel/repo.rs
index c000b56..8bb761b 100644
--- a/src/channel/repo.rs
+++ b/src/channel/repo.rs
@@ -1,9 +1,9 @@
 use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
 
 use crate::{
-    channel::{Channel, Id},
+    channel::{Channel, History, Id},
     clock::DateTime,
-    event::{types, Instant, Sequence},
+    event::{Instant, Sequence},
 };
 
 pub trait Provider {
@@ -19,7 +19,7 @@ impl<'c> Provider for Transaction<'c, Sqlite> {
 pub struct Channels<'t>(&'t mut SqliteConnection);
 
 impl<'c> Channels<'c> {
-    pub async fn create(&mut self, name: &str, created: &Instant) -> Result<Channel, sqlx::Error> {
+    pub async fn create(&mut self, name: &str, created: &Instant) -> Result<History, sqlx::Error> {
         let id = Id::generate();
         let channel = sqlx::query!(
             r#"
@@ -37,13 +37,16 @@ impl<'c> Channels<'c> {
             created.at,
             created.sequence,
         )
-        .map(|row| Channel {
-            id: row.id,
-            name: row.name,
+        .map(|row| History {
+            channel: Channel {
+                id: row.id,
+                name: row.name,
+            },
             created: Instant {
                 at: row.created_at,
                 sequence: row.created_sequence,
             },
+            deleted: None,
         })
         .fetch_one(&mut *self.0)
         .await?;
@@ -51,7 +54,7 @@ impl<'c> Channels<'c> {
         Ok(channel)
     }
 
-    pub async fn by_id(&mut self, channel: &Id) -> Result<Channel, sqlx::Error> {
+    pub async fn by_id(&mut self, channel: &Id) -> Result<History, sqlx::Error> {
         let channel = sqlx::query!(
             r#"
                 select
@@ -64,13 +67,16 @@ impl<'c> Channels<'c> {
             "#,
             channel,
         )
-        .map(|row| Channel {
-            id: row.id,
-            name: row.name,
+        .map(|row| History {
+            channel: Channel {
+                id: row.id,
+                name: row.name,
+            },
             created: Instant {
                 at: row.created_at,
                 sequence: row.created_sequence,
             },
+            deleted: None,
         })
         .fetch_one(&mut *self.0)
         .await?;
@@ -81,7 +87,7 @@ impl<'c> Channels<'c> {
     pub async fn all(
         &mut self,
         resume_point: Option<Sequence>,
-    ) -> Result<Vec<Channel>, sqlx::Error> {
+    ) -> Result<Vec<History>, sqlx::Error> {
         let channels = sqlx::query!(
             r#"
                 select
@@ -95,13 +101,16 @@ impl<'c> Channels<'c> {
             "#,
             resume_point,
         )
-        .map(|row| Channel {
-            id: row.id,
-            name: row.name,
+        .map(|row| History {
+            channel: Channel {
+                id: row.id,
+                name: row.name,
+            },
             created: Instant {
                 at: row.created_at,
                 sequence: row.created_sequence,
             },
+            deleted: None,
         })
         .fetch_all(&mut *self.0)
         .await?;
@@ -112,7 +121,7 @@ impl<'c> Channels<'c> {
     pub async fn replay(
         &mut self,
         resume_at: Option<Sequence>,
-    ) -> Result<Vec<Channel>, sqlx::Error> {
+    ) -> Result<Vec<History>, sqlx::Error> {
         let channels = sqlx::query!(
             r#"
                 select
@@ -125,13 +134,16 @@ impl<'c> Channels<'c> {
             "#,
             resume_at,
         )
-        .map(|row| Channel {
-            id: row.id,
-            name: row.name,
+        .map(|row| History {
+            channel: Channel {
+                id: row.id,
+                name: row.name,
+            },
             created: Instant {
                 at: row.created_at,
                 sequence: row.created_sequence,
             },
+            deleted: None,
         })
         .fetch_all(&mut *self.0)
         .await?;
@@ -141,35 +153,43 @@ impl<'c> Channels<'c> {
 
     pub async fn delete(
         &mut self,
-        channel: &Channel,
+        channel: &Id,
         deleted: &Instant,
-    ) -> Result<types::ChannelEvent, sqlx::Error> {
-        let channel = channel.id.clone();
-        sqlx::query_scalar!(
+    ) -> Result<History, sqlx::Error> {
+        let channel = sqlx::query!(
             r#"
                 delete from channel
                 where id = $1
-                returning 1 as "row: i64"
+                returning
+                    id as "id: Id",
+                    name,
+                    created_at as "created_at: DateTime",
+                    created_sequence as "created_sequence: Sequence"
             "#,
             channel,
         )
+        .map(|row| History {
+            channel: Channel {
+                id: row.id,
+                name: row.name,
+            },
+            created: Instant {
+                at: row.created_at,
+                sequence: row.created_sequence,
+            },
+            deleted: Some(*deleted),
+        })
         .fetch_one(&mut *self.0)
         .await?;
 
-        Ok(types::ChannelEvent {
-            instant: *deleted,
-            data: types::DeletedEvent { channel }.into(),
-        })
+        Ok(channel)
     }
 
-    pub async fn expired(&mut self, expired_at: &DateTime) -> Result<Vec<Channel>, sqlx::Error> {
-        let channels = sqlx::query!(
+    pub async fn expired(&mut self, expired_at: &DateTime) -> Result<Vec<Id>, sqlx::Error> {
+        let channels = sqlx::query_scalar!(
             r#"
                 select
-                    channel.id as "id: Id",
-                    channel.name,
-                    channel.created_at as "created_at: DateTime",
-                    channel.created_sequence as "created_sequence: Sequence"
+                    channel.id as "id: Id"
                 from channel
                     left join message
                 where created_at < $1
@@ -177,14 +197,6 @@ impl<'c> Channels<'c> {
             "#,
             expired_at,
         )
-        .map(|row| Channel {
-            id: row.id,
-            name: row.name,
-            created: Instant {
-                at: row.created_at,
-                sequence: row.created_sequence,
-            },
-        })
         .fetch_all(&mut *self.0)
         .await?;