Trait esrs::aggregate::AggregateManager [−][src]
pub trait AggregateManager: Identifier {
type State: Default + Clone + Debug + Send + Sync;
type Command: Send + Sync;
type Event: Serialize + DeserializeOwned + Send + Sync;
type Error: Send + Sync;
fn event_store(
&self
) -> &(dyn EventStore<Self::Event, Self::Error> + Send + Sync);
fn apply_event(
id: &Uuid,
state: Self::State,
event: &StoreEvent<Self::Event>
) -> Self::State;
fn validate_command(
aggregate_state: &AggregateState<Self::State>,
cmd: &Self::Command
) -> Result<(), Self::Error>;
fn do_handle_command<'life0, 'async_trait>(
&'life0 self,
aggregate_state: AggregateState<Self::State>,
cmd: Self::Command
) -> Pin<Box<dyn Future<Output = Result<AggregateState<Self::State>, Self::Error>> + Send + 'async_trait>>
where
'life0: 'async_trait,
Self: 'async_trait;
fn handle_command<'life0, 'async_trait>(
&'life0 self,
aggregate_state: AggregateState<Self::State>,
cmd: Self::Command
) -> Pin<Box<dyn Future<Output = Result<AggregateState<Self::State>, Self::Error>> + Send + 'async_trait>>
where
'life0: 'async_trait,
Self: Sync + 'async_trait,
{ ... }
fn apply_events(
aggregate_state: AggregateState<Self::State>,
events: Vec<StoreEvent<Self::Event>>
) -> AggregateState<Self::State> { ... }
fn load<'life0, 'async_trait>(
&'life0 self,
aggregate_id: Uuid
) -> Pin<Box<dyn Future<Output = Option<AggregateState<Self::State>>> + Send + 'async_trait>>
where
'life0: 'async_trait,
Self: Sync + 'async_trait,
{ ... }
fn persist<'life0, 'async_trait>(
&'life0 self,
aggregate_state: AggregateState<Self::State>,
events: Vec<Self::Event>
) -> Pin<Box<dyn Future<Output = Result<AggregateState<Self::State>, Self::Error>> + Send + 'async_trait>>
where
'life0: 'async_trait,
Self: Sync + 'async_trait,
{ ... }
}
Expand description
The AggregateManager is responsible for loading an aggregate from the store, mapping commands to events, and persisting those events in the store. Be careful when implenting this trait, as you will be responsible for threading AggregateState/Commands/Events correctly. For example, a bad implementation could result in an AggregateState that is not replicated on load.
Unless you need to perform side effects as part of your command handling/verification you should implement the
safer Aggregate
trait instead.
Associated Types
Required methods
fn event_store(
&self
) -> &(dyn EventStore<Self::Event, Self::Error> + Send + Sync)
fn event_store(
&self
) -> &(dyn EventStore<Self::Event, Self::Error> + Send + Sync)
Returns the event store, configured for the aggregate
fn apply_event(
id: &Uuid,
state: Self::State,
event: &StoreEvent<Self::Event>
) -> Self::State
fn apply_event(
id: &Uuid,
state: Self::State,
event: &StoreEvent<Self::Event>
) -> Self::State
This function applies the event onto the aggregate and returns a new one, updated with the event data
fn validate_command(
aggregate_state: &AggregateState<Self::State>,
cmd: &Self::Command
) -> Result<(), Self::Error>
fn validate_command(
aggregate_state: &AggregateState<Self::State>,
cmd: &Self::Command
) -> Result<(), Self::Error>
Validation should reject any command is inconsitent with the current aggregate state, or would result in one or more events that could not be applied onto the aggregate state.
fn do_handle_command<'life0, 'async_trait>(
&'life0 self,
aggregate_state: AggregateState<Self::State>,
cmd: Self::Command
) -> Pin<Box<dyn Future<Output = Result<AggregateState<Self::State>, Self::Error>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Provided methods
fn handle_command<'life0, 'async_trait>(
&'life0 self,
aggregate_state: AggregateState<Self::State>,
cmd: Self::Command
) -> Pin<Box<dyn Future<Output = Result<AggregateState<Self::State>, Self::Error>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: Sync + 'async_trait,
fn apply_events(
aggregate_state: AggregateState<Self::State>,
events: Vec<StoreEvent<Self::Event>>
) -> AggregateState<Self::State>
fn apply_events(
aggregate_state: AggregateState<Self::State>,
events: Vec<StoreEvent<Self::Event>>
) -> AggregateState<Self::State>
Responsible for applying events in order onto the aggregate state, and incrementing the sequence number. You should avoid implementing this method, and be very careful if you decide to do so.
events
will be passed in order of ascending sequence number.
Loads an aggregate instance from the event store, by applying previously persisted events onto the aggregate state by order of their sequence number
Persits an event into the event store - recording it in the aggregate instance’s history.