es-entity 0.12.19

Event Sourcing Entity Framework
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

use crate::{clock::ClockHandle, db};

use super::{AtomicOperation, hooks};

pub trait AtomicOperationWithTime: AtomicOperation {
    fn now(&self) -> chrono::DateTime<chrono::Utc>;
}

/// Wrapper that guarantees time is available, borrowing the underlying operation.
pub struct OpWithTime<'a, Op: AtomicOperation + ?Sized> {
    inner: &'a mut Op,
    now: chrono::DateTime<chrono::Utc>,
}

impl<'a, Op: AtomicOperation + ?Sized> AtomicOperationWithTime for OpWithTime<'a, Op> {
    fn now(&self) -> chrono::DateTime<chrono::Utc> {
        self.now
    }
}

impl<'a, Op: AtomicOperation + ?Sized> OpWithTime<'a, Op> {
    /// Wraps an operation, using existing time if present, otherwise fetching from DB.
    ///
    /// Priority order:
    /// 1. Cached time from operation
    /// 2. Manual clock time if the operation's clock is manual
    /// 3. Database time via `SELECT NOW()`
    pub async fn cached_or_db_time(op: &'a mut Op) -> Result<Self, sqlx::Error> {
        let now = if let Some(time) = op.maybe_now() {
            time
        } else if let Some(manual_time) = op.clock().manual_now() {
            manual_time
        } else {
            db::database_now(op.connection()).await?
        };
        Ok(Self { inner: op, now })
    }

    /// Wraps with a specific time (uses existing if present).
    pub fn cached_or_time(op: &'a mut Op, time: chrono::DateTime<chrono::Utc>) -> Self {
        let now = op.maybe_now().unwrap_or(time);
        Self { inner: op, now }
    }

    /// Wraps using system time (uses existing if present).
    ///
    /// Uses cached time if present, otherwise uses the operation's clock.
    pub fn cached_or_clock_time(op: &'a mut Op) -> Self {
        let now = op.maybe_now().unwrap_or_else(|| op.clock().now());
        Self { inner: op, now }
    }

    pub fn now(&self) -> chrono::DateTime<chrono::Utc> {
        self.now
    }
}

impl<'a, Op: AtomicOperation + ?Sized> AtomicOperation for OpWithTime<'a, Op> {
    fn maybe_now(&self) -> Option<chrono::DateTime<chrono::Utc>> {
        Some(self.now)
    }

    fn clock(&self) -> &ClockHandle {
        self.inner.clock()
    }

    fn connection(&mut self) -> &mut db::Connection {
        self.inner.connection()
    }

    fn add_commit_hook_dyn(
        &mut self,
        type_id: std::any::TypeId,
        hook: Box<dyn hooks::DynHook>,
    ) -> Result<(), Box<dyn hooks::DynHook>> {
        self.inner.add_commit_hook_dyn(type_id, hook)
    }

    fn commit_hook_dyn(&self, type_id: std::any::TypeId) -> Option<&dyn hooks::DynHook> {
        self.inner.commit_hook_dyn(type_id)
    }

    fn supports_hooks(&self) -> bool {
        self.inner.supports_hooks()
    }

    fn savepoint_parts(&mut self) -> (&mut db::Connection, super::savepoint::HookSlot<'_>) {
        self.inner.savepoint_parts()
    }
}