docs and is_some

Cargo.toml

@@ -15,7 +15,7 @@ version = "0.15.0"
 all-features = true
 
 [features]
-default = []
+default = ["postgres", "rebuilder", "kafka", "rabbit", "upcasting"]
 postgres = ["sqlx", "sqlx/postgres", "typed-builder", "tokio"]
 rebuilder = []
 kafka = ["rdkafka", "typed-builder"]

src/handler.rs

@@ -64,6 +64,7 @@ where
 pub trait TransactionalEventHandler<A, Er, Ex>: Sync
 where
     A: Aggregate,
+    Ex: Send,
 {
     /// Handle an event in a transactional fashion and perform a read side crate, update or delete.
     /// If an error is returned the transaction will be aborted and the handling of a command by an

src/manager.rs

@@ -75,8 +75,7 @@ where
     /// Acquires a lock on this aggregate instance, and only then loads it from the event store,
     /// by applying previously persisted events onto the aggregate state by order of their sequence number.
     ///
-    /// The lock is contained in the returned `AggregateState`, and released when this is dropped.
-    /// It can also be extracted with the `take_lock` method for more advanced uses.
+    /// The returned `LockedLoad` contains the outcome of the load and is responsible for correctly managing the lock.
     pub async fn lock_and_load(
         &self,
         aggregate_id: impl Into<Uuid> + Send,

src/manager/locked_load.rs

@@ -23,6 +23,15 @@ impl<T> LockedLoad<T> {
         Self(LockedLoadInner::None { id, lock })
     }
 
+    /// Checks if the AggregateState was found.
+    pub fn is_some(&self) -> bool {
+        let Self(inner) = self;
+        match inner {
+            LockedLoadInner::None { .. } => false,
+            LockedLoadInner::Some(_) => true,
+        }
+    }
+
     /// Extracts the contained AggregateState, or panics otherwise.
     pub fn unwrap(self) -> AggregateState<T> {
         let Self(inner) = self;