Struct AggregateRepository 

pub struct AggregateRepository<R, A> { /* private fields */ }

Async repository wrapper for a specific aggregate type.

Snapshots are an optional, transparent optimization: with_snapshots(n) configures snapshot caching on this same type, and every method behaves identically with or without it — on commit a snapshot is staged in the same transaction when due, and on load the aggregate is hydrated from a snapshot when one exists.

Implementations

impl<R, A> AggregateRepository<R, A>

pub fn new(repo: R) -> Self

pub fn repo(&self) -> &R

pub fn repo_mut(&mut self) -> &mut R

impl<R, A> AggregateRepository<R, A>

where R: GetStream, A: Aggregate + Send,

pub async fn get(&self, id: &str) -> Result<Option<A>, RepositoryError>

pub async fn get_all(&self, ids: &[&str]) -> Result<Vec<A>, RepositoryError>

Load existing aggregates for the provided ids.

Each id is converted to a StreamIdentity, fetched through get_streams, and hydrated if present. Missing streams are skipped, and backend implementations may return aggregates in storage order rather than input order.

impl<R, A> AggregateRepository<R, A>

where R: TransactionalCommit, A: Aggregate + Send,

pub async fn commit(&self, aggregate: &mut A) -> Result<(), RepositoryError>

pub async fn commit_all( &self, aggregates: &mut [&mut A], ) -> Result<(), RepositoryError>

pub async fn commit_entities( &self, streams: Vec<(StreamIdentity, &mut Entity)>, ) -> Result<(), RepositoryError>

impl<R, A> AggregateRepository<R, A>

where R: GetWithOpts, A: Aggregate + Send,

pub async fn get_with( &self, id: &str, opts: ReadOpts, ) -> Result<Option<A>, RepositoryError>

Load an aggregate with options (e.g. ReadOpts::no_lock() to skip the queue lock when the repository is a queued() wrapper).

pub async fn peek(&self, id: &str) -> Result<Option<A>, RepositoryError>

Non-locking read (alias for get_with(ReadOpts::no_lock())).

impl<R, A> AggregateRepository<R, A>

where R: GetAllWithOpts, A: Aggregate + Send,

pub async fn get_all_with( &self, ids: &[&str], opts: ReadOpts, ) -> Result<Vec<A>, RepositoryError>

Load aggregates for the provided ids with options.

pub async fn peek_all(&self, ids: &[&str]) -> Result<Vec<A>, RepositoryError>

Non-locking multi-read (alias for get_all_with(ReadOpts::no_lock())).

impl<R, A> AggregateRepository<R, A>

where R: UnlockableRepository, A: Aggregate,

pub async fn abort(&self, aggregate: &A) -> Result<(), RepositoryError>

Release the lock held for an aggregate after an aborted load.

pub async fn unlock(&self, id: &str) -> Result<(), RepositoryError>

Release the lock held for an aggregate id.

impl<R, A> AggregateRepository<R, A>

pub fn outbox(&self, message: OutboxMessage) -> AggregateCommit<'_, R, A>

Start a commit with an outbox message attached.

pub fn read_models( &self, read_models: ReadModelWritePlanBuilder, ) -> AggregateCommit<'_, R, A>

Start a commit with relational read-model writes attached. Composes with .outbox(..), the aggregate’s events, and snapshots in one transaction.

impl<R, A> AggregateRepository<R, A>

where R: SnapshotStore + Sync, A: Snapshottable + Send,

pub fn with_snapshots(self, frequency: u64) -> Self

Enable snapshot caching at the given event frequency.

Snapshots are a transparent optimization: this configures snapshot behaviour on the same repository type and returns it. On commit a snapshot is staged (when due) in the same transaction; on load the aggregate is hydrated from a snapshot when one exists. Every other method behaves identically with or without snapshots.

Trait Implementations

impl<R, A> ConfigurableOutboxPublisher for AggregateRepository<R, A>

fn configure_outbox_publisher(&mut self, config: OutboxPublisherConfig)

Install the outbox publisher.

impl<R, A> HasOutboxStore for AggregateRepository<R, A>

where R: HasOutboxStore,

type OutboxStore = <R as HasOutboxStore>::OutboxStore

The concrete outbox store this repository produces.

fn outbox_store(&self) -> Self::OutboxStore

Produce a handle to the durable outbox store.

impl<R, A> HasRepo for AggregateRepository<R, A>

type Repo = AggregateRepository<R, A>

fn repo(&self) -> &Self::Repo