AggregateManager handle command returns updated state (#196)

examples/readme/main.rs

@@ -30,7 +30,7 @@ async fn main() {
         .expect("Failed to create PgStore");
 
     let manager: AggregateManager<_> = AggregateManager::new(store);
-    let _: Result<Result<(), BookError>, PgStoreError> = manager
+    let _: Result<Result<BookState, BookError>, PgStoreError> = manager
         .handle_command(Default::default(), BookCommand::Buy { num_of_copies: 1 })
         .await;
 }

src/manager.rs

@@ -34,18 +34,22 @@ where
     ///
     /// The store transactionally persists the events - recording them in the aggregate instance's history.
     ///
+    /// On success, the updated aggregate state is returned.
+    ///
     /// Returns two layers of errors:
     /// - `Err(_)` if the aggregate handled the command but the outcome failed to be recorded;
     /// - `Ok(Err(_))` if the aggregate denied the command.
     pub async fn handle_command(
         &self,
         mut aggregate_state: AggregateState<<E::Aggregate as Aggregate>::State>,
         command: <E::Aggregate as Aggregate>::Command,
-    ) -> Result<Result<(), <E::Aggregate as Aggregate>::Error>, E::Error> {
+    ) -> Result<Result<<E::Aggregate as Aggregate>::State, <E::Aggregate as Aggregate>::Error>, E::Error> {
         match <E::Aggregate as Aggregate>::handle_command(aggregate_state.inner(), command) {
             Err(domain_error) => Ok(Err(domain_error)),
             Ok(events) => match self.event_store.persist(&mut aggregate_state, events).await {
-                Ok(_) => Ok(Ok(())),
+                Ok(store_events) => Ok(Ok(aggregate_state
+                    .apply_store_events(store_events, <E::Aggregate as Aggregate>::apply_event)
+                    .into_inner())),
                 Err(operational_error) => Err(operational_error),
             },
         }