summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/invite/app.rs33
-rw-r--r--src/login/app.rs38
-rw-r--r--src/login/create.rs95
-rw-r--r--src/login/mod.rs3
-rw-r--r--src/setup/app.rs32
5 files changed, 158 insertions, 43 deletions
diff --git a/src/invite/app.rs b/src/invite/app.rs
index 182eb67..d4e877a 100644
--- a/src/invite/app.rs
+++ b/src/invite/app.rs
@@ -5,8 +5,11 @@ use super::{repo::Provider as _, Id, Invite, Summary};
use crate::{
clock::DateTime,
db::{Duplicate as _, NotFound as _},
- event::{repo::Provider as _, Broadcaster, Event},
- login::{repo::Provider as _, validate, Login, Password},
+ event::Broadcaster,
+ login::{
+ create::{self, Create},
+ Login, Password,
+ },
name::Name,
token::{repo::Provider as _, Secret},
};
@@ -44,9 +47,7 @@ impl<'a> Invites<'a> {
password: &Password,
accepted_at: &DateTime,
) -> Result<(Login, Secret), AcceptError> {
- if !validate::name(name) {
- return Err(AcceptError::InvalidName(name.clone()));
- }
+ let create = Create::begin(name, password, accepted_at);
let mut tx = self.db.begin().await?;
let invite = tx
@@ -59,23 +60,20 @@ impl<'a> Invites<'a> {
// the invite. Final validation is in the next tx.
tx.commit().await?;
- let password_hash = password.hash()?;
+ let validated = create.validate()?;
let mut tx = self.db.begin().await?;
// If the invite has been deleted or accepted in the interim, this step will
// catch it.
tx.invites().accept(&invite).await?;
- let created = tx.sequence().next(accepted_at).await?;
- let login = tx
- .logins()
- .create(name, &password_hash, &created)
+ let stored = validated
+ .store(&mut tx)
.await
.duplicate(|| AcceptError::DuplicateLogin(name.clone()))?;
- let secret = tx.tokens().issue(&login, accepted_at).await?;
+ let secret = tx.tokens().issue(stored.login(), accepted_at).await?;
tx.commit().await?;
- self.events
- .broadcast(login.events().map(Event::from).collect::<Vec<_>>());
+ let login = stored.publish(self.events);
Ok((login.as_created(), secret))
}
@@ -105,3 +103,12 @@ pub enum AcceptError {
#[error(transparent)]
PasswordHash(#[from] password_hash::Error),
}
+
+impl From<create::Error> for AcceptError {
+ fn from(error: create::Error) -> Self {
+ match error {
+ create::Error::InvalidName(name) => Self::InvalidName(name),
+ create::Error::PasswordHash(error) => Self::PasswordHash(error),
+ }
+ }
+}
diff --git a/src/login/app.rs b/src/login/app.rs
index c1bfe6e..6da26e9 100644
--- a/src/login/app.rs
+++ b/src/login/app.rs
@@ -3,13 +3,12 @@ use sqlx::sqlite::SqlitePool;
use super::repo::Provider as _;
#[cfg(test)]
-use super::{validate, Login, Password};
-#[cfg(test)]
-use crate::{
- clock::DateTime,
- event::{repo::Provider as _, Broadcaster, Event},
- name::Name,
+use super::{
+ create::{self, Create},
+ Login, Password,
};
+#[cfg(test)]
+use crate::{clock::DateTime, event::Broadcaster, name::Name};
pub struct Logins<'a> {
db: &'a SqlitePool,
@@ -35,19 +34,14 @@ impl<'a> Logins<'a> {
password: &Password,
created_at: &DateTime,
) -> Result<Login, CreateError> {
- if !validate::name(name) {
- return Err(CreateError::InvalidName(name.clone()));
- }
-
- let password_hash = password.hash()?;
+ let create = Create::begin(name, password, created_at);
+ let validated = create.validate()?;
let mut tx = self.db.begin().await?;
- let created = tx.sequence().next(created_at).await?;
- let login = tx.logins().create(name, &password_hash, &created).await?;
+ let stored = validated.store(&mut tx).await?;
tx.commit().await?;
- self.events
- .broadcast(login.events().map(Event::from).collect::<Vec<_>>());
+ let login = stored.publish(self.events);
Ok(login.as_created())
}
@@ -67,7 +61,17 @@ pub enum CreateError {
#[error("invalid login name: {0}")]
InvalidName(Name),
#[error(transparent)]
- Database(#[from] sqlx::Error),
- #[error(transparent)]
PasswordHash(#[from] password_hash::Error),
+ #[error(transparent)]
+ Database(#[from] sqlx::Error),
+}
+
+#[cfg(test)]
+impl From<create::Error> for CreateError {
+ fn from(error: create::Error) -> Self {
+ match error {
+ create::Error::InvalidName(name) => Self::InvalidName(name),
+ create::Error::PasswordHash(error) => Self::PasswordHash(error),
+ }
+ }
}
diff --git a/src/login/create.rs b/src/login/create.rs
new file mode 100644
index 0000000..693daaf
--- /dev/null
+++ b/src/login/create.rs
@@ -0,0 +1,95 @@
+use sqlx::{sqlite::Sqlite, Transaction};
+
+use super::{password::StoredHash, repo::Provider as _, validate, History, Password};
+use crate::{
+ clock::DateTime,
+ event::{repo::Provider as _, Broadcaster, Event},
+ name::Name,
+};
+
+pub struct Create<'a> {
+ name: &'a Name,
+ password: &'a Password,
+ created_at: &'a DateTime,
+}
+
+impl<'a> Create<'a> {
+ #[must_use = "dropping a login creation attempt is likely a mistake"]
+ pub fn begin(name: &'a Name, password: &'a Password, created_at: &'a DateTime) -> Self {
+ Self {
+ name,
+ password,
+ created_at,
+ }
+ }
+
+ #[must_use = "dropping a login creation attempt is likely a mistake"]
+ pub fn validate(self) -> Result<Validated<'a>, Error> {
+ let Self {
+ name,
+ password,
+ created_at,
+ } = self;
+
+ if !validate::name(name) {
+ return Err(Error::InvalidName(name.clone()));
+ }
+
+ let password_hash = password.hash()?;
+
+ Ok(Validated {
+ name,
+ password_hash,
+ created_at,
+ })
+ }
+}
+
+pub struct Validated<'a> {
+ name: &'a Name,
+ password_hash: StoredHash,
+ created_at: &'a DateTime,
+}
+
+impl<'a> Validated<'a> {
+ #[must_use = "dropping a login creation attempt is likely a mistake"]
+ pub async fn store<'c>(self, tx: &mut Transaction<'c, Sqlite>) -> Result<Stored, sqlx::Error> {
+ let Self {
+ name,
+ password_hash,
+ created_at,
+ } = self;
+
+ let created = tx.sequence().next(created_at).await?;
+ let login = tx.logins().create(name, &password_hash, &created).await?;
+
+ Ok(Stored { login })
+ }
+}
+
+pub struct Stored {
+ login: History,
+}
+
+impl Stored {
+ #[must_use = "dropping a login creation attempt is likely a mistake"]
+ pub fn publish(self, events: &Broadcaster) -> History {
+ let Self { login } = self;
+
+ events.broadcast(login.events().map(Event::from).collect::<Vec<_>>());
+
+ login
+ }
+
+ pub fn login(&self) -> &History {
+ &self.login
+ }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ #[error("invalid login name: {0}")]
+ InvalidName(Name),
+ #[error(transparent)]
+ PasswordHash(#[from] password_hash::Error),
+}
diff --git a/src/login/mod.rs b/src/login/mod.rs
index 6d10e17..5a6d715 100644
--- a/src/login/mod.rs
+++ b/src/login/mod.rs
@@ -1,4 +1,5 @@
pub mod app;
+pub mod create;
pub mod event;
mod history;
mod id;
@@ -6,7 +7,7 @@ pub mod password;
pub mod repo;
mod routes;
mod snapshot;
-pub mod validate;
+mod validate;
pub use self::{
event::Event, history::History, id::Id, password::Password, routes::router, snapshot::Login,
diff --git a/src/setup/app.rs b/src/setup/app.rs
index cab7c4b..c1f7b69 100644
--- a/src/setup/app.rs
+++ b/src/setup/app.rs
@@ -3,8 +3,11 @@ use sqlx::sqlite::SqlitePool;
use super::repo::Provider as _;
use crate::{
clock::DateTime,
- event::{repo::Provider as _, Broadcaster, Event},
- login::{repo::Provider as _, validate, Login, Password},
+ event::Broadcaster,
+ login::{
+ create::{self, Create},
+ Login, Password,
+ },
name::Name,
token::{repo::Provider as _, Secret},
};
@@ -25,24 +28,20 @@ impl<'a> Setup<'a> {
password: &Password,
created_at: &DateTime,
) -> Result<(Login, Secret), Error> {
- if !validate::name(name) {
- return Err(Error::InvalidName(name.clone()));
- }
+ let create = Create::begin(name, password, created_at);
- let password_hash = password.hash()?;
+ let validated = create.validate()?;
let mut tx = self.db.begin().await?;
- let login = if tx.setup().completed().await? {
+ let stored = if tx.setup().completed().await? {
Err(Error::SetupCompleted)?
} else {
- let created = tx.sequence().next(created_at).await?;
- tx.logins().create(name, &password_hash, &created).await?
+ validated.store(&mut tx).await?
};
- let secret = tx.tokens().issue(&login, created_at).await?;
+ let secret = tx.tokens().issue(stored.login(), created_at).await?;
tx.commit().await?;
- self.events
- .broadcast(login.events().map(Event::from).collect::<Vec<_>>());
+ let login = stored.publish(self.events);
Ok((login.as_created(), secret))
}
@@ -67,3 +66,12 @@ pub enum Error {
#[error(transparent)]
PasswordHash(#[from] password_hash::Error),
}
+
+impl From<create::Error> for Error {
+ fn from(error: create::Error) -> Self {
+ match error {
+ create::Error::InvalidName(name) => Self::InvalidName(name),
+ create::Error::PasswordHash(error) => Self::PasswordHash(error),
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-01-02 19:12:28 +0000