medi-rs 2.3.0

A lightweight async mediator library for Rust with dependency injection and derive macros
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

#![cfg(feature = "tokio")]

use core::convert::Infallible;
use std::sync::Mutex;

use medi_rs::{DecoratorNext, MediCommand, medi_handler, medi_module, mediator};

static CALLS: Mutex<Vec<&str>> = Mutex::new(Vec::new());

async fn global_logging<Command, Next>(command: Command, next: Next) -> Result<Next::Response, Next::Error>
where
    Command: Send,
    Next: DecoratorNext<Command>,
{
    CALLS.lock().unwrap().push("global:before");
    let result = next.call(command).await;
    CALLS.lock().unwrap().push("global:after");
    result
}

async fn logging(
    command: DecoratedCommand,
    next: impl DecoratorNext<DecoratedCommand, Response = &'static str, Error = Infallible>,
) -> Result<&'static str, Infallible> {
    CALLS.lock().unwrap().push("logging:before");
    let result = next.call(command).await;
    CALLS.lock().unwrap().push("logging:after");
    result
}

async fn validation(
    command: DecoratedCommand,
    next: impl DecoratorNext<DecoratedCommand, Response = &'static str, Error = Infallible>,
) -> Result<&'static str, Infallible> {
    CALLS.lock().unwrap().push("validation:before");
    let result = next.call(command).await;
    CALLS.lock().unwrap().push("validation:after");
    result
}

#[derive(MediCommand)]
#[medi_command(return_type = &'static str)]
struct DecoratedCommand;

#[medi_handler(decorators = [logging, validation])]
async fn handle_decorated_command(_: DecoratedCommand) -> Result<&'static str, Infallible> {
    CALLS.lock().unwrap().push("handler");
    Ok("handled")
}

medi_module! {
    manifest decorated_manifest;
    commands { DecoratedCommand => handle_decorated_command; }
}

mediator! {
    struct DecoratedMediator {
        event_queue_capacity: 1;
        event_workers: 1;
        modules: [decorated_manifest];
        decorators: [global_logging];
    }
}

#[tokio::test]
async fn function_decorators_receive_and_forward_the_command() {
    CALLS.lock().unwrap().clear();

    assert_eq!(
        DecoratedMediator::new().send(DecoratedCommand).await.unwrap(),
        "handled"
    );
    assert_eq!(
        *CALLS.lock().unwrap(),
        [
            "global:before",
            "logging:before",
            "validation:before",
            "handler",
            "validation:after",
            "logging:after",
            "global:after"
        ]
    );
}