Struct Store 

pub struct Store<Id, M> { /* private fields */ }

In-memory event store that keeps streams in a hash map.

Uses a global sequence counter (Position = u64) to maintain chronological ordering across streams, enabling cross-aggregate projections that need to interleave events by time rather than by stream name.

Generic over:

• Id: Aggregate identifier type (must be hashable/equatable for map keys)
• M: Metadata type (use () when not needed)

This store uses serde_json::Value as the internal data representation.

Implementations

impl<Id, M> Store<Id, M>

pub fn new() -> Self

Trait Implementations

impl<Id: Clone, M: Clone> Clone for Store<Id, M>

fn clone(&self) -> Store<Id, M>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Id, M> Default for Store<Id, M>

fn default() -> Self

Returns the “default value” for a type.

impl<Id, M> EventStore for Store<Id, M>

where Id: Clone + Eq + Hash + Send + Sync + 'static, M: Clone + Send + Sync + 'static,

type Data = Value

Serialised event payload type.

type Error = InMemoryError

Store-specific error type.

type Id = Id

Aggregate identifier type.

type Metadata = M

Metadata type for infrastructure concerns.

type Position = u64

Position type used for ordering events and version checking.

fn decode_event<E>( &self, stored: &StoredEvent<Self::Id, Self::Position, Self::Data, Self::Metadata>, ) -> Result<E, Self::Error>

where E: DomainEvent + DeserializeOwned,

Decode a stored event into a concrete event type.

fn stream_version<'a>( &'a self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, ) -> impl Future<Output = Result<Option<u64>, Self::Error>> + Send + 'a

Get the current version (latest position) for an aggregate stream.

fn commit_events<'a, E>( &'a self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, events: NonEmpty<E>, metadata: &'a Self::Metadata, ) -> impl Future<Output = Result<Committed<u64>, CommitError<Self::Error>>> + Send + 'a

where E: EventKind + Serialize + Send + Sync + 'a, Self::Metadata: Clone,

Commit events to an aggregate stream without version checking.

fn commit_events_optimistic<'a, E>( &'a self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, expected_version: Option<Self::Position>, events: NonEmpty<E>, metadata: &'a Self::Metadata, ) -> impl Future<Output = Result<Committed<u64>, OptimisticCommitError<u64, Self::Error>>> + Send + 'a

where E: EventKind + Serialize + Send + Sync + 'a, Self::Metadata: Clone,

Commit events to an aggregate stream with optimistic concurrency control.

fn load_events<'a>( &'a self, filters: &'a [EventFilter<Self::Id, Self::Position>], ) -> impl Future<Output = LoadEventsResult<Self::Id, Self::Position, Self::Data, Self::Metadata, Self::Error>> + Send + 'a

Load events matching the specified filters.

impl<Id, M> SubscribableStore for Store<Id, M>

where Id: Clone + Eq + Hash + Send + Sync + 'static, M: Clone + Send + Sync + 'static,

fn subscribe( &self, filters: &[EventFilter<Self::Id, Self::Position>], from_position: Option<Self::Position>, ) -> Pin<Box<dyn Stream<Item = Result<StoredEvent<Self::Id, Self::Position, Self::Data, Self::Metadata>, Self::Error>> + Send + '_>>

where Self::Position: Ord,

Subscribe to events matching the given filters.

impl<Id, M> GloballyOrderedStore for Store<Id, M>

where Id: Clone + Eq + Hash + Send + Sync + 'static, M: Clone + Send + Sync + 'static,