feat(eventually): add query::Handler trait, serde::Convert implements Copy (#296)

- feat(eventually): add derive(Copy) to serde::Convert
- feat(eventually): add query module
- fix(eventually): aggregate::test::Scenario implements Default trait
correctly

Author: ar3s3ru

eventually/src/aggregate/test.rs

@@ -11,7 +11,7 @@ use crate::event;
 
 /// A test scenario that can be used to test an [Aggregate] and [Aggregate Root][Root]
 /// using a [given-then-when canvas](https://www.agilealliance.org/glossary/gwt/) approach.
-#[derive(Default, Clone, Copy)]
+#[derive(Clone, Copy)]
 pub struct Scenario<T>(PhantomData<T>)
 where
     T: Aggregate,
@@ -26,6 +26,12 @@ where
     T::Event: Debug + PartialEq,
     T::Error: Debug,
 {
+    /// Creates a new [Scenario] instance.
+    #[must_use]
+    pub fn new() -> Self {
+        Self(PhantomData)
+    }
+
     /// Specifies the precondition for the test [Scenario].
     ///
     /// In other words, it can be used to specify all the Domain [Event][event::Envelope]s
@@ -57,6 +63,18 @@ where
     }
 }
 
+impl<T> Default for Scenario<T>
+where
+    T: Aggregate,
+    T::Id: Clone,
+    T::Event: Debug + PartialEq,
+    T::Error: Debug,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[doc(hidden)]
 pub struct ScenarioGiven<T>
 where

eventually/src/lib.rs

@@ -9,7 +9,7 @@ pub mod aggregate;
 pub mod command;
 pub mod event;
 pub mod message;
-// pub mod query;
+pub mod query;
 pub mod serde;
 #[cfg(feature = "tracing")]
 pub mod tracing;

eventually/src/query.rs

@@ -0,0 +1,52 @@
+//! Module `query` contains types and helpful abstractions to model Domain Queries
+//! and implement Domain Query Handlers.
+
+use async_trait::async_trait;
+use futures::Future;
+
+use crate::message;
+
+/// A [Message][message::Message] carrying the Domain Query itself as payload
+/// and other relevant information as metadata.
+pub type Envelope<T> = message::Envelope<T>;
+
+/// An Handler describes an implementation that is able to handle specific [Queries][Envelope].
+///
+/// The Handler evaluates the Domain Query and produces a **result**, here described
+/// through the [Output][Handler::Output] associated type.
+#[async_trait]
+pub trait Handler<T>: Send + Sync
+where
+    T: message::Message + Send + Sync,
+{
+    /// The result type the Handler produces when evaluating a Query.
+    type Output: Send + Sync;
+    /// The error type returned by the Handler when Query evaluation fails.
+    type Error: Send + Sync;
+
+    /// Evaluates the [Query][Envelope] provided and returns a result type,
+    /// described by the [Output][Handler::Output] parameter.
+    ///
+    /// # Errors
+    ///
+    /// As the Handler can fail to evaluate the Query, an [Error][Handler::Error]
+    /// can be returned instead.
+    async fn handle(&self, query: Envelope<T>) -> Result<Self::Output, Self::Error>;
+}
+
+#[async_trait]
+impl<T, R, Err, F, Fut> Handler<T> for F
+where
+    T: message::Message + Send + Sync + 'static,
+    R: Send + Sync,
+    Err: Send + Sync,
+    F: Send + Sync + Fn(Envelope<T>) -> Fut,
+    Fut: Send + Sync + Future<Output = Result<R, Err>>,
+{
+    type Output = R;
+    type Error = Err;
+
+    async fn handle(&self, command: Envelope<T>) -> Result<R, Self::Error> {
+        self(command).await
+    }
+}