Struct postgres_es::PostgresStore

pub struct PostgresStore<A: Aggregate + Send + Sync> { /* fields omitted */ }

Storage engine using a Postgres database backing. This is an event-sourced EventStore, meaning it uses events as the primary source of truth for the state of the aggregate.

For a snapshot-based EventStore see PostgresSnapshotStore.

Implementations

impl<A: Aggregate> PostgresStore<A>

pub fn new(pool: Pool<Postgres>) -> Self

Creates a new PostgresStore from the provided database connection, an EventStore used for configuring a new cqrs framework.

let store = PostgresStore::<MyAggregate>::new(pool);
let cqrs = CqrsFramework::new(store, vec![]);

Trait Implementations

impl<A: Aggregate> EventStore<A> for PostgresStore<A>

type AC = PostgresStoreAggregateContext<A>

Provides the current state of an aggregate along with surrounding context. This is used by the CqrsFramework when loading an aggregate in order to handle incoming commands.

fn load<'life0, 'life1, 'async_trait>(
    &'life0 self,
    aggregate_id: &'life1 str
) -> Pin<Box<dyn Future<Output = Vec<EventEnvelope<A>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Load all events for a particular aggregate_id

fn load_aggregate<'life0, 'life1, 'async_trait>(
    &'life0 self,
    aggregate_id: &'life1 str
) -> Pin<Box<dyn Future<Output = PostgresStoreAggregateContext<A>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Load aggregate at current state

fn commit<'life0, 'async_trait>(
    &'life0 self,
    events: Vec<A::Event>,
    context: PostgresStoreAggregateContext<A>,
    metadata: HashMap<String, String>
) -> Pin<Box<dyn Future<Output = Result<Vec<EventEnvelope<A>>, AggregateError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Commit new events

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

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