Struct EventQueryBuilder 

pub struct EventQueryBuilder { /* private fields */ }

Builder for constructing event queries with options.

Example

// Get all events as a stream
let events = db.events(EventSelector::all()).stream();

// Get first 10 events in reverse order, collected to a Vec
let events: Vec<Event> = db
    .events(EventSelector::stream_equals("my-stream"))
    .reverse()
    .limit(10)
    .collect()
    .await;

// Get just the first event
let first = db.events(EventSelector::all()).first().await;

Implementations

impl EventQueryBuilder

pub fn new(database: DatabaseAtRevisionImpl, selector: EventSelector) -> Self

Create a new event query builder.

pub fn direction(self, direction: QueryDirection) -> Self

Set the query direction.

pub fn reverse(self) -> Self

Set the query to reverse order (newest first).

pub fn forward(self) -> Self

Set the query to forward order (oldest first).

pub fn limit(self, limit: u64) -> Self

Set a limit on the number of events returned.

pub async fn collect(self) -> Vec<Event>

Execute the query and collect all events into a Vec.

pub async fn first(self) -> Option<Event>

Execute the query and return just the first event, if any.

pub fn typed<T>(self) -> TypedEventQuery<T>

where T: for<'a> TryFrom<&'a Event> + 'static,

Create a typed event query that filters and converts events.

The type T must implement TryFrom<&Event>. Events that fail to convert are silently skipped.

Example

#[derive(Debug)]
struct AccountCreated { name: String }

impl TryFrom<&Event> for AccountCreated {
    type Error = Box<dyn std::error::Error>;
    fn try_from(event: &Event) -> Result<Self, Self::Error> {
        // Parse the event data...
    }
}

let accounts: Vec<AccountCreated> = db
    .events(EventSelector::type_equals("AccountCreated"))
    .typed::<AccountCreated>()
    .collect()
    .await;