Skip to main content

hyprstream_core/services/oauth/
token_store.rs

1//! Persistent refresh token store abstraction.
2//!
3//! `TokenStore` is the trait. `RocksDbTokenStore` (the `rocksdb` feature)
4//! wraps the existing rocksdb::DB. A Valkey implementation is provided when
5//! the `valkey` feature is enabled.
6
7use anyhow::Result;
8use async_trait::async_trait;
9#[cfg(feature = "rocksdb")]
10use parking_lot::Mutex;
11#[cfg(feature = "rocksdb")]
12use std::path::Path;
13#[cfg(any(feature = "rocksdb", feature = "valkey"))]
14use std::sync::Arc;
15
16use super::state::RefreshTokenEntry;
17
18/// Persistent storage for refresh tokens.
19#[async_trait]
20pub trait TokenStore: Send + Sync {
21    async fn put(&self, token: &str, entry: &RefreshTokenEntry, ttl_secs: u64) -> Result<()>;
22    async fn get(&self, token: &str) -> Result<Option<RefreshTokenEntry>>;
23    /// Atomically remove and return a token entry, if it is still present.
24    /// Used for single-use refresh-token rotation across all OAuth replicas.
25    async fn take(&self, token: &str) -> Result<Option<RefreshTokenEntry>>;
26    async fn delete(&self, token: &str) -> Result<()>;
27}
28
29/// RocksDB-backed refresh token store (requires the `rocksdb` feature).
30#[cfg(feature = "rocksdb")]
31pub struct RocksDbTokenStore {
32    db: Arc<rocksdb::DB>,
33    take_lock: Mutex<()>,
34}
35
36#[cfg(feature = "rocksdb")]
37impl RocksDbTokenStore {
38    pub fn open(path: impl AsRef<Path>) -> Result<Self> {
39        let mut opts = rocksdb::Options::default();
40        opts.create_if_missing(true);
41        let db = rocksdb::DB::open(&opts, path)?;
42        Ok(Self {
43            db: Arc::new(db),
44            take_lock: Mutex::new(()),
45        })
46    }
47}
48
49#[cfg(feature = "rocksdb")]
50#[async_trait]
51impl TokenStore for RocksDbTokenStore {
52    async fn put(&self, token: &str, entry: &RefreshTokenEntry, _ttl_secs: u64) -> Result<()> {
53        let bytes = serde_json::to_vec(entry)?;
54        self.db.put(token.as_bytes(), bytes)?;
55        Ok(())
56    }
57
58    async fn get(&self, token: &str) -> Result<Option<RefreshTokenEntry>> {
59        match self.db.get(token.as_bytes())? {
60            None => Ok(None),
61            Some(bytes) => {
62                let entry: RefreshTokenEntry = serde_json::from_slice(&bytes)?;
63                if entry.is_expired() {
64                    let _ = self.db.delete(token.as_bytes());
65                    Ok(None)
66                } else {
67                    Ok(Some(entry))
68                }
69            }
70        }
71    }
72
73    async fn take(&self, token: &str) -> Result<Option<RefreshTokenEntry>> {
74        let _guard = self.take_lock.lock();
75        match self.db.get(token.as_bytes())? {
76            None => Ok(None),
77            Some(bytes) => {
78                let entry: RefreshTokenEntry = serde_json::from_slice(&bytes)?;
79                self.db.delete(token.as_bytes())?;
80                if entry.is_expired() {
81                    Ok(None)
82                } else {
83                    Ok(Some(entry))
84                }
85            }
86        }
87    }
88
89    async fn delete(&self, token: &str) -> Result<()> {
90        self.db.delete(token.as_bytes())?;
91        Ok(())
92    }
93}
94
95/// Valkey-backed refresh token store (requires `valkey` feature).
96#[cfg(feature = "valkey")]
97pub struct ValkeyTokenStore {
98    pool: fred::prelude::RedisPool,
99    key_prefix: String,
100}
101
102#[cfg(feature = "valkey")]
103impl ValkeyTokenStore {
104    pub async fn connect(url: &str) -> Result<Self> {
105        use fred::prelude::*;
106        let config = RedisConfig::from_url(url)?;
107        let pool = Builder::from_config(config).build_pool(8)?;
108        pool.connect();
109        pool.wait_for_connect().await?;
110        Ok(Self {
111            pool,
112            key_prefix: "hs:token:".to_owned(),
113        })
114    }
115
116    fn key(&self, token: &str) -> String {
117        format!("{}{}", self.key_prefix, token)
118    }
119}
120
121#[cfg(feature = "valkey")]
122#[async_trait]
123impl TokenStore for ValkeyTokenStore {
124    async fn put(&self, token: &str, entry: &RefreshTokenEntry, ttl_secs: u64) -> Result<()> {
125        use fred::prelude::*;
126        let bytes = serde_json::to_string(entry)?;
127        self.pool
128            .set::<(), _, _>(
129                self.key(token),
130                bytes,
131                Some(Expiration::EX(ttl_secs as i64)),
132                None,
133                false,
134            )
135            .await?;
136        Ok(())
137    }
138
139    async fn get(&self, token: &str) -> Result<Option<RefreshTokenEntry>> {
140        use fred::prelude::*;
141        let val: Option<String> = self.pool.get(self.key(token)).await?;
142        match val {
143            None => Ok(None),
144            Some(s) => Ok(Some(serde_json::from_str(&s)?)),
145        }
146    }
147
148    async fn take(&self, token: &str) -> Result<Option<RefreshTokenEntry>> {
149        use fred::prelude::*;
150        let val: Option<String> = self.pool.getdel(self.key(token)).await?;
151        match val {
152            None => Ok(None),
153            Some(serialized) => {
154                let entry: RefreshTokenEntry = serde_json::from_str(&serialized)?;
155                if entry.is_expired() {
156                    Ok(None)
157                } else {
158                    Ok(Some(entry))
159                }
160            }
161        }
162    }
163
164    async fn delete(&self, token: &str) -> Result<()> {
165        use fred::prelude::*;
166        self.pool.del::<i64, _>(self.key(token)).await?;
167        Ok(())
168    }
169}
170
171#[cfg(test)]
172#[allow(clippy::unwrap_used)]
173mod tests {
174    use super::*;
175
176    #[cfg(feature = "rocksdb")]
177    #[tokio::test]
178    async fn rocksdb_take_allows_exactly_one_claim() {
179        let dir = tempfile::tempdir().unwrap();
180        let store = RocksDbTokenStore::open(dir.path()).unwrap();
181        let entry = RefreshTokenEntry {
182            client_id: "client".to_owned(),
183            username: "user".to_owned(),
184            scopes: vec!["openid".to_owned()],
185            resource: None,
186            expires_at_unix: chrono::Utc::now().timestamp() + 60,
187            verifying_key_bytes: None,
188            dpop_jkt: None,
189            client_assertion_jkt: None,
190            ucan_grant: None,
191            session_id: None,
192        };
193        store.put("refresh", &entry, 60).await.unwrap();
194
195        let first = store.take("refresh").await.unwrap();
196        let second = store.take("refresh").await.unwrap();
197
198        assert_eq!(
199            first.as_ref().map(|entry| entry.client_id.as_str()),
200            Some("client")
201        );
202        assert!(second.is_none());
203    }
204}