Skip to main content

libkeri/keri/db/subing/
cesr.rs

1use crate::cesr::Matter;
2use crate::cesr::Parsable;
3use crate::keri::db::dbing::LMDBer;
4use crate::keri::db::errors::DBError;
5use crate::keri::db::subing::{SuberBase, SuberError, ValueCodec};
6use std::marker::PhantomData;
7use std::sync::Arc;
8
9// CesrCodec implements ValueCodec trait for CESR objects
10pub struct CesrCodec<T: Matter> {
11    _phantom: PhantomData<T>,
12}
13
14impl<T: Matter> ValueCodec for CesrCodec<T> {
15    type Error = SuberError;
16
17    fn serialize<V: ?Sized + Clone + Into<Vec<u8>>>(val: &V) -> Result<Vec<u8>, SuberError> {
18        // In the case of Matter objects, we should use qb64b
19        // But this is a generic function that can receive other types
20        // We'll assume val can be converted to Vec<u8>
21        Ok(val.clone().into())
22    }
23
24    fn deserialize<V: TryFrom<Vec<u8>>>(bytes: &[u8]) -> Result<V, SuberError> {
25        // Generic deserialization using TryFrom
26        match V::try_from(bytes.to_vec()) {
27            Ok(v) => Ok(v),
28            Err(_) => Err(SuberError::DeserializationError(
29                "Failed to deserialize value".to_string(),
30            )),
31        }
32    }
33}
34
35// The actual CesrSuberBase implementation
36pub struct CesrSuberBase<M: Matter> {
37    pub base: SuberBase<CesrCodec<M>>,
38    _matter_type: PhantomData<M>,
39}
40
41#[allow(dead_code)]
42impl<M: Matter + Parsable> CesrSuberBase<M> {
43    pub fn new(
44        db: Arc<LMDBer>,
45        subkey: &str,
46        sep: Option<u8>,
47        verify: bool,
48    ) -> Result<Self, SuberError> {
49        let base = SuberBase::<CesrCodec<M>>::new(db, subkey, sep, verify, Some(false))?;
50
51        Ok(Self {
52            base,
53            _matter_type: PhantomData,
54        })
55    }
56
57    // Override ser method to use Matter's qb64b method
58    pub fn ser(&self, val: &M) -> Result<Vec<u8>, SuberError> {
59        Ok(val.qb64b())
60    }
61
62    // Override des method to use Matter's from_qb64b method
63    pub fn des(&self, val: &[u8]) -> Result<M, SuberError> {
64        Ok(M::from_qb64b(&mut val.to_vec(), None)?)
65    }
66
67    pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
68        self.base.to_key(keys, topive)
69    }
70
71    // Delegate methods to the base implementation
72    pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
73        let key = self.base.to_key(keys, false);
74        let val_bytes = self.ser(val)?;
75        Ok(self.base.db.put_val(&self.base.sdb, &key, &val_bytes)?)
76    }
77
78    pub fn put_val(&self, key: &[u8], val: &[u8]) -> Result<bool, DBError> {
79        self.base.db.put_val(&self.base.sdb, key, val)
80    }
81
82    pub fn set_val(&self, key: &[u8], val: &[u8]) -> Result<bool, DBError> {
83        self.base.db.set_val(&self.base.sdb, key, val)
84    }
85
86    // Delegate methods to the base implementation
87    pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
88        let key = self.base.to_key(keys, false);
89        let val_bytes = self.ser(val)?;
90        Ok(self.base.db.set_val(&self.base.sdb, &key, &val_bytes)?)
91    }
92
93    pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<M>, SuberError> {
94        let key = self.base.to_key(keys, false);
95        if let Some(val) = self.base.db.get_val(&self.base.sdb, &key)? {
96            Ok(Some(self.des(&val)?))
97        } else {
98            Ok(None)
99        }
100    }
101
102    // Remove an entry at keys
103    pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
104        self.base.trim(keys, false)
105    }
106
107    // Delegate the remaining methods to base
108    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
109        Ok(self.base.trim(keys, topive)?)
110    }
111
112    pub fn get_full_item_iter<K: AsRef<[u8]>>(
113        &self,
114        keys: &[K],
115        topive: bool,
116    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
117        Ok(self.base.get_full_item_iter(keys, topive)?)
118    }
119
120    pub fn get_item_iter<K: AsRef<[u8]>>(
121        &self,
122        keys: &[K],
123        topive: bool,
124    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
125        Ok(self.base.get_item_iter(keys, topive)?)
126    }
127
128    pub fn cnt_all(&self) -> Result<usize, SuberError> {
129        Ok(self.base.cnt_all()?)
130    }
131
132    // Add additional methods that would transform raw byte values into Matter instances
133    pub fn process_items(
134        &self,
135        items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
136    ) -> Result<Vec<(Vec<Vec<u8>>, M)>, SuberError> {
137        items
138            .into_iter()
139            .map(|(keys, val)| {
140                let matter = self.des(&val)?;
141                Ok((keys, matter))
142            })
143            .collect()
144    }
145}
146
147// Similar to the Python Suber class, we can implement a wrapper for CesrSuberBase
148pub struct CesrSuber<M: Matter> {
149    base: CesrSuberBase<M>,
150}
151
152impl<M: Matter + Parsable> CesrSuber<M> {
153    pub fn new(
154        db: Arc<LMDBer>,
155        subkey: &str,
156        sep: Option<u8>,
157        verify: bool,
158    ) -> Result<Self, SuberError> {
159        let base = CesrSuberBase::new(db, subkey, sep, verify)?;
160
161        Ok(Self { base })
162    }
163
164    // Delegate all methods to the base
165    pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
166        self.base.pin(keys, val)
167    }
168
169    // Delegate all methods to the base
170    pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
171        self.base.put(keys, val)
172    }
173
174    pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<M>, SuberError> {
175        self.base.get(keys)
176    }
177
178    pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
179        self.base.rem(keys)
180    }
181
182    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
183        self.base.trim(keys, topive)
184    }
185
186    pub fn get_full_item_iter<K: AsRef<[u8]>>(
187        &self,
188        keys: &[K],
189        topive: bool,
190    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
191        self.base.get_full_item_iter(keys, topive)
192    }
193
194    pub fn get_item_iter<K: AsRef<[u8]>>(
195        &self,
196        keys: &[K],
197        topive: bool,
198    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
199        self.base.get_item_iter(keys, topive)
200    }
201
202    pub fn process_items(
203        &self,
204        items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
205    ) -> Result<Vec<(Vec<Vec<u8>>, M)>, SuberError> {
206        self.base.process_items(items)
207    }
208
209    pub fn cnt_all(&self) -> Result<usize, SuberError> {
210        self.base.cnt_all()
211    }
212}
213
214#[cfg(test)]
215mod tests {
216    use super::*;
217    use std::sync::Arc;
218
219    use crate::cesr::diger::Diger;
220    use crate::cesr::indexing::siger::Siger;
221    use crate::cesr::{BaseMatter, Matter};
222    use crate::keri::db::dbing::LMDBer;
223    use crate::keri::db::subing::cesr::CesrSuber;
224
225    #[test]
226    fn test_cesr_suber() -> Result<(), SuberError> {
227        // Create a temporary database for testing
228        let lmdber = LMDBer::builder().name("test_db").temp(true).build()?;
229
230        // Create "seen." database
231        assert_eq!(lmdber.name(), "test_db");
232        assert!(lmdber.opened());
233
234        let db_ref = Arc::new(lmdber);
235
236        // Create CesrSuber with default Matter class
237        let sdb = CesrSuber::<BaseMatter>::new(db_ref.clone(), "bags.", None, true)?;
238
239        // Test with initial value
240        let pre0 = "BDzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc";
241        let val0 = BaseMatter::from_qb64(pre0)?;
242
243        // Test keys as tuple
244        let keys: &[&[u8]] = &[b"alpha".as_ref(), b"dog".as_ref()];
245
246        // Test put operation
247        let result = sdb.put(keys, &val0)?;
248        assert!(result);
249
250        // Test get operation
251        let actual = sdb.get(keys)?.unwrap();
252        assert_eq!(actual.qb64(), val0.qb64());
253
254        // Test trim (remove) operation
255        let result = sdb.trim(keys, false)?;
256        assert!(result);
257
258        // Verify the entry is removed
259        let actual = sdb.get(keys)?;
260        assert!(actual.is_none());
261
262        // Put again and verify
263        let result = sdb.put(keys, &val0)?;
264        assert!(result);
265
266        let actual = sdb.get(keys)?.unwrap();
267        assert_eq!(actual.qb64(), val0.qb64());
268
269        // Attempt to put a different value (pin without force should fail)
270        let pre1 = "BHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc";
271        let val1 = BaseMatter::from_qb64(pre1)?;
272
273        // This should fail because it's not a forced update (equivalent to Python's put returning False)
274        let result = sdb.put(keys, &val1)?;
275        assert!(!result);
276
277        // Original value should still be there
278        let actual = sdb.get(keys)?.unwrap();
279        assert_eq!(actual.qb64(), val0.qb64());
280
281        // Force update with pin operation (trim and put)
282        // In our Rust implementation, this would be a trim followed by a put
283        let trim_result = sdb.trim(keys, false)?;
284        assert!(trim_result);
285
286        let put_result = sdb.put(keys, &val1)?;
287        assert!(put_result);
288
289        let actual = sdb.get(keys)?.unwrap();
290        assert_eq!(actual.qb64(), val1.qb64());
291
292        // Test with keys as string
293        let keys_str: &[&[u8]] = &[b"beta.fish".as_ref()];
294
295        let result = sdb.put(keys_str, &val1)?;
296        assert!(result);
297
298        let actual = sdb.get(keys_str)?.unwrap();
299        assert_eq!(actual.qb64(), val1.qb64());
300
301        let result = sdb.trim(keys_str, false)?;
302        assert!(result);
303
304        let actual = sdb.get(keys_str)?;
305        assert!(actual.is_none());
306
307        // Test missing entry
308        let bad_key: &[&[u8]] = &[b"badkey".as_ref()];
309        let actual = sdb.get(bad_key)?;
310        assert!(actual.is_none());
311
312        // Test iteritems (get_item_iter)
313        let sdb_pugs = CesrSuber::<BaseMatter>::new(db_ref.clone(), "pugs.", None, true)?;
314
315        let keys_a1: &[&[u8]] = &[b"a".as_ref(), b"1".as_ref()];
316        let keys_a2: &[&[u8]] = &[b"a".as_ref(), b"2".as_ref()];
317
318        assert!(sdb_pugs.put(keys_a1, &val0)?);
319        assert!(sdb_pugs.put(keys_a2, &val1)?);
320
321        let empty: [&[u8]; 0] = [];
322        let items = sdb_pugs.get_item_iter(&empty, false)?;
323        let processed_items = sdb_pugs.process_items(items)?;
324
325        // Convert the result to a format we can easily check
326        let mut result_items = Vec::new();
327        for (keys_vec, val) in processed_items {
328            let keys_tuple: Vec<String> = keys_vec
329                .into_iter()
330                .map(|k| String::from_utf8(k).unwrap())
331                .collect();
332
333            result_items.push((keys_tuple, val.qb64()));
334        }
335
336        // Check the iteritems result
337        assert_eq!(result_items.len(), 2);
338        assert_eq!(result_items[0].0, vec!["a".to_string(), "1".to_string()]);
339        assert_eq!(result_items[0].1, val0.qb64());
340        assert_eq!(result_items[1].0, vec!["a".to_string(), "2".to_string()]);
341        assert_eq!(result_items[1].1, val1.qb64());
342
343        // Test with Diger class
344        let sdb_diger = CesrSuber::<Diger>::new(db_ref.clone(), "pigs.", None, true)?;
345
346        let dig0 = "EAPYGGwTmuupWzwEHHzq7K0gzUhPx5_yZ-Wk1x4ejhcc";
347        let val0 = Diger::from_qb64(dig0)?;
348
349        let keys: &[&[u8]] = &[b"alpha".as_ref(), b"dog".as_ref()];
350
351        assert!(sdb_diger.put(keys, &val0)?);
352
353        let actual = sdb_diger.get(keys)?.unwrap();
354        assert_eq!(actual.qb64(), val0.qb64());
355
356        assert!(sdb_diger.trim(keys, false)?);
357
358        let actual = sdb_diger.get(keys)?;
359        assert!(actual.is_none());
360
361        assert!(sdb_diger.put(keys, &val0)?);
362
363        let actual = sdb_diger.get(keys)?.unwrap();
364        assert_eq!(actual.qb64(), val0.qb64());
365
366        // Attempt to update with a Matter value that has a different code
367        let pre1 = "EHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc";
368        let val1 = BaseMatter::from_qb64(pre1)?;
369
370        // In Rust the following won't compile(!) because we're trying to add a different type
371        // let result = sdb_diger.put(keys, &val1).unwrap();
372        // assert!(!result);
373
374        // Force update with pin operation (trim and put)
375        let trim_result = sdb_diger.trim(keys, false)?;
376        assert!(trim_result);
377
378        let val1_diger = Diger::from_qb64(pre1)?;
379        let put_result = sdb_diger.put(keys, &val1_diger)?;
380        assert!(put_result);
381
382        let actual = sdb_diger.get(keys)?.unwrap();
383        assert_eq!(actual.qb64(), val1_diger.qb64());
384
385        // Test iteritems with another database
386        let sdb_figs = CesrSuber::<Diger>::new(db_ref.clone(), "figs.", None, true)?;
387
388        let keys_a1: &[&[u8]] = &[b"a".as_ref(), b"1".as_ref()];
389        let keys_a2: &[&[u8]] = &[b"a".as_ref(), b"2".as_ref()];
390
391        assert!(sdb_figs.put(keys_a1, &val0)?);
392        assert!(sdb_figs.put(keys_a2, &val1_diger)?);
393
394        let items = sdb_figs.get_item_iter(&empty, false)?;
395        let processed_items = sdb_figs.process_items(items)?;
396
397        let mut result_items = Vec::new();
398        for (keys_vec, val) in processed_items {
399            let keys_tuple: Vec<String> = keys_vec
400                .into_iter()
401                .map(|k| String::from_utf8(k).unwrap())
402                .collect();
403
404            result_items.push((keys_tuple, val.qb64()));
405        }
406
407        assert_eq!(result_items.len(), 2);
408        assert_eq!(result_items[0].0, vec!["a".to_string(), "1".to_string()]);
409        assert_eq!(result_items[0].1, val0.qb64());
410        assert_eq!(result_items[1].0, vec!["a".to_string(), "2".to_string()]);
411        assert_eq!(result_items[1].1, val1_diger.qb64());
412
413        // Add more data
414        let keys_b1: &[&[u8]] = &[b"b".as_ref(), b"1".as_ref()];
415        let keys_b2: &[&[u8]] = &[b"b".as_ref(), b"2".as_ref()];
416        let keys_bc1: &[&[u8]] = &[b"bc".as_ref(), b"1".as_ref()];
417
418        assert!(sdb_figs.put(keys_b1, &val0)?);
419        assert!(sdb_figs.put(keys_b2, &val1_diger)?);
420        assert!(sdb_figs.put(keys_bc1, &val0)?);
421
422        // Test with topkey (prefix filtering)
423        let top_keys: &[&[u8]] = &[b"b".as_ref(), b"".as_ref()];
424        let items = sdb_figs.get_item_iter(top_keys, true)?;
425        let processed_items = sdb_figs.process_items(items)?;
426
427        let mut result_items = Vec::new();
428        for (keys_vec, val) in processed_items {
429            let keys_tuple: Vec<String> = keys_vec
430                .into_iter()
431                .map(|k| String::from_utf8(k).unwrap())
432                .collect();
433
434            result_items.push((keys_tuple, val.qb64()));
435        }
436
437        assert_eq!(result_items.len(), 2);
438        assert_eq!(result_items[0].0, vec!["b".to_string(), "1".to_string()]);
439        assert_eq!(result_items[0].1, val0.qb64());
440        assert_eq!(result_items[1].0, vec!["b".to_string(), "2".to_string()]);
441        assert_eq!(result_items[1].1, val1_diger.qb64());
442
443        // Test Siger class
444        let sdb_siger = CesrSuber::<Siger>::new(db_ref.clone(), "pigs.", None, true).unwrap();
445
446        let sig0 = "AACdI8OSQkMJ9r-xigjEByEjIua7LHH3AOJ22PQKqljMhuhcgh9nGRcKnsz5KvKd7K_H9-1298F4Id1DxvIoEmCQ";
447        let val0 = Siger::from_qb64(sig0, None)?;
448
449        let keys: &[&[u8]] = &[b"zeta".as_ref(), b"cat".as_ref()];
450
451        assert!(sdb_siger.put(keys, &val0)?);
452
453        let actual = sdb_siger.get(keys)?.unwrap();
454        assert_eq!(actual.qb64(), val0.qb64());
455
456        Ok(())
457    }
458}