rorm-db 0.12.0

The inner database abstraction layer from rorm.
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

//! Wrapper to implement [`TransactionHook`] for a closure

use std::future::Future;

use crate::transaction::{Transaction, TransactionError, TransactionHook};

/// Wrapper to implement [`TransactionHook`] for a closure
pub struct ClosureHook<C, L> {
    closure: Option<C>,
    _lifecycle: L,
}
impl<C, L> ClosureHook<C, L> {
    /// Wraps a `closure` to run during `lifecycle` of a [`TransactionHook`]
    ///
    /// `lifecycle` is one of:
    /// - [`PreCommit`]
    /// - [`PostCommit`]
    /// - [`OnRollback`]
    pub fn new(closure: C, lifecycle: L) -> Self
    where
        Self: TransactionHook,
    {
        Self {
            closure: Some(closure),
            _lifecycle: lifecycle,
        }
    }
}

/// Marker for [`TransactionHook::pre_commit`]
///
/// It is used by [`ClosureHook`] to determine when to run the closure.
pub struct PreCommit;

/// Marker for [`TransactionHook::post_commit`]
///
/// It is used by [`ClosureHook`] to determine when to run the closure.
pub struct PostCommit;

/// Marker for [`TransactionHook::on_rollback`]
///
/// It is used by [`ClosureHook`] to determine when to run the closure.
pub struct OnRollback;

impl<T, F> TransactionHook for ClosureHook<T, PreCommit>
where
    T: FnOnce() -> F + Send + 'static,
    F: Future<Output = Result<(), TransactionError>> + Send,
{
    async fn pre_commit(&mut self, _tx: &mut Transaction) -> Result<(), TransactionError> {
        if let Some(closure) = self.closure.take() {
            closure().await?;
        }
        Ok(())
    }
}
impl<T> TransactionHook for ClosureHook<T, PostCommit>
where
    T: FnOnce() + Send + 'static,
{
    fn post_commit(&mut self) {
        if let Some(closure) = self.closure.take() {
            closure()
        }
    }
}
impl<T> TransactionHook for ClosureHook<T, OnRollback>
where
    T: FnOnce() + Send + 'static,
{
    fn on_rollback(&mut self) {
        if let Some(closure) = self.closure.take() {
            closure()
        }
    }
}