jaeb 0.3.7

simple snapshot-driven event 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

//! Middleware traits for cross-cutting event interception.
//!
//! Middlewares run **before** listener dispatch and can inspect (or reject) any
//! event flowing through the bus. They receive the event as `&dyn Any`, so a
//! single middleware can handle multiple event types via downcasting.
//!
//! # Ordering
//!
//! Middlewares execute in FIFO registration order. The first middleware to
//! return [`MiddlewareDecision::Reject`] short-circuits the pipeline — no
//! further middlewares run and no listeners are invoked.

use std::any::Any;
use std::future::Future;

use crate::types::Event;

/// Decision returned by a middleware after inspecting an event.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MiddlewareDecision {
    /// Allow the event to proceed to listeners (and the next middleware).
    Continue,
    /// Reject the event with a reason string. No listeners will fire.
    Reject(String),
}

/// Async middleware trait.
///
/// Implement this for middleware that needs to perform async work (e.g., check
/// an external service, acquire a lock, etc.).
pub trait Middleware: Send + Sync + 'static {
    /// Inspect the event and decide whether to continue or reject.
    ///
    /// `event_name` is the `std::any::type_name` of the concrete event type.
    fn process<'a>(&'a self, event_name: &'static str, event: &'a (dyn Any + Send + Sync)) -> impl Future<Output = MiddlewareDecision> + Send + 'a;
}

/// Sync middleware trait.
///
/// Implement this for lightweight, non-blocking middleware that can make a
/// decision synchronously.
pub trait SyncMiddleware: Send + Sync + 'static {
    /// Inspect the event and decide whether to continue or reject.
    fn process(&self, event_name: &'static str, event: &(dyn Any + Send + Sync)) -> MiddlewareDecision;
}

/// Async middleware scoped to a specific event type `E`.
///
/// This middleware runs only when publishing events of type `E`.
pub trait TypedMiddleware<E: Event>: Send + Sync + 'static {
    /// Inspect a typed event and decide whether to continue or reject.
    fn process<'a>(&'a self, event_name: &'static str, event: &'a E) -> impl Future<Output = MiddlewareDecision> + Send + 'a;
}

/// Sync middleware scoped to a specific event type `E`.
///
/// This middleware runs only when publishing events of type `E`.
pub trait TypedSyncMiddleware<E: Event>: Send + Sync + 'static {
    /// Inspect a typed event and decide whether to continue or reject.
    fn process(&self, event_name: &'static str, event: &E) -> MiddlewareDecision;
}