hyprstream_core/services/oauth/
token_store.rs1use 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#[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 async fn take(&self, token: &str) -> Result<Option<RefreshTokenEntry>>;
26 async fn delete(&self, token: &str) -> Result<()>;
27}
28
29#[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#[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}