busstop 0.2.7

A command and query bus
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

mod command_handler;
mod dispatched_command;

use std::sync::Arc;

pub use command_handler::CommandHandler;
pub use dispatched_command::DispatchedCommand;
use futures::future::BoxFuture;
use simple_middleware::{Manager as MiddlewareManager, Next};

use crate::Busstop;

/// Next middleware to call. Send argument pass to all commands' middlewares
pub type NextCommandMiddleware = Next<DispatchedCommand, DispatchedCommand>;

/// Command middleware type
pub type CommandMiddleware = Box<
    dyn FnMut(DispatchedCommand, NextCommandMiddleware) -> BoxFuture<'static, DispatchedCommand>
        + Send
        + Sync,
>;

/// A type that can be used as a command can implement this trait.
/// Implementing this trait makes it easy to register an handler
/// and to dispatch the command.
#[async_trait::async_trait]
pub trait DispatchableCommand: Send + Sync {
    /// Dispatch the command
    async fn dispatch_command(self) -> bool
    where
        Self: Sized + 'static,
    {
        Busstop::instance().dispatch_command(self).await
    }

    /// Register this handler for this command
    async fn command_handler<H: CommandHandler + Default + 'static>()
    where
        Self: Sized,
    {
        Busstop::instance()
            .register_command::<Self>(H::default())
            .await;
    }

    /// Register a middleware on this dispatchable command
    async fn command_middleware<M: 'static>(middleware: M)
    where
        Self: Sized,
        M: FnMut(
                DispatchedCommand,
                Next<DispatchedCommand, DispatchedCommand>,
            ) -> BoxFuture<'static, DispatchedCommand>
            + Send
            + Sync,
    {
        Busstop::instance()
            .register_command_middleware::<Self, M>(middleware)
            .await;
    }

    /// Register this handler if the command does not have an existing handler
    async fn soft_command_handler<H: CommandHandler + Default + 'static>()
    where
        Self: Sized,
    {
        let bus = Busstop::instance();
        if !bus.command_has_handler::<Self>().await {
            bus.register_command::<Self>(H::default()).await;
        }
    }

    /// Register the instance as the handler for this command
    async fn register_command_handler<H: CommandHandler + 'static>(handler: H)
    where
        Self: Sized,
    {
        Busstop::instance().register_command::<Self>(handler).await;
    }

    /// Register the instance as the soft handler for this command
    async fn register_soft_command_handler<H: CommandHandler + 'static>(handler: H)
    where
        Self: Sized,
    {
        let bus = Busstop::instance();
        if !bus.command_has_handler::<Self>().await {
            bus.register_command::<Self>(handler).await;
        }
    }
}

/// Manages the middlewares for the current command handler
pub struct CommandHandlerManager {
    name: String,
    middleware: MiddlewareManager<DispatchedCommand, DispatchedCommand>,
}

impl CommandHandlerManager {
    /// Create a new instance
    pub async fn new(handler: impl CommandHandler + 'static) -> Self {
        let handler = Arc::new(Box::new(handler));
        Self {
            name: handler.command_handler_name().to_string(),
            middleware: MiddlewareManager::last(move |dispatched, _| {
                let instance = handler.clone();
                Box::pin(async move { instance.clone().handle_command(dispatched).await })
            })
            .await,
        }
    }

    /// The name of the command
    pub fn name(&self) -> &String {
        &self.name
    }

    pub async fn next<M>(&self, middleware: M) -> &Self
    where
        M: FnMut(DispatchedCommand, NextCommandMiddleware) -> BoxFuture<'static, DispatchedCommand>
            + Send
            + 'static,
    {
        self.middleware.next(middleware).await;
        self
    }

    pub async fn handle(&self, dispatched: DispatchedCommand) -> DispatchedCommand {
        let mut result = self.middleware.send(dispatched).await;
        result.handled = true;

        result
    }

    pub async fn handle_command<C: Send + Sync + 'static>(&self, command: C) -> DispatchedCommand {
        self.handle(DispatchedCommand::new(
            Box::new(command),
            std::any::type_name::<C>(),
        ))
        .await
    }
}

#[cfg(test)]
mod test {
    use super::*;

    struct Cmd;
    impl DispatchableCommand for Cmd {}

    #[derive(Default)]
    struct CmdHandler;

    #[async_trait::async_trait]
    impl CommandHandler for CmdHandler {
        async fn handle_command(&self, c: DispatchedCommand) -> DispatchedCommand {
            c
        }
    }

    #[tokio::test]
    async fn test_command_handler_manager() {
        let manager = CommandHandlerManager::new(CmdHandler).await;

        manager
            .next(|c, n| Box::pin(async move { n.call(c).await }))
            .await;
        manager
            .next(|c, n| Box::pin(async move { n.call(c).await }))
            .await;

        assert_eq!(manager.handle_command(Cmd).await.handled(), true)
    }
}