Simplify access token mapping and allow token invalidation

Author: bubelov

src/db/main/access_token/blocking_queries.rs

@@ -1,8 +1,9 @@
-use super::schema::Columns;
 use super::schema::{self, AccessToken};
 use crate::db::main::user::schema::Role;
 use crate::Result;
 use rusqlite::{params, Connection};
+use schema::Columns::*;
+use schema::TABLE;
 
 pub fn insert(
     user_id: i64,
@@ -14,15 +15,10 @@ pub fn insert(
     let roles: Vec<String> = roles.iter().map(|it| it.to_string()).collect();
     let sql = format!(
         r#"
-            INSERT INTO {table} ({user_id}, {name}, {secret}, {roles})
+            INSERT INTO {TABLE} ({UserId}, {Name}, {Secret}, {Roles})
             VALUES (?1, ?2, ?3, json(?4))
             RETURNING {projection}
         "#,
-        table = schema::NAME,
-        user_id = Columns::UserId.as_str(),
-        name = Columns::Name.as_str(),
-        secret = Columns::Secret.as_str(),
-        roles = Columns::Roles.as_str(),
         projection = AccessToken::projection(),
     );
     conn.query_row(
@@ -38,10 +34,9 @@ pub fn select_all(conn: &Connection) -> Result<Vec<AccessToken>> {
     let sql = format!(
         r#"
             SELECT {projection}
-            FROM {table}
+            FROM {TABLE}
         "#,
         projection = AccessToken::projection(),
-        table = schema::NAME,
     );
     conn.prepare(&sql)?
         .query_map({}, AccessToken::mapper())?
@@ -54,12 +49,10 @@ pub fn select_by_id(id: i64, conn: &Connection) -> Result<AccessToken> {
     let sql = format!(
         r#"
             SELECT {projection}
-            FROM {table}
-            WHERE {id} = ?1
+            FROM {TABLE}
+            WHERE {Id} = ?1
         "#,
         projection = AccessToken::projection(),
-        table = schema::NAME,
-        id = Columns::Id.as_str(),
     );
     conn.query_row(&sql, params![id], AccessToken::mapper())
         .map_err(Into::into)
@@ -69,34 +62,15 @@ pub fn select_by_secret(secret: &str, conn: &Connection) -> Result<AccessToken>
     let sql = format!(
         r#"
             SELECT {projection}
-            FROM {table}
-            WHERE {secret} = ?1
+            FROM {TABLE}
+            WHERE {Secret} = ?1 AND {DeletedAt} IS NULL
         "#,
         projection = AccessToken::projection(),
-        table = schema::NAME,
-        secret = Columns::Secret.as_str(),
     );
     conn.query_row(&sql, params![secret], AccessToken::mapper())
         .map_err(Into::into)
 }
 
-#[cfg(test)]
-pub fn set_roles(token_id: i64, roles: &[Role], conn: &Connection) -> Result<()> {
-    let sql = format!(
-        r#"
-            UPDATE {table}
-            SET {roles} = json(?1)
-            WHERE {id} = ?2
-        "#,
-        table = schema::NAME,
-        roles = Columns::Roles.as_str(),
-        id = Columns::Id.as_str(),
-    );
-    let roles: Vec<String> = roles.iter().map(|role| role.to_string()).collect();
-    conn.execute(&sql, params![serde_json::to_string(&roles)?, token_id])?;
-    Ok(())
-}
-
 #[cfg(test)]
 mod test {
     use crate::db::main::test::conn;
@@ -106,32 +80,27 @@ mod test {
     #[test]
     fn insert() -> Result<()> {
         let conn = conn();
-        let user = crate::db::main::user::blocking_queries::insert("test_user", "password", &conn)?;
         let name = "name";
         let secret = "secret";
         let roles = vec![Role::Admin];
-
-        let inserted_token = super::insert(user.id, name, secret, &roles, &conn)?;
+        let inserted_token = super::insert(2, name, secret, &roles, &conn)?;
         let selected_token = super::select_by_id(inserted_token.id, &conn)?;
-
+        assert_eq!(inserted_token, selected_token);
         assert_eq!(selected_token, inserted_token);
-
         assert_eq!(1, selected_token.id);
-        assert_eq!(user.id, selected_token.user_id);
+        assert_eq!(2, selected_token.user_id);
         assert_eq!(Some(name), selected_token.name.as_deref());
         assert_eq!(secret, selected_token.secret);
         assert_eq!(roles, selected_token.roles);
         assert!(selected_token.deleted_at.is_none());
-
         Ok(())
     }
 
     #[test]
     fn select_all() -> Result<()> {
         let conn = conn();
-        let user = crate::db::main::user::blocking_queries::insert("test_user", "password", &conn)?;
-        let token_1 = super::insert(user.id, "name_1", "pwd_1", &[], &conn)?;
-        let token_2 = super::insert(user.id, "name_2", "pwd_2", &[], &conn)?;
+        let token_1 = super::insert(1, "name_1", "pwd_1", &[], &conn)?;
+        let token_2 = super::insert(1, "name_2", "pwd_2", &[], &conn)?;
         let query_res = super::select_all(&conn)?;
         assert_eq!(2, query_res.len());
         assert_eq!(&token_1, query_res.first().unwrap());
@@ -142,8 +111,7 @@ mod test {
     #[test]
     fn select_by_id() -> Result<()> {
         let conn = conn();
-        let user = crate::db::main::user::blocking_queries::insert("test_user", "password", &conn)?;
-        let insert_res = super::insert(user.id, "name", "pwd", &[], &conn)?;
+        let insert_res = super::insert(1, "name", "pwd", &[], &conn)?;
         let select_res = super::select_by_id(insert_res.id, &conn)?;
         assert_eq!(insert_res, select_res);
         Ok(())
@@ -152,22 +120,10 @@ mod test {
     #[test]
     fn select_by_secret() -> Result<()> {
         let conn = conn();
-        let user = crate::db::main::user::blocking_queries::insert("test_user", "password", &conn)?;
         let secret = "xxx";
-        let token = super::insert(user.id, "", secret, &[], &conn)?;
+        let token = super::insert(1, "", secret, &[], &conn)?;
         let select_res = super::select_by_secret(secret, &conn)?;
         assert_eq!(token, select_res);
         Ok(())
     }
-
-    #[test]
-    fn set_roles() -> Result<()> {
-        let conn = conn();
-        let user = crate::db::main::user::blocking_queries::insert("test_user", "password", &conn)?;
-        let token = super::insert(user.id, "name", "pwd", &[], &conn)?;
-        let roles = vec![Role::User, Role::Admin];
-        super::set_roles(token.id, &roles, &conn)?;
-        assert_eq!(roles, super::select_by_id(token.id, &conn)?.roles);
-        Ok(())
-    }
 }

src/db/main/access_token/mod.rs

@@ -1,3 +1,3 @@
-pub(super) mod blocking_queries;
+mod blocking_queries;
 pub mod queries;
 pub mod schema;

src/db/main/access_token/schema.rs

@@ -4,8 +4,10 @@ use serde_json::Value;
 use std::{str::FromStr, sync::OnceLock};
 use time::OffsetDateTime;
 
-pub const NAME: &str = "access_token";
+pub const TABLE: &str = "access_token";
 
+#[derive(strum::AsRefStr, strum::Display)]
+#[strum(serialize_all = "snake_case")]
 pub enum Columns {
     Id,
     UserId,
@@ -17,21 +19,6 @@ pub enum Columns {
     DeletedAt,
 }
 
-impl Columns {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            Columns::Id => "id",
-            Columns::UserId => "user_id",
-            Columns::Name => "name",
-            Columns::Secret => "secret",
-            Columns::Roles => "roles",
-            Columns::CreatedAt => "created_at",
-            Columns::UpdatedAt => "updated_at",
-            Columns::DeletedAt => "deleted_at",
-        }
-    }
-}
-
 #[allow(dead_code)]
 #[derive(Eq, PartialEq, Debug)]
 pub struct AccessToken {
@@ -60,7 +47,7 @@ impl AccessToken {
                 Columns::DeletedAt,
             ]
             .iter()
-            .map(Columns::as_str)
+            .map(AsRef::as_ref)
             .collect::<Vec<_>>()
             .join(", ")
         })
@@ -69,23 +56,24 @@ impl AccessToken {
     pub const fn mapper() -> fn(&Row) -> rusqlite::Result<Self> {
         |row: &Row| -> rusqlite::Result<Self> {
             Ok(AccessToken {
-                id: row.get(Columns::Id.as_str())?,
-                user_id: row.get(Columns::UserId.as_str())?,
-                name: row.get(Columns::Name.as_str())?,
-                secret: row.get(Columns::Secret.as_str())?,
-                roles: Self::parse_roles(row.get(Columns::Roles.as_str())?),
-                created_at: row.get(Columns::CreatedAt.as_str())?,
-                updated_at: row.get(Columns::UpdatedAt.as_str())?,
-                deleted_at: row.get(Columns::DeletedAt.as_str())?,
+                id: row.get(Columns::Id.as_ref())?,
+                user_id: row.get(Columns::UserId.as_ref())?,
+                name: row.get(Columns::Name.as_ref())?,
+                secret: row.get(Columns::Secret.as_ref())?,
+                roles: Self::parse_roles(row.get(Columns::Roles.as_ref())?)?,
+                created_at: row.get(Columns::CreatedAt.as_ref())?,
+                updated_at: row.get(Columns::UpdatedAt.as_ref())?,
+                deleted_at: row.get(Columns::DeletedAt.as_ref())?,
             })
         }
     }
 
-    fn parse_roles(column_value: Value) -> Vec<Role> {
-        let roles: Vec<String> = serde_json::from_value(column_value).unwrap_or_default();
-        roles
+    fn parse_roles(column_value: Value) -> rusqlite::Result<Vec<Role>> {
+        let roles: Vec<String> = serde_json::from_value(column_value)
+            .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
+        Ok(roles
             .into_iter()
             .filter_map(|s| Role::from_str(&s).ok())
-            .collect()
+            .collect())
     }
 }