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
8pub 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 Ok(val.clone().into())
29 }
30
31 fn deserialize<T: TryFrom<Vec<u8>>>(bytes: &[u8]) -> Result<T, SuberError> {
32 Err(SuberError::DeserializationError(
34 "Direct deserialization not implemented".to_string(),
35 ))
36 }
37}
38
39pub struct SerderSuberBase<S: Serder + Rawifiable + 'static> {
41 db: Arc<LMDBer>, sdb: BytesDatabase, sep: u8, verify: bool, _serder_type: PhantomData<S>, }
47
48impl<S: Serder + Rawifiable + 'static> SerderSuberBase<S> {
49 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 pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
69 let mut result = Vec::new();
71
72 if keys.len() == 1 {
74 let key = keys[0].as_ref();
75 if !topive {
76 return key.to_vec();
77 }
78 result.extend_from_slice(key);
80 result.push(self.sep);
81 return result;
82 }
83
84 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 if topive && (!result.is_empty() && result[result.len() - 1] != self.sep) {
94 result.push(self.sep);
95 }
96
97 result
98 }
99
100 pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
102 key.split(|&b| b == self.sep)
104 .map(|part| part.to_vec())
105 .collect()
106 }
107
108 fn ser(&self, val: &S) -> Vec<u8> {
110 val.raw().to_vec()
112 }
113
114 fn des(&self, val: &[u8]) -> Result<S, SuberError> {
116 S::from_raw(val, None).map_err(|e| {
118 SuberError::DeserializationError(format!("Failed to deserialize Serder: {}", e))
119 })
120 }
121
122 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 let serder = self.des(&val)?;
129
130 Ok(Some(serder))
131 } else {
132 Ok(None)
133 }
134 }
135
136 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 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 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 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 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 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) })?;
188
189 Ok(result)
190 }
191
192 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 self.get_full_item_iter(keys, topive)
200 }
201
202 pub fn cnt_all(&self) -> Result<usize, SuberError> {
204 Ok(self.db.cnt(&self.sdb)?)
205 }
206}
207
208pub struct SerderSuber<S: Serder + Rawifiable + 'static> {
211 base: SerderSuberBase<S>,
212}
213
214impl<S: Serder + Rawifiable + 'static> SerderSuber<S> {
215 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 pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], val: &S) -> Result<bool, SuberError> {
229 self.base.put(keys, val)
230 }
231
232 pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], val: &S) -> Result<bool, SuberError> {
235 self.base.pin(keys, val)
236 }
237
238 pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<S>, SuberError> {
241 self.base.get(keys)
242 }
243
244 pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
247 self.base.rem(keys)
248 }
249
250 pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
253 self.base.trim(keys, topive)
254 }
255
256 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 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 pub fn cnt_all(&self) -> Result<usize, SuberError> {
276 self.base.cnt_all()
277 }
278}
279
280pub 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 let lmdber = LMDBer::builder()
295 .name("test_serder_db")
296 .temp(true)
297 .build()?;
298 let db = Arc::new(lmdber);
299
300 let suber: SerderSuber<SerderKERI> = SerderSuber::new(db, "serders.", None, false)?;
302
303 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 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 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 let result = suber.put(keys, &serder2)?;
325 assert!(!result); let retrieved = suber.get(keys)?.unwrap();
329 assert_eq!(retrieved.raw(), serder.raw());
330
331 let result = suber.pin(keys, &serder2)?;
333 assert!(result);
334
335 let retrieved = suber.get(keys)?.unwrap();
337 assert_eq!(retrieved.raw(), serder2.raw());
338
339 let result = suber.rem(keys)?;
341 assert!(result);
342
343 let retrieved = suber.get(keys)?;
344 assert!(retrieved.is_none());
345
346 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 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 let count = suber.cnt_all()?;
365 assert_eq!(count, 2);
366
367 suber.trim(iter_keys, true)?;
369 let count = suber.cnt_all()?;
370 assert_eq!(count, 0);
371
372 Ok(())
373 }
374}