sourcerer 0.1.1

Event-sourcing framework providing aggregates, repositories, stores, snapshots and upcasters for Rust applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

//! An in-memory snapshot store.
use std::sync::Arc;

use async_trait::async_trait;
use tracing::instrument;

use crate::{
    Aggregate, Result,
    snapshot::{SnapshotStore, StoredSnapshot},
};

use dashmap::DashMap;

/// An in-memory, thread-safe snapshot store.
///
/// This is useful for testing or for applications that do not require a
/// persistent snapshot store.
#[derive(Debug)]
pub struct InMemorySnapshotStore<A: Aggregate> {
    snapshots: Arc<DashMap<String, StoredSnapshot<A::Snapshot>>>,
}

impl<A: Aggregate> Default for InMemorySnapshotStore<A> {
    fn default() -> Self {
        Self {
            snapshots: Arc::new(DashMap::new()),
        }
    }
}

#[async_trait]
impl<A> SnapshotStore<A> for InMemorySnapshotStore<A>
where
    A: Aggregate,
{
    #[instrument(skip(self, snapshot), fields(aggregate_id = ?aggregate_id, version))]
    async fn save(&self, aggregate_id: &A::Id, version: i64, snapshot: A::Snapshot) -> Result<()> {
        let stored_snapshot = StoredSnapshot::new(aggregate_id.to_string(), version, snapshot);
        self.snapshots
            .insert(aggregate_id.to_string(), stored_snapshot);
        Ok(())
    }

    #[instrument(skip(self), fields(aggregate_id = ?aggregate_id))]
    async fn load(&self, aggregate_id: &A::Id) -> Result<Option<StoredSnapshot<A::Snapshot>>> {
        Ok(self
            .snapshots
            .get(&aggregate_id.to_string())
            .map(|r| r.clone()))
    }
}