eventastic_postgres 0.5.0

A postgres event store for eventastic
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
91
92

mod common;
mod encryption;
mod error;
mod pickle;
mod reader_impl;
mod repository;
mod side_effect;
mod table_config;
mod transaction;

pub use encryption::{EncryptionProvider, NoEncryption, NoEncryptionError};
pub use error::{DbError, SideEffectDbError};
pub use pickle::Pickle;
pub use repository::PostgresRepository;
pub use side_effect::SideEffectStorage;
pub use table_config::TableConfig;
pub use transaction::PostgresTransaction;

use crate::error::EventSourcingDbError;

use async_trait::async_trait;
use eventastic::{
    aggregate::{Aggregate, Context, SideEffect},
    event::DomainEvent,
    repository::{Repository, RepositoryError},
};
use sqlx::types::Uuid;

/// Extension trait for loading aggregates from PostgreSQL storage.
///
/// This trait provides PostgreSQL-specific methods for working with aggregates
/// that have UUID-based identifiers and can be serialized to JSON.
#[async_trait]
pub trait RootExt<T, O, E>
where
    T: Aggregate<AggregateId = Uuid> + Pickle + Send + Sync + 'static,
    <T as Aggregate>::DomainEvent: DomainEvent<EventId = Uuid> + Pickle + Send + Sync,
    <T as Aggregate>::SideEffect: SideEffect<SideEffectId = Uuid> + Pickle + Send + Sync,
    <T as Aggregate>::ApplyError: Send + Sync,
    O: SideEffectStorage<E::Error, T::SideEffect> + Send + Sync,
    E: EncryptionProvider + Clone + Send + Sync,
{
    /// Loads an aggregate from PostgreSQL storage by its UUID using an existing transaction.
    ///
    /// This method replays the event stream for the given aggregate ID,
    /// starting from any available snapshot and applying subsequent events.
    async fn load_with_transaction(
        transaction: &mut PostgresTransaction<'_, T, O, E>,
        aggregate_id: Uuid,
    ) -> Result<
        Context<T>,
        RepositoryError<
            T::ApplyError,
            <<T as Aggregate>::DomainEvent as DomainEvent>::EventId,
            EventSourcingDbError<E, T>,
        >,
    > {
        Context::load(transaction, &aggregate_id).await
    }

    /// Loads an aggregate from PostgreSQL storage by its UUID without a transaction.
    ///
    /// This method is more efficient for read-only operations as it uses a
    /// connection directly from the pool without starting a transaction.
    async fn load(
        repository: &PostgresRepository<T, O, E>,
        aggregate_id: Uuid,
    ) -> Result<
        Context<T>,
        RepositoryError<
            T::ApplyError,
            <<T as Aggregate>::DomainEvent as DomainEvent>::EventId,
            EventSourcingDbError<E, T>,
        >,
    >
    where
        O: Clone,
    {
        repository.load(&aggregate_id).await
    }
}

impl<T, O, E> RootExt<T, O, E> for T
where
    T: Aggregate<AggregateId = Uuid> + Pickle + Send + Sync + 'static,
    <T as Aggregate>::DomainEvent: DomainEvent<EventId = Uuid> + Pickle + Send + Sync,
    <T as Aggregate>::SideEffect: SideEffect<SideEffectId = Uuid> + Pickle + Send + Sync,
    <T as Aggregate>::ApplyError: Send + Sync,
    O: SideEffectStorage<E::Error, T::SideEffect> + Send + Sync,
    E: EncryptionProvider + Clone + Send + Sync,
{
}