Struct eventually_postgres::EventStoreBuilder

pub struct EventStoreBuilder(_);

Builder type for EventStore instances.

Implementations

impl EventStoreBuilder

pub fn event_stream<Id, Event>(
    &self,
    name: &'static str
) -> EventStore<Id, Event>

Creates a new EventStore instance using the specified stream name as the Postgres backend table.

pub fn aggregate_stream<T>(
    &self,
    _: &T,
    name: &'static str
) -> EventStore<AggregateId<T>, T::Event> where
    T: Aggregate, 

Creates a new EventStore for an Aggregate type, backed by a Postgres table using the specified stream name.

Usage

// Open a connection with Postgres.
let (client, connection) =
    tokio_postgres::connect("postgres://user@pass:localhost:5432/db", tokio_postgres::NoTls)
        .await
        .map_err(|err| {
            eprintln!("failed to connect to Postgres: {}", err);
            err
        })?;

// The connection, responsible for the actual IO, must be handled by a different
// execution context.
tokio::spawn(async move {
    if let Err(e) = connection.await {
        eprintln!("connection error: {}", e);
    }
});

// Use an EventStoreBuilder to build multiple EventStore instances.
let builder = EventStoreBuilder::from(Arc::new(RwLock::new(client)));

// Aggregates should be versioned to be used with the Postgres Event Store.
use eventually_util::versioned::AggregateExt;
let aggregate = SomeAggregate.versioned();

// Event store for the events.
let store = {
    let store = builder.aggregate_stream(&aggregate, "orders");
    store.create_stream().await?;
    store
};

Trait Implementations

impl From<Arc<RwLock<Client>>> for EventStoreBuilder

fn from(client: Arc<RwLock<Client>>) -> Self

Performs the conversion.