event_hex 0.0.2

A library that helps implement hexagonal architecture + Event Sourcing + CQRS following DDD
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

use crate::shared_kernel::errors::EventHexError;
use async_trait::async_trait;
use futures::future::BoxFuture;
use std::any::Any;

/// Alias for erased type.
pub type ErasedResult = Box<dyn Any + Send>;

/// Abstract transaction context.
#[async_trait]
pub trait TransactionContext: Send {
    fn as_any_mut(&mut self) -> &mut dyn Any;
}

pub type TransactionHandler = Box<dyn for<'a> FnOnce(&'a mut dyn TransactionContext) -> BoxFuture<'a, Result<ErasedResult, EventHexError>> + Send>;

/// Port for transaction management.
#[async_trait]
pub trait TransactionManager: Send + Sync {
    // Use TransactionHandler<'a> with the lifetime from the argument
    async fn run_transaction(&self, handler: TransactionHandler) -> Result<ErasedResult, EventHexError>;
}

impl dyn TransactionManager {
    pub async fn run<T, F>(&self, f: F) -> Result<T, EventHexError>
    where
        T: Any + Send + 'static,
        F: FnOnce(&mut dyn TransactionContext) -> BoxFuture<'_, Result<T, EventHexError>> + Send + 'static,
    {
        // Wrap the user-defined handler in ErasedResult
        let handler: TransactionHandler = Box::new(|ctx| {
            Box::pin(async move {
                let res = f(ctx).await?;
                let erased: ErasedResult = Box::new(res);
                Ok(erased)
            })
        });

        let erased_result = self.run_transaction(handler).await?;

        // Attempting to cast the result to the required type T
        erased_result
            .downcast::<T>()
            .map(|boxed_t| *boxed_t)
            .map_err(|_| EventHexError::DownCastError("Downcast failed in transaction".into()))
    }
}