All Classes

Class	Description
AddNewAggregateSnapshotStrategy	Strategy for when an aggregate snapshot should be added
AddNewAggregateSnapshotStrategy.AddNewSnapshotWhenBehindByNumberOfEvents
Aggregate<ID,AGGREGATE_TYPE extends Aggregate<ID,AGGREGATE_TYPE>>	Common interface that all concrete (classical) Aggregate's must implement.
AggregateException
AggregateIdResolver<T,ID>	Interface responsible for resolve the optional aggregate id associated with the type T Example of usages: Command - return the aggregate id associated with the command (can return an Optional.empty()) in case server generated id's are used for commands that create a new Aggregate instance) Event - return the aggregate id associated with the event State - return the aggregate id associated with the aggregate state event projection View - return the aggregate id associated with the View event projection
AggregateRoot<ID,EVENT_TYPE extends Event<ID>,AGGREGATE_TYPE extends AggregateRoot<ID,EVENT_TYPE,AGGREGATE_TYPE>>	A specialized and opinionated mutable Aggregate design This AggregateRoot is designed to work with Class based Event's that inherit from Event. This design is deliberate and will manage a lot of things for you as a developer at the cost of some flexibility.
AggregateRoot<ID,EVENT_TYPE,AGGREGATE_TYPE extends AggregateRoot<ID,EVENT_TYPE,AGGREGATE_TYPE>>	A modern opinionated interpretation of the classic AggregateRoot design, where the Event's are mutable. The modern interpretation doesn't specify any requirement on the design of the Events, they can be Java 17+ records or simple POJO's. Note: The AggregateRoot works best in combination with the StatefulAggregateRepository that's configured to use the StatefulAggregateInstanceFactory.reflectionBasedAggregateRootFactory(), because the AggregateRoot needs to be provided its aggregated id through the AggregateRoot(Object) constructor! The modern AggregateRoot supports keeping the state projection and EventHandler annotated methods within the AggregateRoot instance or within an AggregateState instance. If you wish to keep the state projection and EventHandler annotated methods within an AggregateState instance, then you only need to implement the WithState interface:
AggregateRootWithState<ID,EVENT_TYPE extends Event<ID>,STATE extends AggregateState<ID,EVENT_TYPE>,AGGREGATE_TYPE extends AggregateRootWithState<ID,EVENT_TYPE,STATE,AGGREGATE_TYPE>>	Variant of the AggregateRoot pattern where the aggregate's state and all EventHandler annotated methods are placed within the concrete AggregateState object. When the AggregateRootWithState is combined with AggregateState, then the AggregateRootWithState will contain the command methods and the AggregateState contains the state fields and the EventHandler annotated methods.
AggregateSnapshot<ID,AGGREGATE_IMPL_TYPE>	Aggregate snapshot loaded using loadSnapshot(AggregateType, Object, Class)
AggregateSnapshotDeletionStrategy	Strategy for which historic aggregate snapshots (i.e.
AggregateSnapshotDeletionStrategy.DeleteAllHistoricSnapshots	Strategy that deletes any historic aggregate snapshots when a new snapshot is persisted
AggregateSnapshotDeletionStrategy.KeepHistoricSnapshots	Strategy that keeps all or a specific number of historic aggregate snapshots
AggregateSnapshotRepository	Repository storing and updating Aggregate instance snapshots
AggregateState<ID,EVENT_TYPE extends Event<ID>>	Base class for the state object associated with AggregateRootWithState. When this is combined with the AggregateRootWithState when the AggregateRootWithState will contain the command methods and the AggregateState contains the state fields and the EventHandler annotated methods.
AggregateState<ID,EVENT_TYPE,AGGREGATE_TYPE extends AggregateRoot<ID,EVENT_TYPE,AGGREGATE_TYPE>>	Aggregate state object associated with a given AggregateRoot instance (see AggregateState.getAggregate()) Example:
BrokenSnapshot	AggregateSnapshot.aggregateSnapshot value that's returned from AggregateSnapshotRepository in case the Aggregate snapshot couldn't be deserialized
CommandHandler<COMMAND,EVENT,ERROR>	Command Handler which is responsible for loading any existing Aggregate STATE from the underlying EventStore (see CommandHandler.deciderBasedCommandHandler(ConfigurableEventStore, AggregateType, Class, AggregateIdResolver, AggregateIdResolver, AggregateSnapshotRepository, Class, Decider)) and coordinate persisting any changes to the Aggregate, in the form of EVENT's, to the EventStore as part of an active UnitOfWork (if one exists) The actual logic is delegated to an instance of a Decider
Decider<COMMAND,EVENT,ERROR,STATE>	Variant of the event sourced Decider pattern, which supports building an Aggregate STATE based on previous EVENT's that relate to the aggregate instance, and which can handle COMMAND's, whose side effect is either an ERROR or a List of EVENT's (can be an empty list)
DelayedAddAndDeleteAggregateSnapshotDelegate	Delegating AggregateSnapshotRepository which directly delegates all operations to the provided delegateRepository, except for aggregateUpdated(Object, AggregateEventStream), deleteSnapshots(AggregateType, Object, Class, List), which are performed asynchronously in the background. This ensures that expensive update/clean-up for aggregate snapshots in the database don't affect aggregate persistence performance.
Event<ID>	Based Event type that's built to work in combination with AggregateRoot All you need to do is to inherit from this class when building your own Event types.
EventHandler	Methods annotated with this Annotation will automatically be called when an event is being applied or rehydrated on to an Aggregate instance
EventsToPersist<ID,EVENT_TYPE>	Wrapper object that captures the results of any command handling (e.g.
FlexAggregate<ID,AGGREGATE_TYPE extends FlexAggregate<ID,AGGREGATE_TYPE>>	Simple, easy and opinionated aggregate that allows you to apply events that don't have any requirements with regards to inheritance (i.e.
FlexAggregateRepository<ID,AGGREGATE_TYPE extends FlexAggregate<ID,AGGREGATE_TYPE>>	Opinionated FlexAggregate Repository that's built to persist and load a specific FlexAggregate type in combination with EventStore, EventStoreUnitOfWorkFactory and a FlexAggregateRepository.
FlexAggregateRepository.DefaultFlexAggregateRepository<ID,AGGREGATE_TYPE extends FlexAggregate<ID,AGGREGATE_TYPE>>
Handler<COMMAND,EVENT,ERROR,STATE>	Decider related interface that is responsible for handling COMMAND(s),whose side effect is either an ERROR or a List of EVENT's (can be an empty list)
HandlerResult<ERROR,EVENT>	Captures that result of calling a Handler.handle(Object, Object) for a specific COMMAND and aggregate STATE Concrete instances can either be of type HandlerResult.Success or type HandlerResult.Error
HandlerResult.Error<ERROR,EVENT>	Error variant of the HandlerResult
HandlerResult.Success<ERROR,EVENT>	Success variant of the HandlerResult
InitialEventIsMissingAggregateIdException
InitialStateProvider<STATE>	Decider or View related interface, which provides the Initial STATE for a given aggregate/projection/view. The InitialStateProvider works in collaboration with the StateEvolver in the context of the Decider or View pattern
IsStateFinalResolver<STATE>	Decider related interface that resolves if the aggregate's state is final and no more changes can occur, i.e.
OptimisticAggregateLoadException
PostgresqlAggregateSnapshotRepository
StateEvolver<EVENT,STATE>	A Decider or View related interface, which can apply EVENT<(s) to a aggregate/projection/view STATE instance
StatefulAggregate<ID,EVENT_TYPE,AGGREGATE_TYPE extends StatefulAggregate<ID,EVENT_TYPE,AGGREGATE_TYPE>>	A stateful Aggregate is the most common form of Aggregate design in Object Oriented languages. What makes an Aggregate stateful is the fact that any changes, i.e.
StatefulAggregateInMemoryProjector	Aggregate specific InMemoryProjector Note: An in memory projection is never associated with a UnitOfWork and any changes to the aggregate won't automatically be persisted.
StatefulAggregateInstanceFactory	Factory that helps the StatefulAggregateRepository/StatefulAggregateInMemoryProjector to create an instance of a given Aggregate.
StatefulAggregateInstanceFactory.ObjenesisAggregateInstanceFactory	StatefulAggregateInstanceFactory that uses Objenesis to create a new instance of the Aggregate Please note: Objenesis doesn't initialize fields nor call any constructors, so you Aggregate design needs to take this into consideration. All concrete aggregates that extends AggregateRoot have been prepared to be initialized by Objenesis
StatefulAggregateInstanceFactory.ReflectionBasedAggregateInstanceFactory	StatefulAggregateInstanceFactory that calls the default no-arguments constructor on the concrete Aggregate type to create a new instance of the Aggregate
StatefulAggregateRepository<ID,EVENT_TYPE,AGGREGATE_IMPL_TYPE extends StatefulAggregate<ID,EVENT_TYPE,AGGREGATE_IMPL_TYPE>>	Opinionated Aggregate Repository that's built to persist and load a specific StatefulAggregate type in combination with EventStore, UnitOfWorkFactory and a StatefulAggregateInstanceFactory. You can use the StatefulAggregateRepository.from(ConfigurableEventStore, AggregateEventStreamConfiguration, StatefulAggregateInstanceFactory, Class) to create a new StatefulAggregateRepository instance that supports the most common repository method. Alternatively you can extend from the StatefulAggregateRepository.DefaultStatefulAggregateRepository and add your own special methods
StatefulAggregateRepository.DefaultStatefulAggregateRepository<ID,EVENT_TYPE,AGGREGATE_IMPL_TYPE extends StatefulAggregate<ID,EVENT_TYPE,AGGREGATE_IMPL_TYPE>>	Default StatefulAggregateRepository implementation.
View<EVENT,STATE>	Variant of the Event Sourced Projection/View concept
WithState<ID,EVENT_TYPE,AGGREGATE_TYPE extends AggregateRoot<ID,EVENT_TYPE,AGGREGATE_TYPE>,AGGREGATE_STATE extends AggregateState<ID,EVENT_TYPE,AGGREGATE_TYPE>>	Marker interface that indicates that all state and all EventHandler annotated methods will be hosted with the AggregateState object.