Skip to main content

libkeri/keri/db/subing/
serder.rs

1use crate::keri::core::serdering::{Rawifiable, Serder, SerderACDC, SerderKERI};
2use crate::keri::db::dbing::{BytesDatabase, LMDBer};
3use crate::keri::db::errors::DBError;
4use crate::keri::db::subing::{SuberError, ValueCodec};
5use std::marker::PhantomData;
6use std::sync::Arc;
7
8/// A codec for serializing and deserializing Serder instances
9pub struct SerderCodec<S: Serder + 'static> {
10    verify: bool,
11    _serder_type: PhantomData<S>,
12}
13
14impl<S: Serder + 'static> SerderCodec<S> {
15    pub fn new(verify: bool) -> Self {
16        Self {
17            verify,
18            _serder_type: PhantomData,
19        }
20    }
21}
22
23impl<S: Serder + 'static> ValueCodec for SerderCodec<S> {
24    type Error = SuberError;
25
26    fn serialize<T: ?Sized + Clone + Into<Vec<u8>>>(val: &T) -> Result<Vec<u8>, SuberError> {
27        // For Serder instances, we use the raw bytes
28        Ok(val.clone().into())
29    }
30
31    fn deserialize<T: TryFrom<Vec<u8>>>(bytes: &[u8]) -> Result<T, SuberError> {
32        // This is a placeholder. The actual implementation will come from the SerderSuberBase
33        Err(SuberError::DeserializationError(
34            "Direct deserialization not implemented".to_string(),
35        ))
36    }
37}
38
39/// A struct for handling serialized Serder instances in a database
40pub struct SerderSuberBase<S: Serder + Rawifiable + 'static> {
41    db: Arc<LMDBer>,              // The base LMDB database
42    sdb: BytesDatabase,           // The sub-database
43    sep: u8,                      // Separator for combining keys
44    verify: bool,                 // Whether to verify data when deserializing
45    _serder_type: PhantomData<S>, // Track the Serder type
46}
47
48impl<S: Serder + Rawifiable + 'static> SerderSuberBase<S> {
49    /// Create a new SerderSuberBase instance
50    pub fn new(
51        db: Arc<LMDBer>,
52        subkey: &str,
53        sep: Option<u8>,
54        verify: bool,
55    ) -> Result<Self, SuberError> {
56        let sdb = db.create_database(Some(subkey), Some(false))?;
57
58        Ok(Self {
59            db,
60            sdb,
61            sep: sep.unwrap_or(b'.'),
62            verify,
63            _serder_type: PhantomData,
64        })
65    }
66
67    /// Convert various key forms to bytes
68    pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
69        // Same implementation as SuberBase
70        let mut result = Vec::new();
71
72        // If there's only one key and it's already bytes, return it directly
73        if keys.len() == 1 {
74            let key = keys[0].as_ref();
75            if !topive {
76                return key.to_vec();
77            }
78            // For topive=true, append separator
79            result.extend_from_slice(key);
80            result.push(self.sep);
81            return result;
82        }
83
84        // Join multiple keys with separators
85        for (i, key) in keys.iter().enumerate() {
86            if i > 0 {
87                result.push(self.sep);
88            }
89            result.extend_from_slice(key.as_ref());
90        }
91
92        // Add trailing separator for topive
93        if topive && (!result.is_empty() && result[result.len() - 1] != self.sep) {
94            result.push(self.sep);
95        }
96
97        result
98    }
99
100    /// Convert a key to a vector of key parts
101    pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
102        // Same implementation as SuberBase
103        key.split(|&b| b == self.sep)
104            .map(|part| part.to_vec())
105            .collect()
106    }
107
108    /// Serialize a Serder to bytes
109    fn ser(&self, val: &S) -> Vec<u8> {
110        // For Serder instances, we just use the raw bytes
111        val.raw().to_vec()
112    }
113
114    /// Deserialize bytes to a Serder
115    fn des(&self, val: &[u8]) -> Result<S, SuberError> {
116        // Create a Serder instance from the raw bytes
117        S::from_raw(val, None).map_err(|e| {
118            SuberError::DeserializationError(format!("Failed to deserialize Serder: {}", e))
119        })
120    }
121
122    /// Get a serder value by key
123    pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<S>, SuberError> {
124        let key = self.to_key(keys, false);
125
126        if let Some(val) = self.db.get_val(&self.sdb, &key)? {
127            // Create the Serder instance from raw bytes
128            let serder = self.des(&val)?;
129
130            Ok(Some(serder))
131        } else {
132            Ok(None)
133        }
134    }
135
136    /// Put a serder value at keys (doesn't overwrite)
137    pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &S) -> Result<bool, SuberError> {
138        let key = self.to_key(keys, false);
139        let val_bytes = self.ser(val);
140
141        Ok(self.db.put_val(&self.sdb, &key, &val_bytes)?)
142    }
143
144    /// Pin (set) a serder value at keys (overwrites)
145    pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], val: &S) -> Result<bool, SuberError> {
146        let key = self.to_key(keys, false);
147        let val_bytes = self.ser(val);
148
149        Ok(self.db.set_val(&self.sdb, &key, &val_bytes)?)
150    }
151
152    /// Remove an entry at keys
153    pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
154        let key = self.to_key(keys, false);
155        Ok(self.db.del_val(&self.sdb, &key)?)
156    }
157
158    /// Remove entries with keys starting with a prefix
159    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
160        let key = self.to_key(keys, topive);
161        Ok(self.db.del_top_val(&self.sdb, &key)?)
162    }
163
164    /// Iterator for full items (with all parts visible)
165    pub fn get_full_item_iter<K: AsRef<[u8]>>(
166        &self,
167        keys: &[K],
168        topive: bool,
169    ) -> Result<Vec<(Vec<Vec<u8>>, S)>, SuberError> {
170        let key = self.to_key(keys, topive);
171
172        let mut result = Vec::new();
173        self.db.get_top_items_iter(&self.sdb, &key, |k, v| {
174            // Create the Serder instance from raw bytes
175            let serder = match self.des(v) {
176                Ok(s) => s,
177                Err(e) => {
178                    return Err(DBError::ValueError(format!(
179                        "Failed to deserialize Serder: {}",
180                        e
181                    )))
182                }
183            };
184
185            result.push((self.to_keys(k), serder));
186            Ok(true) // Continue iteration for all items
187        })?;
188
189        Ok(result)
190    }
191
192    /// Iterator for normal items (hiding implementation details)
193    pub fn get_item_iter<K: AsRef<[u8]>>(
194        &self,
195        keys: &[K],
196        topive: bool,
197    ) -> Result<Vec<(Vec<Vec<u8>>, S)>, SuberError> {
198        // By default, this is the same as get_full_item_iter
199        self.get_full_item_iter(keys, topive)
200    }
201
202    /// Count all items in the database
203    pub fn cnt_all(&self) -> Result<usize, SuberError> {
204        Ok(self.db.cnt(&self.sdb)?)
205    }
206}
207
208/// SerderSuber is a specialized database class for storing and retrieving Serder instances.
209/// It combines the functionality of SerderSuberBase and Suber.
210pub struct SerderSuber<S: Serder + Rawifiable + 'static> {
211    base: SerderSuberBase<S>,
212}
213
214impl<S: Serder + Rawifiable + 'static> SerderSuber<S> {
215    /// Create a new SerderSuber instance
216    pub fn new(
217        db: Arc<LMDBer>,
218        subkey: &str,
219        sep: Option<u8>,
220        verify: bool,
221    ) -> Result<Self, SuberError> {
222        let base = SerderSuberBase::new(db, subkey, sep, verify)?;
223        Ok(Self { base })
224    }
225
226    /// Put a serder value at keys (doesn't overwrite)
227    /// Returns true if put, false if key already exists
228    pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &S) -> Result<bool, SuberError> {
229        self.base.put(keys, val)
230    }
231
232    /// Pin (set) a serder value at keys (overwrites)
233    /// Returns true if successful
234    pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], val: &S) -> Result<bool, SuberError> {
235        self.base.pin(keys, val)
236    }
237
238    /// Get a serder value by key
239    /// Returns Some(S) if found, None if not found
240    pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<S>, SuberError> {
241        self.base.get(keys)
242    }
243
244    /// Remove an entry at keys
245    /// Returns true if removed, false if not found
246    pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
247        self.base.rem(keys)
248    }
249
250    /// Remove entries with keys starting with a prefix
251    /// Returns true if any entries were removed
252    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
253        self.base.trim(keys, topive)
254    }
255
256    /// Iterator for full items (with all parts visible)
257    pub fn get_full_item_iter<K: AsRef<[u8]>>(
258        &self,
259        keys: &[K],
260        topive: bool,
261    ) -> Result<Vec<(Vec<Vec<u8>>, S)>, SuberError> {
262        self.base.get_full_item_iter(keys, topive)
263    }
264
265    /// Iterator for normal items (hiding implementation details)
266    pub fn get_item_iter<K: AsRef<[u8]>>(
267        &self,
268        keys: &[K],
269        topive: bool,
270    ) -> Result<Vec<(Vec<Vec<u8>>, S)>, SuberError> {
271        self.base.get_item_iter(keys, topive)
272    }
273
274    /// Count all items in the database
275    pub fn cnt_all(&self) -> Result<usize, SuberError> {
276        self.base.cnt_all()
277    }
278}
279
280/// A type alias for common usage with SerderKERI
281pub type SerderKERISuber = SerderSuber<SerderKERI>;
282pub type SerderACDCSuber = SerderSuber<SerderACDC>;
283
284#[cfg(test)]
285mod tests {
286    use super::*;
287    use crate::keri::core::serdering::SerderKERI;
288    use crate::keri::db::dbing::LMDBer;
289    use std::sync::Arc;
290
291    #[test]
292    fn test_serder_suber() -> Result<(), SuberError> {
293        // Create a temporary database for testing
294        let lmdber = LMDBer::builder()
295            .name("test_serder_db")
296            .temp(true)
297            .build()?;
298        let db = Arc::new(lmdber);
299
300        // Create a SerderSuber instance
301        let suber: SerderSuber<SerderKERI> = SerderSuber::new(db, "serders.", None, false)?;
302
303        // Create a test SerderKERI
304        let sample_ked = r#"{"v":"KERI10JSON00012b_","t":"icp","d":"EDkU2U_TPKca14VElEItpj7twohQL60GIaUPvSHAghga","i":"EDkU2U_TPKca14VElEItpj7twohQL60GIaUPvSHAghga","s":"0","kt":"1","k":["DLcVCJsrp_z4To1j52pggULYa_PEs2sCZggVJ3jBUFeI"],"nt":"1","n":["EA1P0H2qNRf_685xnztMESEs36hwWBTTQmwVrZr5qGyQ"],"bt":"0","b":[],"c":[],"a":[]}"#;
305        let serder =
306            SerderKERI::from_raw(sample_ked.as_ref(), None).expect("Failed to parse test Serder");
307
308        // Test putting and getting a serder
309        let keys = &["test_key".as_bytes()];
310        suber.put(keys, &serder)?;
311
312        let retrieved = suber.get(keys)?;
313        assert!(retrieved.is_some());
314
315        let retrieved_serder = retrieved.unwrap();
316        assert_eq!(retrieved_serder.raw(), serder.raw());
317
318        // Test overwrite with pin
319        let sample_ked2 = r#"{"v":"KERI10JSON000160_","t":"rot","d":"EAg5uUuKVgvaz0vgEC7B-rQdsXHhDCXXbKdO5KRTDQFq","i":"EFa1wAk_coghxxGCID6jEN79Kmvyj0Y1wWN_ndUv3LjW","s":"1","p":"EFa1wAk_coghxxGCID6jEN79Kmvyj0Y1wWN_ndUv3LjW","kt":"1","k":["DAceoFXtYpYjyKGLLfv0Hs4YSGQtqmzKx64zfMI9fBUM"],"nt":"1","n":["EPwseSLvRsbjHDUGeZJSed0HF_Myw8qvZksRTQBC2cjO"],"bt":"0","br":[],"ba":[],"a":[]}"#;
320        let serder2 =
321            SerderKERI::from_raw(sample_ked2.as_ref(), None).expect("Failed to parse test Serder");
322
323        // First attempt with put (should fail to overwrite)
324        let result = suber.put(keys, &serder2)?;
325        assert!(!result); // Should return false because key exists
326
327        // Get and verify it's still the original
328        let retrieved = suber.get(keys)?.unwrap();
329        assert_eq!(retrieved.raw(), serder.raw());
330
331        // Now use pin to overwrite
332        let result = suber.pin(keys, &serder2)?;
333        assert!(result);
334
335        // Get and verify it's the new value
336        let retrieved = suber.get(keys)?.unwrap();
337        assert_eq!(retrieved.raw(), serder2.raw());
338
339        // Test removing an entry
340        let result = suber.rem(keys)?;
341        assert!(result);
342
343        let retrieved = suber.get(keys)?;
344        assert!(retrieved.is_none());
345
346        // Test adding multiple entries and using iterators
347        let serders = [
348            (vec!["a", "1"], serder.clone()),
349            (vec!["a", "2"], serder2.clone()),
350        ];
351
352        for (k, s) in &serders {
353            let key_bytes: Vec<&[u8]> = k.iter().map(|s| s.as_bytes()).collect();
354            suber.put(&key_bytes, s)?;
355        }
356
357        // Test get_item_iter
358        let iter_keys = &["a".as_bytes()];
359        let items = suber.get_item_iter(iter_keys, true)?;
360
361        assert_eq!(items.len(), 2);
362
363        // Test cnt_all
364        let count = suber.cnt_all()?;
365        assert_eq!(count, 2);
366
367        // Test trim
368        suber.trim(iter_keys, true)?;
369        let count = suber.cnt_all()?;
370        assert_eq!(count, 0);
371
372        Ok(())
373    }
374}