Skip to main content

libkeri/keri/db/subing/
cesrioset.rs

1use crate::cesr::Matter;
2use crate::cesr::Parsable;
3use crate::keri::db::dbing::LMDBer;
4use crate::keri::db::subing::cesr::CesrSuberBase;
5use crate::keri::db::subing::ioset::IoSetSuber;
6use crate::keri::db::subing::SuberError;
7use std::sync::Arc;
8
9pub struct CesrIoSetSuber<M: Matter> {
10    pub base: CesrSuberBase<M>,
11    pub io_set_suber: IoSetSuber<crate::keri::db::subing::cesr::CesrCodec<M>>,
12}
13
14impl<M: Matter + Parsable> CesrIoSetSuber<M> {
15    pub fn new(
16        db: Arc<LMDBer>,
17        subkey: &str,
18        sep: Option<u8>,
19        verify: bool,
20    ) -> Result<Self, SuberError> {
21        let base = CesrSuberBase::new(db.clone(), subkey, sep, verify)?;
22        let io_set_suber = IoSetSuber::new(db, subkey, sep, verify)?;
23
24        Ok(Self { base, io_set_suber })
25    }
26
27    // Wrapper for CesrSuberBase methods
28    pub fn _ser(&self, val: &M) -> Result<Vec<u8>, SuberError> {
29        self.base.ser(val)
30    }
31
32    pub fn _des(&self, val: &[u8]) -> Result<M, SuberError> {
33        self.base.des(val)
34    }
35
36    // Wrapper for IoSetSuber methods
37    pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], vals: &[&M]) -> Result<bool, SuberError> {
38        // Convert CESR Matter objects to serialized form for IoSetSuber
39        let ser_vals: Vec<Vec<u8>> = vals
40            .iter()
41            .map(|val| self._ser(val))
42            .collect::<Result<Vec<Vec<u8>>, SuberError>>()?;
43
44        let ser_vals_refs: Vec<&Vec<u8>> = ser_vals.iter().collect();
45
46        self.io_set_suber.put(keys, &ser_vals_refs)
47    }
48
49    pub fn add<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
50        let ser_val = self._ser(val)?;
51        self.io_set_suber.add(keys, &ser_val)
52    }
53
54    pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], vals: &[&M]) -> Result<bool, SuberError> {
55        // Convert CESR Matter objects to serialized form for IoSetSuber
56        let ser_vals: Vec<Vec<u8>> = vals
57            .iter()
58            .map(|val| self._ser(val))
59            .collect::<Result<Vec<Vec<u8>>, SuberError>>()?;
60
61        let ser_vals_refs: Vec<&Vec<u8>> = ser_vals.iter().collect();
62
63        self.io_set_suber.pin(keys, &ser_vals_refs)
64    }
65
66    pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Vec<M>, SuberError> {
67        let ser_vals = self.io_set_suber.get::<K, Vec<u8>>(keys)?;
68        let matters: Result<Vec<M>, SuberError> =
69            ser_vals.into_iter().map(|val| self._des(&val)).collect();
70        matters
71    }
72
73    pub fn get_iter<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Vec<M>, SuberError> {
74        let values = self.io_set_suber.get::<K, Vec<u8>>(keys)?;
75        values.into_iter().map(|val| self._des(&val)).collect()
76    }
77
78    pub fn get_last<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<M>, SuberError> {
79        if let Some(ser_val) = self.io_set_suber.get_last::<K, Vec<u8>>(keys)? {
80            Ok(Some(self._des(&ser_val)?))
81        } else {
82            Ok(None)
83        }
84    }
85
86    pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K], val: Option<&M>) -> Result<bool, SuberError> {
87        match val {
88            Some(m) => {
89                let ser_val = self._ser(m)?;
90                self.io_set_suber.rem::<K, Vec<u8>>(keys, Some(&ser_val))
91            }
92            None => self.io_set_suber.rem::<K, Vec<u8>>(keys, None),
93        }
94    }
95
96    pub fn cnt<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<usize, SuberError> {
97        self.io_set_suber.cnt(keys)
98    }
99
100    // Wrapper for get_item_iter with proper conversion to Matter objects
101    pub fn get_item_iter<K: AsRef<[u8]>>(
102        &self,
103        keys: &[K],
104        topive: bool,
105    ) -> Result<Vec<(Vec<Vec<u8>>, M)>, SuberError> {
106        let items = self.io_set_suber.get_full_item_iter(keys, topive)?;
107        items
108            .into_iter()
109            .map(|(keys_vec, val)| Ok((keys_vec, self._des(&val)?)))
110            .collect()
111    }
112
113    // Wrappers for SuberBase methods (accessed through io_set_suber.base)
114    pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
115        self.io_set_suber.base.to_key(keys, topive)
116    }
117
118    pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
119        self.io_set_suber.base.to_keys(key)
120    }
121
122    pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
123        self.io_set_suber.trim(keys, topive)
124    }
125
126    pub fn get_full_item_iter<K: AsRef<[u8]>>(
127        &self,
128        keys: &[K],
129        topive: bool,
130    ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
131        self.io_set_suber.get_full_item_iter(keys, topive)
132    }
133
134    pub fn cnt_all(&self) -> Result<usize, SuberError> {
135        self.io_set_suber.base.cnt_all()
136    }
137    /// Returns whether this SuberBase is configured to support duplicate values for keys.
138    ///
139    /// # Returns
140    /// * `bool` - True if duplicates are allowed
141    pub fn is_dupsort(&self) -> bool {
142        self.base.base.is_dupsort()
143    }
144}
145
146#[cfg(test)]
147mod tests {
148    use crate::cesr::diger::Diger;
149    use crate::cesr::saider::Saider;
150    use crate::cesr::seqner::Seqner;
151    use crate::cesr::Matter;
152    use crate::keri::core::serdering::{sad::SadValue, Sadder};
153    use crate::keri::db::dbing::{LMDBer, LMDBerBuilder};
154    use crate::keri::db::subing::cesrioset::CesrIoSetSuber;
155    use crate::keri::db::subing::SuberError;
156    use indexmap::IndexMap;
157    use serde_json::{json, Value};
158    use std::sync::Arc;
159
160    #[test]
161    fn test_cesr_ioset_suber() -> Result<(), SuberError> {
162        // Create a tempdir for test isolation (equivalent to with dbing.openLMDB() as db:)
163        let db = LMDBerBuilder::default().name("test").temp(true).build()?;
164
165        assert_eq!(db.name(), "test");
166        assert!(db.opened());
167
168        {
169            // Create a CesrIoSetSuber instance
170            let db_ref = Arc::new(db);
171            let cisuber = CesrIoSetSuber::<Saider>::new(db_ref, "bags.", None, false)?;
172            assert!(!cisuber.is_dupsort());
173
174            // Create sequence numbers
175            let seqner0 = Seqner::from_sn(20);
176            let seq0 = seqner0.qb64();
177            assert_eq!(seq0, "0AAAAAAAAAAAAAAAAAAAAAAU");
178
179            let seqner1 = Seqner::from_sn(10);
180            let seq1 = seqner1.qb64();
181            assert_eq!(seq1, "0AAAAAAAAAAAAAAAAAAAAAAK");
182
183            // Create digest values
184            let diger0 = Diger::from_ser("Hello Me Maties.".as_bytes(), None)?;
185            let dig0 = diger0.qb64();
186            assert_eq!(dig0, "ELq6uSA62FaWKAQf2rclt4D1wRAeVwQ7hBucDG43GrsJ");
187
188            let diger1 = Diger::from_ser("Bye Y'all.".as_bytes(), None)?;
189            let dig1 = diger1.qb64();
190            assert_eq!(dig1, "EK--ZWfMjPZ8R90eDBuwy9umo1CnxpF95H550OGv65ry");
191
192            // Create key tuples
193            let keys0 = [seq0.as_str(), dig0.as_str()];
194            let keys1 = [seq1.as_str(), dig1.as_str()];
195
196            // Create the sad as a Sadder (IndexMap)
197            let mut sad0: Sadder = IndexMap::new();
198            sad0.insert("v".to_string(), SadValue::from_string("KERI10JSON000000_"));
199            sad0.insert("t".to_string(), SadValue::from_string("rpy"));
200            sad0.insert("d".to_string(), SadValue::from_string("")); // vacuous said
201            sad0.insert(
202                "dt".to_string(),
203                SadValue::from_string("2020-08-22T17:50:12.988921+00:00"),
204            );
205            sad0.insert("r".to_string(), SadValue::from_string("/help/me"));
206
207            // Create nested a dict
208            let mut a_dict: IndexMap<String, SadValue> = IndexMap::new();
209            a_dict.insert("name".to_string(), SadValue::from_string("John Jones"));
210            a_dict.insert("role".to_string(), SadValue::from_string("Founder"));
211            sad0.insert("a".to_string(), SadValue::Object(a_dict));
212
213            // Saidify the sadder
214            let (saider0, sadified0) = Saider::saidify(sad0, None, None, None, None)
215                .map_err(|e| SuberError::ValueConversionError(e.to_string()))?;
216            let said0 = saider0.qb64().to_string();
217            assert_eq!(said0, "EKwVGsUU1sUlYRq_g2Z3_3GOIREYtlQ3kPSNjpg8w4j0");
218
219            // Create second sad
220            let mut sad1: Sadder = IndexMap::new();
221            sad1.insert("v".to_string(), SadValue::from_string("KERI10JSON000000_"));
222            sad1.insert("t".to_string(), SadValue::from_string("rpy"));
223            sad1.insert("d".to_string(), SadValue::from_string("")); // vacuous said
224            sad1.insert(
225                "dt".to_string(),
226                SadValue::from_string("2020-08-22T17:50:12.988921+00:00"),
227            );
228            sad1.insert("r".to_string(), SadValue::from_string("/help/you"));
229
230            // Create nested a dict
231            let mut a_dict: IndexMap<String, SadValue> = IndexMap::new();
232            a_dict.insert("name".to_string(), SadValue::from_string("Sue Swan"));
233            a_dict.insert("role".to_string(), SadValue::from_string("Creator"));
234            sad1.insert("a".to_string(), SadValue::Object(a_dict));
235
236            let (saider1, sadified1) = Saider::saidify(sad1, None, None, None, None)
237                .map_err(|e| SuberError::ValueConversionError(e.to_string()))?;
238            let said1 = saider1.qb64().to_string();
239            assert_eq!(said1, "EPl1dMAs2RDsZ12K3yxA0fTHP6dRJzDkStf65VVeFxne");
240
241            // Create third sad
242            let mut sad2: Sadder = IndexMap::new();
243            sad2.insert("v".to_string(), SadValue::from_string("KERI10JSON000000_"));
244            sad2.insert("t".to_string(), SadValue::from_string("rpy"));
245            sad2.insert("d".to_string(), SadValue::from_string("")); // vacuous said
246            sad2.insert(
247                "dt".to_string(),
248                SadValue::from_string("2020-08-22T17:50:30.988921+00:00"),
249            );
250            sad2.insert("r".to_string(), SadValue::from_string("/find/out"));
251
252            // Create nested a dict
253            let mut a_dict: IndexMap<String, SadValue> = IndexMap::new();
254            a_dict.insert("name".to_string(), SadValue::from_string("Zoe Zigler"));
255            a_dict.insert("role".to_string(), SadValue::from_string("Maven"));
256            sad2.insert("a".to_string(), SadValue::Object(a_dict));
257
258            let (saider2, sadified2) = Saider::saidify(sad2, None, None, None, None)
259                .map_err(|e| SuberError::ValueConversionError(e.to_string()))?;
260            let said2 = saider2.qb64().to_string();
261            assert_eq!(said2, "EJxOaEsBSObrcmrsnlfHOdVAowGhUBKoE2Ce3TZ4Mhgu");
262
263            // Test put and get
264            assert!(cisuber.put(&keys0, &[&saider1, &saider0])?);
265            assert_eq!(cisuber.cnt(&keys0)?, 2);
266
267            let actuals = cisuber.get(&keys0)?;
268            assert_eq!(actuals.len(), 2);
269            let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
270            assert_eq!(sers, vec![said1.clone(), said0.clone()]);
271
272            if let Some(actual) = cisuber.get_last(&keys0)? {
273                assert_eq!(actual.qb64(), said0);
274            } else {
275                panic!("Expected a value from get_last but got None");
276            }
277
278            // Test rem
279            assert!(cisuber.rem(&keys0, None)?);
280            let actuals = cisuber.get(&keys0)?;
281            assert!(actuals.is_empty());
282            assert_eq!(cisuber.cnt(&keys0)?, 0);
283
284            // Test put again with different order
285            assert!(cisuber.put(&keys0, &[&saider0, &saider1])?);
286            assert_eq!(cisuber.cnt(&keys0)?, 2);
287
288            let actuals = cisuber.get(&keys0)?;
289            assert_eq!(actuals.len(), 2);
290            let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
291            assert_eq!(sers, vec![said0.clone(), said1.clone()]);
292
293            if let Some(actual) = cisuber.get_last(&keys0)? {
294                assert_eq!(actual.qb64(), said1);
295            } else {
296                panic!("Expected a value from get_last but got None");
297            }
298
299            // Test add
300            assert!(cisuber.add(&keys0, &saider2)?);
301            assert_eq!(cisuber.cnt(&keys0)?, 3);
302
303            let actuals = cisuber.get(&keys0)?;
304            assert_eq!(actuals.len(), 3);
305            let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
306            assert_eq!(sers, vec![said0.clone(), said1.clone(), said2.clone()]);
307
308            if let Some(actual) = cisuber.get_last(&keys0)? {
309                assert_eq!(actual.qb64(), said2);
310            } else {
311                panic!("Expected a value from get_last but got None");
312            }
313
314            // Test pin (replaces all values)
315            assert!(cisuber.pin(&keys0, &[&saider1, &saider2])?);
316            assert_eq!(cisuber.cnt(&keys0)?, 2);
317
318            let actuals = cisuber.get(&keys0)?;
319            assert_eq!(actuals.len(), 2);
320            let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
321            assert_eq!(sers, vec![said1.clone(), said2.clone()]);
322
323            // Test with another key
324            assert!(cisuber.put(&keys1, &[&saider2, &saider1, &saider0])?);
325            assert_eq!(cisuber.cnt(&keys1)?, 3);
326
327            let actuals = cisuber.get(&keys1)?;
328            assert_eq!(actuals.len(), 3);
329            let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
330            assert_eq!(sers, vec![said2.clone(), said1.clone(), said0.clone()]);
331
332            // Test rem with specific value
333            assert!(cisuber.rem(&keys1, Some(&saider1))?);
334            assert_eq!(cisuber.cnt(&keys1)?, 2);
335
336            let actuals = cisuber.get(&keys1)?;
337            assert_eq!(actuals.len(), 2);
338            let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
339            assert_eq!(sers, vec![said2.clone(), said0.clone()]);
340
341            // Test get_iter
342            let actuals = cisuber.get_iter(&keys1)?;
343            let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
344            assert_eq!(sers, vec![said2.clone(), said0.clone()]);
345
346            // Test get_item_iter for all items
347            let items = cisuber.get_item_iter(&[] as &[&str], false)?;
348
349            // Check total number of items matches expected
350            assert_eq!(items.len(), 4);
351
352            // Convert items to human-readable format for assertions
353            let items_converted: Vec<(Vec<String>, String)> = items
354                .into_iter()
355                .map(|(keys, val)| {
356                    (
357                        keys.into_iter()
358                            .map(|key| String::from_utf8(key).unwrap())
359                            .collect(),
360                        val.qb64(),
361                    )
362                })
363                .collect();
364
365            // Test get_full_item_iter for all items
366            let full_items = cisuber.get_full_item_iter(&[] as &[&str], false)?;
367            assert_eq!(full_items.len(), 4);
368
369            // Convert keys to string for easier assertions
370            let full_items_converted: Vec<(Vec<String>, Vec<u8>)> = full_items
371                .into_iter()
372                .map(|(keys, val)| {
373                    (
374                        keys.into_iter()
375                            .map(|key| String::from_utf8(key).unwrap())
376                            .collect(),
377                        val,
378                    )
379                })
380                .collect();
381
382            // Each key should have 3 parts (2 parts + ordinal)
383            for (keys, _) in &full_items_converted {
384                assert_eq!(keys.len(), 3, "Full item key should have 3 parts");
385                // Third part should be the ordinal
386                assert!(
387                    keys[2].starts_with("000000000000000000000000000000"),
388                    "Third part of key should be ordinal: {}",
389                    keys[2]
390                );
391            }
392
393            // Test get_item_iter with specific keys
394            let items = cisuber.get_item_iter(&keys0, false)?;
395            let items_converted: Vec<(Vec<String>, String)> = items
396                .into_iter()
397                .map(|(keys, val)| {
398                    (
399                        keys.into_iter()
400                            .map(|key| String::from_utf8(key).unwrap())
401                            .collect(),
402                        val.qb64(),
403                    )
404                })
405                .collect();
406
407            assert_eq!(items_converted.len(), 2);
408            assert_eq!(items_converted[0].0[0], seq0);
409            assert_eq!(items_converted[0].0[1], dig0);
410
411            // Test with top keys (prefix match)
412            let topkeys = [seq1, String::from("")];
413            let items = cisuber.get_item_iter(&topkeys, false)?;
414            let items_converted: Vec<(Vec<String>, String)> = items
415                .into_iter()
416                .map(|(keys, val)| {
417                    (
418                        keys.into_iter()
419                            .map(|key| String::from_utf8(key).unwrap())
420                            .collect(),
421                        val.qb64(),
422                    )
423                })
424                .collect();
425
426            assert_eq!(items_converted.len(), 2);
427
428            // Test get_full_item_iter with specific prefix
429            let topkeys = [seq0, String::from("")];
430            let items = cisuber.get_full_item_iter(&topkeys, false)?;
431            let items_converted: Vec<(Vec<String>, Vec<u8>)> = items
432                .into_iter()
433                .map(|(keys, val)| {
434                    (
435                        keys.into_iter()
436                            .map(|key| String::from_utf8(key).unwrap())
437                            .collect(),
438                        val,
439                    )
440                })
441                .collect();
442
443            assert_eq!(items_converted.len(), 2);
444        }
445
446        Ok(())
447    }
448}