dddk_core 0.6.0

Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
Documentation 
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

use std::sync::Arc;
use crate::dddk::aliases::{Commands, Events, ResponseFromHandler};
use crate::dddk::command::bus_impl::command_dispatcher::CommandDispatcher;
use crate::dddk::command::bus_impl::command_logging_middleware::CommandLoggingMiddleware;
use crate::dddk::command::bus_impl::event_produced_by_command_bus_dispatcher::EventsProducedByCommandBusDispatcher;
use crate::dddk::command::command::Command;
use crate::dddk::command::command_bus::CommandBus;
use crate::dddk::command::command_handler::CommandHandlerInBus;
use crate::dddk::event::bus_impl::event_dispatcher::EventDispatcher;
use crate::dddk::event::event_handler::EventHandlerInBus;
use crate::dddk::event::event_handler_logger::encapsulated_event_handler_with_logger;
use crate::dddk::external_event::bus_impl::command_produced_by_external_event_bus_dispatcher::CommandProducedByExternalEventBusDispatcher;
use crate::dddk::external_event::bus_impl::external_event_dispatcher::ExternalEventDispatcher;
use crate::dddk::external_event::bus_impl::external_event_logging_middleware::ExternalEventLoggingMiddleware;
use crate::dddk::external_event::external_event::ExternalEvent;
use crate::dddk::external_event::external_event_bus::ExternalEventBus;
use crate::dddk::external_event::policy_handler::PolicyHandlerInBus;
use crate::dddk::query::bus_impl::query_dispatcher::QueryDispatcher;
use crate::dddk::query::bus_impl::query_logging_middleware::QueryLoggingMiddleware;
use crate::dddk::query::query::Query;
use crate::dddk::query::query_bus::QueryBus;
use crate::dddk::query::query_handler::QueryHandlerInBus;

pub mod dddk;

pub struct AppBus {
    external_event_bus: CommandProducedByExternalEventBusDispatcher,
    query_bus: QueryLoggingMiddleware,
}

impl AppBus {
    pub fn new(command_handlers: Vec<Box<dyn CommandHandlerInBus>>,
               event_handlers: Vec<Box<dyn EventHandlerInBus>>,
               query_handlers: Vec<Box<dyn QueryHandlerInBus>>,
               policy_handlers: Vec<Box<dyn PolicyHandlerInBus>>) -> AppBus {
        let command_dispatcher = CommandDispatcher::new(command_handlers);
        let command_logging_middleware = CommandLoggingMiddleware::new(Box::new(command_dispatcher));

        let event_handlers_logger = encapsulated_event_handler_with_logger(event_handlers);
        let event_dispatcher = EventDispatcher::new(event_handlers_logger);

        let events_produced_by_command_bus_dispatcher = EventsProducedByCommandBusDispatcher::new(
            Box::new(command_logging_middleware),
            Arc::new(event_dispatcher),
            true,
        );

        let external_event_dispatcher = ExternalEventDispatcher::new(policy_handlers);
        let external_events_bus_logging_middleware = ExternalEventLoggingMiddleware::new(Box::new(external_event_dispatcher));
        let command_produced_by_policy_dispatcher = CommandProducedByExternalEventBusDispatcher::new(
            Box::new(external_events_bus_logging_middleware),
            Box::new(events_produced_by_command_bus_dispatcher)
        );

        let query_dispatcher = QueryDispatcher::new(query_handlers);
        let query_logging_middleware = QueryLoggingMiddleware::new(Box::new(query_dispatcher));
        AppBus {
            external_event_bus: command_produced_by_policy_dispatcher,
            query_bus: query_logging_middleware,
        }
    }

    pub fn dispatch_external_event(&self, external_event: &dyn ExternalEvent) -> Commands {
        self.external_event_bus.dispatch(external_event)
    }

    pub fn dispatch_command(&self, command: &dyn Command) -> Events {
        self.external_event_bus.get_command_bus().dispatch(command, None)
    }

    pub fn dispatch_query(&self, query: &dyn Query) -> ResponseFromHandler {
        self.query_bus.dispatch(query)
    }
}