From a2fee1c18d9def1486a570fb3c98db5372c51238 Mon Sep 17 00:00:00 2001 From: Owen Jacobson Date: Tue, 26 Aug 2025 18:18:24 -0400 Subject: Store `User` instances using their events. --- src/user/create.rs | 39 +++++++++++++++++++++++++++------------ src/user/history.rs | 22 ++++++++++++++++++++-- src/user/repo.rs | 50 +++++++++++++++++++++++++++++--------------------- 3 files changed, 76 insertions(+), 35 deletions(-) (limited to 'src') 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 { + pub async fn store( + self, + tx: &mut Transaction<'_, Sqlite>, + ) -> Result + 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 { + events: E, login: Login, } -impl Stored { - pub fn publish(self, broadcaster: &Broadcaster) { - let Self { user, login: _ } = self; +impl Stored +where + E: IntoIterator, +{ + pub fn publish(self, events: &Broadcaster) { + let Self { + events: user_events, + login: _, + } = self; - broadcaster.broadcast(user.events().map(Event::from).collect::>()); + events.broadcast(user_events.into_iter().collect::>()); } pub fn login(&self) -> &Login { diff --git a/src/user/history.rs b/src/user/history.rs index f58e9c7..7c06a2d 100644 --- a/src/user/history.rs +++ b/src/user/history.rs @@ -2,7 +2,10 @@ use super::{ User, event::{Created, Event}, }; -use crate::event::{Instant, Sequence}; +use crate::{ + event::{Instant, Sequence}, + login::Login, +}; #[derive(Clone, Debug, Eq, PartialEq)] pub struct History { @@ -10,6 +13,21 @@ pub struct History { pub created: Instant, } +// Lifecycle interface +impl History { + pub fn begin(login: &Login, created: Instant) -> Self { + let Login { id, name } = login.clone(); + + Self { + user: User { + id: id.into(), + name, + }, + created, + } + } +} + // State interface impl History { pub fn as_of(&self, sequence: S) -> Option @@ -32,7 +50,7 @@ impl History { .into() } - pub fn events(&self) -> impl Iterator + use<> { + pub fn events(&self) -> impl Iterator + Clone + use<> { [self.created()].into_iter() } } diff --git a/src/user/repo.rs b/src/user/repo.rs index aaf3b73..292d72e 100644 --- a/src/user/repo.rs +++ b/src/user/repo.rs @@ -1,13 +1,13 @@ use futures::stream::{StreamExt as _, TryStreamExt as _}; use sqlx::{SqliteConnection, Transaction, sqlite::Sqlite}; +use super::{Event, History, Id, User, event::Created}; use crate::{ clock::DateTime, db::NotFound, event::{Instant, Sequence}, login::Login, name::{self, Name}, - user::{History, Id, User}, }; pub trait Provider { @@ -23,30 +23,39 @@ impl Provider for Transaction<'_, Sqlite> { pub struct Users<'t>(&'t mut SqliteConnection); impl Users<'_> { - pub async fn create( + pub async fn record_events( &mut self, - login: &Login, - created: &Instant, - ) -> Result { + events: impl IntoIterator, + ) -> Result<(), sqlx::Error> { + for event in events { + self.record_event(&event).await?; + } + Ok(()) + } + + pub async fn record_event(&mut self, event: &Event) -> Result<(), sqlx::Error> { + match event { + Event::Created(created) => self.record_created(created).await, + } + } + + async fn record_created(&mut self, created: &Created) -> Result<(), sqlx::Error> { + let Created { user, instant } = created; + sqlx::query!( r#" - insert into user (id, created_sequence, created_at) + insert + into user (id, created_at, created_sequence) values ($1, $2, $3) "#, - login.id, - created.sequence, - created.at, + user.id, + instant.at, + instant.sequence, ) .execute(&mut *self.0) .await?; - Ok(History { - user: User { - id: login.id.clone().into(), - name: login.name.clone(), - }, - created: *created, - }) + Ok(()) } pub async fn by_login(&mut self, login: &Login) -> Result { @@ -86,12 +95,11 @@ impl Users<'_> { id as "id: Id", login.display_name as "display_name: String", login.canonical_name as "canonical_name: String", - user.created_sequence as "created_sequence: Sequence", - user.created_at as "created_at: DateTime" + user.created_at as "created_at: DateTime", + user.created_sequence as "created_sequence: Sequence" from user join login using (id) where user.created_sequence <= $1 - order by canonical_name "#, resume_at, ) @@ -119,8 +127,8 @@ impl Users<'_> { id as "id: Id", login.display_name as "display_name: String", login.canonical_name as "canonical_name: String", - user.created_sequence as "created_sequence: Sequence", - user.created_at as "created_at: DateTime" + user.created_at as "created_at: DateTime", + user.created_sequence as "created_sequence: Sequence" from user join login using (id) where user.created_sequence > $1 -- cgit v1.2.3