1 files changed, 9 insertions, 131 deletions

diff --git a/src/login/app.rs b/src/login/app.rs
index 182c62c..15adb31 100644
--- a/src/login/app.rs
+++ b/src/login/app.rs
@@ -1,57 +1,25 @@
-use chrono::TimeDelta;
-use futures::{
-    future,
-    stream::{self, StreamExt as _},
-    Stream,
-};
 use sqlx::sqlite::SqlitePool;
 
-use super::{broadcaster::Broadcaster, extract::IdentitySecret, repo::auth::Provider as _, types};
-use crate::{
-    clock::DateTime,
-    password::Password,
-    repo::{
-        error::NotFound as _,
-        login::{Login, Provider as _},
-        token::{self, Provider as _},
-    },
-};
+use crate::event::{repo::Provider as _, Sequence};
+
+#[cfg(test)]
+use super::{repo::Provider as _, Login, Password};
 
 pub struct Logins<'a> {
     db: &'a SqlitePool,
-    logins: &'a Broadcaster,
 }
 
 impl<'a> Logins<'a> {
-    pub const fn new(db: &'a SqlitePool, logins: &'a Broadcaster) -> Self {
-        Self { db, logins }
+    pub const fn new(db: &'a SqlitePool) -> Self {
+        Self { db }
     }
 
-    pub async fn login(
-        &self,
-        name: &str,
-        password: &Password,
-        login_at: &DateTime,
-    ) -> Result<IdentitySecret, LoginError> {
+    pub async fn boot_point(&self) -> Result<Sequence, sqlx::Error> {
         let mut tx = self.db.begin().await?;
-
-        let login = if let Some((login, stored_hash)) = tx.auth().for_name(name).await? {
-            if stored_hash.verify(password)? {
-                // Password verified; use the login.
-                login
-            } else {
-                // Password NOT verified.
-                return Err(LoginError::Rejected);
-            }
-        } else {
-            let password_hash = password.hash()?;
-            tx.logins().create(name, &password_hash).await?
-        };
-
-        let token = tx.tokens().issue(&login, login_at).await?;
+        let sequence = tx.sequence().current().await?;
         tx.commit().await?;
 
-        Ok(token)
+        Ok(sequence)
     }
 
     #[cfg(test)]
@@ -64,82 +32,6 @@ impl<'a> Logins<'a> {
 
         Ok(login)
     }
-
-    pub async fn validate(
-        &self,
-        secret: &IdentitySecret,
-        used_at: &DateTime,
-    ) -> Result<(token::Id, Login), ValidateError> {
-        let mut tx = self.db.begin().await?;
-        let login = tx
-            .tokens()
-            .validate(secret, used_at)
-            .await
-            .not_found(|| ValidateError::InvalidToken)?;
-        tx.commit().await?;
-
-        Ok(login)
-    }
-
-    pub fn limit_stream<E>(
-        &self,
-        token: token::Id,
-        events: impl Stream<Item = E> + std::fmt::Debug,
-    ) -> impl Stream<Item = E> + std::fmt::Debug
-    where
-        E: std::fmt::Debug,
-    {
-        let token_events = self
-            .logins
-            .subscribe()
-            .filter(move |event| future::ready(event.token == token))
-            .map(|_| GuardedEvent::TokenRevoked);
-
-        let events = events.map(|event| GuardedEvent::Event(event));
-
-        stream::select(token_events, events).scan((), |(), event| {
-            future::ready(match event {
-                GuardedEvent::Event(event) => Some(event),
-                GuardedEvent::TokenRevoked => None,
-            })
-        })
-    }
-
-    pub async fn expire(&self, relative_to: &DateTime) -> Result<(), sqlx::Error> {
-        // Somewhat arbitrarily, expire after 7 days.
-        let expire_at = relative_to.to_owned() - TimeDelta::days(7);
-
-        let mut tx = self.db.begin().await?;
-        let tokens = tx.tokens().expire(&expire_at).await?;
-        tx.commit().await?;
-
-        for event in tokens.into_iter().map(types::TokenRevoked::from) {
-            self.logins.broadcast(&event);
-        }
-
-        Ok(())
-    }
-
-    pub async fn logout(&self, token: &token::Id) -> Result<(), ValidateError> {
-        let mut tx = self.db.begin().await?;
-        tx.tokens().revoke(token).await?;
-        tx.commit().await?;
-
-        self.logins
-            .broadcast(&types::TokenRevoked::from(token.clone()));
-
-        Ok(())
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum LoginError {
-    #[error("invalid login")]
-    Rejected,
-    #[error(transparent)]
-    DatabaseError(#[from] sqlx::Error),
-    #[error(transparent)]
-    PasswordHashError(#[from] password_hash::Error),
 }
 
 #[cfg(test)]
@@ -149,17 +41,3 @@ pub enum CreateError {
     DatabaseError(#[from] sqlx::Error),
     PasswordHashError(#[from] password_hash::Error),
 }
-
-#[derive(Debug, thiserror::Error)]
-pub enum ValidateError {
-    #[error("invalid token")]
-    InvalidToken,
-    #[error(transparent)]
-    DatabaseError(#[from] sqlx::Error),
-}
-
-#[derive(Debug)]
-enum GuardedEvent<E> {
-    TokenRevoked,
-    Event(E),
-}