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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//!
//! ## Abstractions
//!
//! Event applied to an aggregate state results in a modified aggregate state:
//!
//! ```text
//! (aggregate, Event) -> aggregate'
//! ```
//!
//! Commands are handled by aggregates resulting in a zero, one or several events:
//!
//! ```text
//! (Aggregate, Command) -> Vec<NewEvent>
//! ```
//!
//! ```text
//! (NewEvent, Store) -> DomainEvent
//! ```
//!
//! Aggregates have a generation property. The generation of an aggregate enumerates the number of
//! modifications through a sequence of applied events.
//!
//! Applying an event to an aggregate advances its state from the current generation n to the next
//! generation n+1:
//!
//! ```text
//! (Aggregate(n), DomainEvent) -> Aggregate(n+1)
//! ```
//!
//! Aggregates can be replayed by applying all stored events to a newly initialized aggregate:
//!
//! ```text
//! (initialized aggregate, &[DomainEvent]) -> current aggregate
//! ```
//!
//!
//! ## Dispatching a Command
//!
//! Given a command we need to find the right aggregate instance to handle it.
//!
//! When dispatcher gets the aggregate instance it calls the handle_command function. The returned
//! list of events (`Vec<NewEvent>`) will be enriched with the address properties of the aggregate to
//! get the related `DomainEvent`s.
//!
#![doc(html_root_url = "https://docs.rs/eventmill/0.4.0")]
//#![deny(missing_docs)]
#![deny(unsafe_code, unstable_features)]
#![warn(
    bare_trait_objects,
    missing_copy_implementations,
    missing_debug_implementations,
    rust_2018_idioms,
    trivial_casts,
    trivial_numeric_casts,
    unused_extern_crates,
    unused_import_braces,
    unused_qualifications
)]

pub mod aggregate;
pub mod command;
pub mod dispatch;
pub mod event;
pub mod inmemory_store;
pub mod metadata;
pub mod query;
pub mod store;
pub mod test_support;

//
// Re-export of types and functions of the public API
//
// We should not re-export:
//
// * specific implementations of the API, e.g. `InMemoryStore`.
// * types or functions with names that would be ambiguous if exported without
//   the module name.
//
pub use crate::aggregate::{
    Aggregate, AggregateIdOf, AggregateState, AggregateType, Generation, InitializeAggregate,
    VersionedAggregate, WithAggregateId,
};
pub use crate::command::{DomainCommand, HandleCommand};
pub use crate::dispatch::{DispatchCommand, DispatchEvent};
pub use crate::event::{DomainEvent, EventType, NewEvent, Sequence};
pub use crate::metadata::Metadata;
pub use crate::query::ReceiveEvent;
pub use crate::store::{EventSink, EventSinkError, EventSource, EventSourceError};

// Export derive macros
#[cfg(feature = "derive")]
pub use eventmill_derive::{AggregateType, EventType};