Struct AsAggregate 

pub struct AsAggregate<A>(/* private fields */);

Newtype pattern to ensure compatibility between optional::Aggregate trait and the core Aggregate trait.

Usage

1. Use From<Aggregate> trait implementation:

   use eventually_util::optional::AsAggregate;
   
   let aggregate = AsAggregate::from(MyOptionalAggregate);

2. Use the Aggregate::as_aggregate method:

   let aggregate = MyOptionalAggregate.as_aggregate();

Trait Implementations

impl<A> Aggregate for AsAggregate<A>

where A: Aggregate + Send + Sync, A::Id: Send + Sync, A::Command: Send + Sync, A::State: Send + Sync,

type Id = <A as Aggregate>::Id

Aggregate identifier: this should represent an unique identifier to refer to a unique Aggregate instance.

type State = Option<<A as Aggregate>::State>

State of the Aggregate: this should represent the Domain Entity data structure.

type Event = <A as Aggregate>::Event

Represents a specific, domain-related change to the Aggregate State.

type Command = <A as Aggregate>::Command

Commands are all the possible operations available on an Aggregate. Use Commands to model business use-cases or State mutations.

type Error = <A as Aggregate>::Error

Possible failures while applying Events or handling Commands.

fn apply( state: Self::State, event: Self::Event, ) -> Result<Self::State, Self::Error>

Applies an Event to the current Aggregate State.

fn handle<'a, 's: 'a>( &'a self, id: &'s Self::Id, state: &'s Self::State, command: Self::Command, ) -> BoxFuture<'a, Result<Option<Vec<Self::Event>>, Self::Error>>

where Self: Sized,

Handles the requested Command and returns a list of Events to apply the State mutation based on the current representation of the State.

impl<A: Clone> Clone for AsAggregate<A>

fn clone(&self) -> AsAggregate<A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A> From<A> for AsAggregate<A>

fn from(value: A) -> Self

Converts to this type from the input type.