From 5d3392799f88c5a3d3f9c656c73d6e8ac5c4d793 Mon Sep 17 00:00:00 2001
From: Owen Jacobson <owen@grimoire.ca>
Date: Wed, 2 Oct 2024 01:02:58 -0400
Subject: Split login and token handling.

---
 src/token/repo/token.rs | 151 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)
 create mode 100644 src/token/repo/token.rs

(limited to 'src/token/repo/token.rs')

diff --git a/src/token/repo/token.rs b/src/token/repo/token.rs
new file mode 100644
index 0000000..5f64dac
--- /dev/null
+++ b/src/token/repo/token.rs
@@ -0,0 +1,151 @@
+use sqlx::{sqlite::Sqlite, SqliteConnection, Transaction};
+use uuid::Uuid;
+
+use crate::{
+    clock::DateTime,
+    login::{self, Login},
+    token::{Id, Secret},
+};
+
+pub trait Provider {
+    fn tokens(&mut self) -> Tokens;
+}
+
+impl<'c> Provider for Transaction<'c, Sqlite> {
+    fn tokens(&mut self) -> Tokens {
+        Tokens(self)
+    }
+}
+
+pub struct Tokens<'t>(&'t mut SqliteConnection);
+
+impl<'c> Tokens<'c> {
+    // Issue a new token for an existing login. The issued_at timestamp will
+    // be used to control expiry, until the token is actually used.
+    pub async fn issue(
+        &mut self,
+        login: &Login,
+        issued_at: &DateTime,
+    ) -> Result<Secret, sqlx::Error> {
+        let id = Id::generate();
+        let secret = Uuid::new_v4().to_string();
+
+        let secret = sqlx::query_scalar!(
+            r#"
+                insert
+                into token (id, secret, login, issued_at, last_used_at)
+                values ($1, $2, $3, $4, $4)
+                returning secret as "secret!: Secret"
+            "#,
+            id,
+            secret,
+            login.id,
+            issued_at,
+        )
+        .fetch_one(&mut *self.0)
+        .await?;
+
+        Ok(secret)
+    }
+
+    pub async fn require(&mut self, token: &Id) -> Result<(), sqlx::Error> {
+        sqlx::query_scalar!(
+            r#"
+                select id as "id: Id"
+                from token
+                where id = $1
+            "#,
+            token,
+        )
+        .fetch_one(&mut *self.0)
+        .await?;
+
+        Ok(())
+    }
+
+    // Revoke a token by its secret.
+    pub async fn revoke(&mut self, token: &Id) -> Result<(), sqlx::Error> {
+        sqlx::query_scalar!(
+            r#"
+                delete
+                from token
+                where id = $1
+                returning id as "id: Id"
+            "#,
+            token,
+        )
+        .fetch_one(&mut *self.0)
+        .await?;
+
+        Ok(())
+    }
+
+    // Expire and delete all tokens that haven't been used more recently than
+    // `expire_at`.
+    pub async fn expire(&mut self, expire_at: &DateTime) -> Result<Vec<Id>, sqlx::Error> {
+        let tokens = sqlx::query_scalar!(
+            r#"
+                delete
+                from token
+                where last_used_at < $1
+                returning id as "id: Id"
+            "#,
+            expire_at,
+        )
+        .fetch_all(&mut *self.0)
+        .await?;
+
+        Ok(tokens)
+    }
+
+    // Validate a token by its secret, retrieving the associated Login record.
+    // Will return [None] if the token is not valid. The token's last-used
+    // timestamp will be set to `used_at`.
+    pub async fn validate(
+        &mut self,
+        secret: &Secret,
+        used_at: &DateTime,
+    ) -> Result<(Id, Login), sqlx::Error> {
+        // I would use `update … returning` to do this in one query, but
+        // sqlite3, as of this writing, does not allow an update's `returning`
+        // clause to reference columns from tables joined into the update. Two
+        // queries is fine, but it feels untidy.
+        sqlx::query!(
+            r#"
+                update token
+                set last_used_at = $1
+                where secret = $2
+            "#,
+            used_at,
+            secret,
+        )
+        .execute(&mut *self.0)
+        .await?;
+
+        let login = sqlx::query!(
+            r#"
+                select
+                    token.id as "token_id: Id",
+                    login.id as "login_id: login::Id",
+                    name as "login_name"
+                from login
+                join token on login.id = token.login
+                where token.secret = $1
+            "#,
+            secret,
+        )
+        .map(|row| {
+            (
+                row.token_id,
+                Login {
+                    id: row.login_id,
+                    name: row.login_name,
+                },
+            )
+        })
+        .fetch_one(&mut *self.0)
+        .await?;
+
+        Ok(login)
+    }
+}
-- 
cgit v1.2.3