chekov 0.1.1

CQRS/ES Framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

use crate::event::Event;
use crate::Aggregate;
use crate::CommandExecutorError;
use crate::{event::*, message::Dispatch, Application};
use actix::SystemService;

mod consistency;
mod metadata;

pub use consistency::Consistency;
pub use metadata::CommandMetadatas;

/// Define a Command which can be dispatch
pub trait Command: std::fmt::Debug + Send + 'static {
    /// The Event that can be generated for this command
    type Event: Event + event_store::Event;

    /// The Executor that will execute the command and produce the events
    ///
    /// Note that for now, onlu Aggregate can be used as Executor.
    type Executor: CommandExecutor<Self> + EventApplier<Self::Event>;

    /// The registry where the command will be dispatched
    type ExecutorRegistry: SystemService;

    /// Returns the identifier for this command.
    ///
    /// The identifier is used to choose the right executor.
    fn identifier(&self) -> String;
}

#[doc(hidden)]
#[async_trait::async_trait]
pub trait Dispatchable<C, A>
where
    C: Command,
    A: Application,
{
    async fn dispatch(&self, cmd: C) -> Result<Vec<C::Event>, CommandExecutorError>
    where
        <C as Command>::ExecutorRegistry: actix::Handler<Dispatch<C, A>>;
}

/// Receives a command and an immutable Executor and optionally returns events
pub trait CommandHandler<C: Command + ?Sized> {
    fn execute(command: C, executor: &C::Executor) -> Result<Vec<C::Event>, CommandExecutorError>;
}

/// Receives a command and an immutable State and optionally returns events
pub trait CommandExecutor<T: Command + ?Sized>: Aggregate {
    fn execute(cmd: T, state: &Self) -> Result<Vec<T::Event>, CommandExecutorError>;
}