Struct postgres_es::PostgresStoreAggregateContext

pub struct PostgresStoreAggregateContext<A> where
    A: Aggregate,  {
    pub aggregate_id: String,
    pub aggregate: A,
    pub current_sequence: usize,
}

Holds context for a pure event store implementation for MemStore

Fields

aggregate_id: String

The aggregate ID of the aggregate instance that has been loaded.

aggregate: A

The current state of the aggregate instance.

current_sequence: usize

The last committed event sequence number for this aggregate instance.

Trait Implementations

impl<A> AggregateContext<A> for PostgresStoreAggregateContext<A> where
    A: Aggregate, 

pub fn aggregate(&self) -> &A

The aggregate instance with all state loaded.

impl<A, E> EventStore<A, E, PostgresStoreAggregateContext<A>> for PostgresStore<A, E> where
    A: Aggregate,
    E: DomainEvent<A>, 

pub fn load(&self, aggregate_id: &str) -> Vec<EventEnvelope<A, E>>

Load all events for a particular aggregate_id

pub fn load_aggregate(
    &self,
    aggregate_id: &str
) -> PostgresStoreAggregateContext<A>

Load aggregate at current state

pub fn commit(
    &self,
    events: Vec<E>,
    context: PostgresStoreAggregateContext<A>,
    metadata: HashMap<String, String>
) -> Result<Vec<EventEnvelope<A, E>>, AggregateError>

Commit new events

pub fn wrap_events(
    &self,
    aggregate_id: &str,
    current_sequence: usize,
    resultant_events: Vec<E, Global>,
    base_metadata: HashMap<String, String, RandomState>
) -> Vec<EventEnvelope<A, E>, Global>

Method to wrap a set of events with the additional metadata needed for persistence and publishing