Struct eventually_core::repository::Repository

pub struct Repository<T, Store> where
    T: Aggregate + 'static,  { /* fields omitted */ }

Implementation of the Repository pattern for storing, retrieving and deleting Aggregates.

A Repository instruments an EventStore to:

• Insert Events in the EventStore for an Aggregate, using the AggregateRoot,
• Get all the Events in the EventStore and rebuild the State of an Aggregate, into a new AggregateRoot instance,
• Remove all the Events for an Aggregate in the EventStore.

Implementations

impl<T, Store> Repository<T, Store> where
    T: Aggregate,
    Store: EventStore<SourceId = AggregateId<T>, Event = T::Event>, 

pub fn new(aggregate: T, store: Store) -> Self

Creates a new Repository instance, using the Aggregate and EventStore provided.

impl<T, Store> Repository<T, Store> where
    T: Aggregate + Debug + Clone,
    T::Event: Clone,
    T::State: Default + Identifiable,
    T::Error: StdError + 'static,
    AggregateId<T>: Default,
    Store: EventStore<SourceId = AggregateId<T>, Event = T::Event> + Debug,
    Store::Offset: Default,
    Store::Error: StdError + 'static, 

pub async fn get<'_>(
    &'_ self,
    id: AggregateId<T>
) -> Result<Option<AggregateRoot<T>>, T, Store>

Returns the Aggregate from the Repository with the specified id, if any.

In case the Aggregate with the specified id exists, returns a new AggregateRoot instance with its latest State.

Otherwise, None is returned.

pub async fn add<'_>(
    &'_ mut self,
    __arg1: AggregateRoot<T>
) -> Result<AggregateRoot<T>, T, Store>

Adds a new State of the Aggregate into the Repository, through an AggregateRoot instance.

Returns Error::NoEvents if there are no Events to commit in the AggregateRoot.

pub async fn remove<'_>(
    &'_ mut self,
    id: AggregateId<T>
) -> Result<(), T, Store>

Removes the specified Aggregate from the Repository, using the provided AggregateId.