Store `User` instances using their events.

1 files changed, 27 insertions, 12 deletions

diff --git a/src/user/create.rs b/src/user/create.rs
index 5c060c9..21c61d1 100644
--- a/src/user/create.rs
+++ b/src/user/create.rs
@@ -3,7 +3,7 @@ use sqlx::{Transaction, sqlite::Sqlite};
 use super::{History, repo::Provider as _, validate};
 use crate::{
     clock::DateTime,
-    event::{Broadcaster, Event, repo::Provider as _},
+    event::{Broadcaster, Event, Sequence, repo::Provider as _},
     login::{self, Login, repo::Provider as _},
     name::Name,
     password::{Password, StoredHash},
@@ -54,7 +54,10 @@ pub struct Validated<'a> {
 }
 
 impl Validated<'_> {
-    pub async fn store(self, tx: &mut Transaction<'_, Sqlite>) -> Result<Stored, sqlx::Error> {
+    pub async fn store(
+        self,
+        tx: &mut Transaction<'_, Sqlite>,
+    ) -> Result<Stored<impl IntoIterator<Item = Event> + use<>>, sqlx::Error> {
         let Self {
             name,
             password,
@@ -63,28 +66,40 @@ impl Validated<'_> {
 
         let login = Login {
             id: login::Id::generate(),
-            name: name.to_owned(),
+            name: name.clone(),
         };
+        tx.logins().create(&login, &password).await?;
 
         let created = tx.sequence().next(created_at).await?;
-        tx.logins().create(&login, &password).await?;
-        let user = tx.users().create(&login, &created).await?;
+        let user = History::begin(&login, created);
+
+        let events = user.events().filter(Sequence::start_from(created));
+        tx.users().record_events(events.clone()).await?;
 
-        Ok(Stored { user, login })
+        Ok(Stored {
+            events: events.map(Event::from),
+            login,
+        })
     }
 }
 
 #[must_use = "dropping a user creation attempt is likely a mistake"]
-pub struct Stored {
-    user: History,
+pub struct Stored<E> {
+    events: E,
     login: Login,
 }
 
-impl Stored {
-    pub fn publish(self, broadcaster: &Broadcaster) {
-        let Self { user, login: _ } = self;
+impl<E> Stored<E>
+where
+    E: IntoIterator<Item = Event>,
+{
+    pub fn publish(self, events: &Broadcaster) {
+        let Self {
+            events: user_events,
+            login: _,
+        } = self;
 
-        broadcaster.broadcast(user.events().map(Event::from).collect::<Vec<_>>());
+        events.broadcast(user_events.into_iter().collect::<Vec<_>>());
     }
 
     pub fn login(&self) -> &Login {