Data.CQRS.Command

Module to import for the Command side of the application.

Documentation

type AggregateAction a e = Maybe a -> e -> a

An aggregate action is just a function for applying an event to an aggregate. Aggregates that have not been created yet will be passed in as Nothing and aggregates which are being updated will be passed in as Just x.

data Repository a e

Repository consisting of an event store and an event bus.

data CommandT a e m b

Command monad transformer.

Instances

MonadTrans (CommandT a e)

Monad m => Monad (CommandT a e m)

Functor m => Functor (CommandT a e m)

Applicative m => Applicative (CommandT a e m)

MonadIO m => MonadIO (CommandT a e m)

createAggregate :: (MonadIO m, Monad m) => UUID -> (UnitOfWorkT a e (CommandT a e m) (Maybe a) -> UnitOfWorkT a e (CommandT a e m) b) -> CommandT a e m b

Create a new aggregate using the supplied unit of work. Throws a VersionConflict exception if there is already an aggregate with the given aggregate ID. NOTE: The exception may be thrown at the END of the unit of work, and so any operations in the unit of work that are lifted into the nested monad may be performed regardless. (This is due to optimistic concurrency control.)

execCommandT :: MonadIO m => Repository a e -> CommandT a e m b -> m ()

Run a command against a repository, ignoring the result.

freshUUID :: MonadIO m => CommandT a e m UUID

Create a fresh UUID from the repository.

publishEvent :: (MonadIO m, NFData a, NFData e) => e -> UnitOfWorkT a e (CommandT a e m) ()

Publish event for the current aggregate.

readAggregate :: MonadIO m => UUID -> CommandT a e m (Maybe a)

Read value of an aggregate if it exists. If any update needs to be performed on the aggregate, use of the getter function (see createAggregate and updateAggregate) should be preferred.

runCommandT :: MonadIO m => Repository a e -> CommandT a e m b -> m b

Run a command against a repository.

data UnitOfWorkT a e m b

Unit of work monad transformer.

Instances

MonadTrans (UnitOfWorkT a e)

Monad m => Monad (UnitOfWorkT a e m)

Functor m => Functor (UnitOfWorkT a e m)

Monad m => Applicative (UnitOfWorkT a e m)

MonadIO m => MonadIO (UnitOfWorkT a e m)

updateAggregate :: MonadIO m => UUID -> (UnitOfWorkT a e (CommandT a e m) a -> UnitOfWorkT a e (CommandT a e m) b) -> CommandT a e m (Maybe b)

Update aggregate with the supplied unit of work. The unit of work is given a function to get the current value of the aggregate. Returns the value returned by the unit of work, or Nothing if there was no aggregate with the given ID. Throws a VersionConflict exception if a version conflict occurs during commit. NOTE: The exception may be thrown at the END of the unit of work, and so any operations in the unit of work that are lifted into the nested monad may be performed regardless. (This is due to optimistic concurrency control.)