LockedLoad

src/manager.rs

@@ -1,3 +1,7 @@
+mod locked_load;
+
+pub use locked_load::LockedLoad;
+
 use uuid::Uuid;
 
 use crate::store::{EventStore, StoreEvent};
@@ -71,19 +75,22 @@ 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,
-    ) -> Result<Option<AggregateState<<E::Aggregate as Aggregate>::State>>, E::Error> {
+    ) -> Result<LockedLoad<<E::Aggregate as Aggregate>::State>, E::Error> {
         let id = aggregate_id.into();
         let guard = self.event_store.lock(id).await?;
+        let aggregate_state = self.load(id).await?;
 
-        Ok(self.load(id).await?.map(|mut state| {
-            state.set_lock(guard);
-            state
-        }))
+        Ok(match aggregate_state {
+            Some(mut aggregate_state) => {
+                aggregate_state.set_lock(guard);
+                LockedLoad::some(aggregate_state)
+            }
+            None => LockedLoad::none(id, guard),
+        })
     }
 
     /// `delete` should either complete the aggregate instance, along with all its associated events

src/manager/locked_load.rs

@@ -0,0 +1,67 @@
+use uuid::Uuid;
+
+use crate::store::EventStoreLockGuard;
+use crate::AggregateState;
+
+/// The outcome of [`crate::manager::AggregateManager::lock_and_load`], akin to `Option<AggregateState<_>>`.
+///
+/// it contains the loaded [`AggregateState`] if found,
+/// and ensures that the lock is preserved in all cases.
+///
+/// Releases the lock on drop, unless it gets transferred through its API.
+pub struct LockedLoad<T>(LockedLoadInner<T>);
+
+impl<T> LockedLoad<T> {
+    /// Constructs a new instance from an AggregateState.
+    /// It should contain its own lock.
+    pub fn some(aggregate_state: AggregateState<T>) -> Self {
+        Self(LockedLoadInner::Some(aggregate_state))
+    }
+
+    /// Constructs a new instance to hold the lock for an empty state.
+    pub fn none(id: Uuid, lock: EventStoreLockGuard) -> Self {
+        Self(LockedLoadInner::None { id, lock })
+    }
+
+    /// Checks if the AggregateState was found.
+    pub fn is_some(&self) -> bool {
+        matches!(self, Self(LockedLoadInner::Some(_)))
+    }
+
+    /// Extracts the contained AggregateState, or panics otherwise.
+    pub fn unwrap(self) -> AggregateState<T> {
+        let Self(inner) = self;
+        match inner {
+            LockedLoadInner::None { .. } => None,
+            LockedLoadInner::Some(aggregate_state) => Some(aggregate_state),
+        }
+        .unwrap()
+    }
+}
+
+impl<T> LockedLoad<T>
+where
+    T: Default,
+{
+    /// Extracts the contained AggregateState, otherwise returns a new one
+    /// with the default internal state together with the lock.
+    pub fn unwrap_or_default(self) -> AggregateState<T> {
+        let Self(inner) = self;
+        match inner {
+            LockedLoadInner::None { id, lock } => {
+                let mut aggregate_state = AggregateState::with_id(id);
+                aggregate_state.set_lock(lock);
+                aggregate_state
+            }
+            LockedLoadInner::Some(aggregate_state) => aggregate_state,
+        }
+    }
+}
+
+/// Encapsulates the logic to avoid exposing the internal behaviour.
+/// It's essentially `Option<AggregateState<T>>`, but it also needs to
+/// retain the lock information.
+enum LockedLoadInner<T> {
+    None { id: Uuid, lock: EventStoreLockGuard },
+    Some(AggregateState<T>),
+}