cqrs-rust-lib 0.4.0

An opinionated implementation of CQRS/Event Sourcing with pluggable storage backends (InMemory, PostgreSQL, MongoDB)
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
52
53
54
55

use crate::{Aggregate, CqrsError, EventEnvelope, Snapshot};
use futures::stream::Stream;
use std::pin::Pin;

pub type EventStream<A> = Pin<Box<dyn Stream<Item = Result<EventEnvelope<A>, CqrsError>> + Send>>;

#[async_trait::async_trait]
pub trait EventStoreStorage<A>
where
    A: Aggregate + 'static,
{
    type Session: Send + Sync;

    async fn start_session(&self) -> Result<Self::Session, CqrsError>;
    async fn close_session(&self, session: Self::Session) -> Result<(), CqrsError>;
    async fn fetch_snapshot(&self, aggregate_id: &str) -> Result<Option<Snapshot<A>>, CqrsError>;

    async fn fetch_events_from_version(
        &self,
        aggregate_id: &str,
        version: usize,
    ) -> Result<EventStream<A>, CqrsError>;

    async fn fetch_all_events(&self, aggregate_id: &str) -> Result<EventStream<A>, CqrsError>;

    async fn fetch_events_paged(
        &self,
        aggregate_id: &str,
        page: usize,
        page_size: usize,
    ) -> Result<(Vec<EventEnvelope<A>>, i64), CqrsError>;

    async fn fetch_latest_event(
        &self,
        aggregate: &A,
        session: &Self::Session,
    ) -> Result<Option<EventEnvelope<A>>, CqrsError>;

    async fn save_events(
        &self,
        events: Vec<EventEnvelope<A>>,
        session: &mut Self::Session,
    ) -> Result<(), CqrsError>;

    async fn save_snapshot(
        &self,
        aggregate: &A,
        version: usize,
        session: &mut Self::Session,
    ) -> Result<(), CqrsError>;

    async fn abort_session(&self, _session: Self::Session) -> Result<(), CqrsError> {
        Ok(())
    }
}