Skip to main content

dkms_wasm/database/in_memory/
sn_database.rs

1use std::{
2    collections::HashMap,
3    sync::{Arc, RwLock},
4};
5
6use said::SelfAddressingIdentifier;
7use keri_core::{database::SequencedEventDatabase, prefix::IdentifierPrefix};
8use cesrox::primitives::CesrPrimitive;
9
10use super::InMemoryDbError;
11
12pub struct InMemorySnDatabase {
13    data: RwLock<HashMap<(String, u64), Vec<SelfAddressingIdentifier>>>,
14}
15
16impl Default for InMemorySnDatabase {
17    fn default() -> Self {
18        Self::new(Arc::new(()), "default").unwrap()
19    }
20}
21
22impl SequencedEventDatabase for InMemorySnDatabase {
23    type DatabaseType = ();
24    type Error = InMemoryDbError;
25    type DigestIter = Box<dyn Iterator<Item = SelfAddressingIdentifier>>;
26
27    fn new(
28        _db: Arc<Self::DatabaseType>,
29        _table_name: &'static str,
30    ) -> Result<Self, Self::Error>
31    where
32        Self: Sized,
33    {
34        Ok(Self {
35            data: RwLock::new(HashMap::new()),
36        })
37    }
38
39    fn insert(
40        &self,
41        id: &IdentifierPrefix,
42        sn: u64,
43        digest: &SelfAddressingIdentifier,
44    ) -> Result<(), Self::Error> {
45        let mut data = self.data.write().unwrap();
46        let key = (id.to_str(), sn);
47        data.entry(key)
48            .or_default()
49            .push(digest.clone());
50        Ok(())
51    }
52
53    fn get(
54        &self,
55        id: &IdentifierPrefix,
56        sn: u64,
57    ) -> Result<Self::DigestIter, Self::Error> {
58        let data = self.data.read().unwrap();
59        let key = (id.to_str(), sn);
60
61        if let Some(digests) = data.get(&key) {
62            Ok(Box::new(digests.clone().into_iter()))
63        } else {
64            Ok(Box::new(std::iter::empty()))
65        }
66    }
67
68    fn get_greater_than(
69        &self,
70        id: &IdentifierPrefix,
71        sn: u64,
72    ) -> Result<Self::DigestIter, Self::Error> {
73        let data = self.data.read().unwrap();
74        let id_str = id.to_str();
75
76        let mut result = Vec::new();
77        for ((prefix, seq), digests) in data.iter() {
78            if prefix == &id_str && *seq >= sn {
79                result.extend(digests.clone());
80            }
81        }
82
83        Ok(Box::new(result.into_iter()))
84    }
85
86    fn remove(
87        &self,
88        id: &IdentifierPrefix,
89        sn: u64,
90        digest: &SelfAddressingIdentifier,
91    ) -> Result<(), Self::Error> {
92        let mut data = self.data.write().unwrap();
93        let key = (id.to_str(), sn);
94
95        if let Some(digests) = data.get_mut(&key) {
96            digests.retain(|d| d != digest);
97            if digests.is_empty() {
98                data.remove(&key);
99            }
100            Ok(())
101        } else {
102            Err(InMemoryDbError::NotFound(format!("{:?} at sn {}", id, sn)))
103        }
104    }
105}