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, 65 insertions, 8 deletions

diff --git a/src/event/mod.rs b/src/event/mod.rs
index c982d3a..1503b77 100644
--- a/src/event/mod.rs
+++ b/src/event/mod.rs
@@ -1,18 +1,75 @@
+use crate::{channel, message};
+
 pub mod app;
 pub mod broadcaster;
 mod extract;
 pub mod repo;
 mod routes;
 mod sequence;
-pub mod types;
 
-use crate::clock::DateTime;
+pub use self::{
+    routes::router,
+    sequence::{Instant, Sequence, Sequenced},
+};
+
+#[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
+    }
+}
+
+impl From<channel::Event> for Event {
+    fn from(event: channel::Event) -> Self {
+        Self {
+            instant: event.instant,
+            kind: event.kind.into(),
+        }
+    }
+}
+
+impl From<message::Event> for Event {
+    fn from(event: message::Event) -> Self {
+        Self {
+            instant: event.instant,
+            kind: event.kind.into(),
+        }
+    }
+}
 
-pub use self::{routes::router, sequence::Sequence};
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum Kind {
+    #[serde(rename = "created")]
+    ChannelCreated(channel::event::Created),
+    #[serde(rename = "message")]
+    MessageSent(message::event::Sent),
+    MessageDeleted(message::event::Deleted),
+    #[serde(rename = "deleted")]
+    ChannelDeleted(channel::event::Deleted),
+}
+
+impl From<channel::event::Kind> for Kind {
+    fn from(kind: channel::event::Kind) -> Self {
+        match kind {
+            channel::event::Kind::Created(created) => Self::ChannelCreated(created),
+            channel::event::Kind::Deleted(deleted) => Self::ChannelDeleted(deleted),
+        }
+    }
+}
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Serialize)]
-pub struct Instant {
-    pub at: DateTime,
-    #[serde(skip)]
-    pub sequence: Sequence,
+impl From<message::event::Kind> for Kind {
+    fn from(kind: message::event::Kind) -> Self {
+        match kind {
+            message::event::Kind::Sent(created) => Self::MessageSent(created),
+            message::event::Kind::Deleted(deleted) => Self::MessageDeleted(deleted),
+        }
+    }
 }