Eventful.Store.Class

EventStore

data EventStore serialized m

The EventStore is the core type of eventful. A store operates in some monad m and stores events by serializing them to the type serialized.

Constructors

EventStore

Fields

• getLatestVersion :: UUID -> m EventVersion

  Gets the latest EventVersion for a given Projection.

• getEvents :: UUID -> EventStoreQueryRange EventVersion -> m [StoredEvent serialized]

  Retrieves all the events for a given Projection using that projection's UUID. If an event version is provided then all events with a version greater than or equal to that version are returned.

• storeEvents :: ExpectedVersion -> UUID -> [serialized] -> m (Maybe EventWriteError)

  Stores the events for a given Projection using that projection's UUID.

newtype GloballyOrderedEventStore serialized m

Gets all the events ordered starting with a given SequenceNumber, and ordered by SequenceNumber. This is used when replaying all the events in a store.

Constructors

GloballyOrderedEventStore

Fields

• getSequencedEvents :: EventStoreQueryRange SequenceNumber -> m [GloballyOrderedEvent serialized]

data ExpectedVersion

ExpectedVersion is used to assert the event stream is at a certain version number. This is used when multiple writers are concurrently writing to the event store. If the expected version is incorrect, then storing fails.

Constructors

AnyVersion

Used when the writer doesn't care what version the stream is at.

NoStream

The stream shouldn't exist yet.

StreamExists

The stream should already exist.

ExactVersion EventVersion

Used to assert the stream is at a particular version.

Instances

Eq ExpectedVersion

Methods

(==) :: ExpectedVersion -> ExpectedVersion -> Bool

(/=) :: ExpectedVersion -> ExpectedVersion -> Bool

Show ExpectedVersion

Methods

showsPrec :: Int -> ExpectedVersion -> ShowS

show :: ExpectedVersion -> String

showList :: [ExpectedVersion] -> ShowS

data EventWriteError

Constructors

EventStreamNotAtExpectedVersion EventVersion

Instances

Eq EventWriteError

Methods

(==) :: EventWriteError -> EventWriteError -> Bool

(/=) :: EventWriteError -> EventWriteError -> Bool

Show EventWriteError

Methods

showsPrec :: Int -> EventWriteError -> ShowS

show :: EventWriteError -> String

showList :: [EventWriteError] -> ShowS

runEventStoreUsing :: (Monad m, Monad mstore) => (forall a. mstore a -> m a) -> EventStore serialized mstore -> EventStore serialized m

Changes the monad an EventStore runs in. This is useful to run event stores in another Monad while forgetting the original Monad.

runGloballyOrderedEventStoreUsing :: (Monad m, Monad mstore) => (forall a. mstore a -> m a) -> GloballyOrderedEventStore serialized mstore -> GloballyOrderedEventStore serialized m

Analog of runEventStoreUsing for a GloballyOrderedEventStore.

module Eventful.Store.Queries

Serialization

serializedEventStore :: Monad m => Serializer event serialized -> EventStore serialized m -> EventStore event m

Wraps an EventStore and transparently serializes/deserializes events for you. Note that in this implementation deserialization errors when using getEvents are simply ignored (the event is not returned).

serializedGloballyOrderedEventStore :: Monad m => Serializer event serialized -> GloballyOrderedEventStore serialized m -> GloballyOrderedEventStore event m

Like serializedEventStore except for GloballyOrderedEventStore.

Utility types

data ProjectionEvent event

A ProjectionEvent is an event that is associated with a Projection via the projection's UUID.

Constructors

ProjectionEvent

Fields

• projectionEventProjectionId :: !UUID

  The UUID of the Projection that the event belongs to.

• projectionEventEvent :: !event

  The actual event type. Note that this can be a serialized event or the actual Haskell event type.

Instances

Functor ProjectionEvent

Methods

fmap :: (a -> b) -> ProjectionEvent a -> ProjectionEvent b

(<$) :: a -> ProjectionEvent b -> ProjectionEvent a

Foldable ProjectionEvent

Methods

fold :: Monoid m => ProjectionEvent m -> m

foldMap :: Monoid m => (a -> m) -> ProjectionEvent a -> m

foldr :: (a -> b -> b) -> b -> ProjectionEvent a -> b

foldr' :: (a -> b -> b) -> b -> ProjectionEvent a -> b

foldl :: (b -> a -> b) -> b -> ProjectionEvent a -> b

foldl' :: (b -> a -> b) -> b -> ProjectionEvent a -> b

foldr1 :: (a -> a -> a) -> ProjectionEvent a -> a

foldl1 :: (a -> a -> a) -> ProjectionEvent a -> a

toList :: ProjectionEvent a -> [a]

null :: ProjectionEvent a -> Bool

length :: ProjectionEvent a -> Int

elem :: Eq a => a -> ProjectionEvent a -> Bool

maximum :: Ord a => ProjectionEvent a -> a

minimum :: Ord a => ProjectionEvent a -> a

sum :: Num a => ProjectionEvent a -> a

product :: Num a => ProjectionEvent a -> a

Traversable ProjectionEvent

Methods

traverse :: Applicative f => (a -> f b) -> ProjectionEvent a -> f (ProjectionEvent b)

sequenceA :: Applicative f => ProjectionEvent (f a) -> f (ProjectionEvent a)

mapM :: Monad m => (a -> m b) -> ProjectionEvent a -> m (ProjectionEvent b)

sequence :: Monad m => ProjectionEvent (m a) -> m (ProjectionEvent a)

Eq event => Eq (ProjectionEvent event)

Methods

(==) :: ProjectionEvent event -> ProjectionEvent event -> Bool

(/=) :: ProjectionEvent event -> ProjectionEvent event -> Bool

Show event => Show (ProjectionEvent event)

Methods

showsPrec :: Int -> ProjectionEvent event -> ShowS

show :: ProjectionEvent event -> String

showList :: [ProjectionEvent event] -> ShowS

data StoredEvent event

A StoredEvent is an event with associated storage metadata.

Constructors

StoredEvent

Fields

• storedEventProjectionId :: !UUID

  The UUID of the Projection that the event belongs to.

• storedEventVersion :: !EventVersion

  The version of the Projection corresponding to this event.

• storedEventEvent :: !event

  The actual event type. Note that this can be a serialized event or the actual Haskell event type.

Instances

Functor StoredEvent

Methods

fmap :: (a -> b) -> StoredEvent a -> StoredEvent b

(<$) :: a -> StoredEvent b -> StoredEvent a

Foldable StoredEvent

Methods

fold :: Monoid m => StoredEvent m -> m

foldMap :: Monoid m => (a -> m) -> StoredEvent a -> m

foldr :: (a -> b -> b) -> b -> StoredEvent a -> b

foldr' :: (a -> b -> b) -> b -> StoredEvent a -> b

foldl :: (b -> a -> b) -> b -> StoredEvent a -> b

foldl' :: (b -> a -> b) -> b -> StoredEvent a -> b

foldr1 :: (a -> a -> a) -> StoredEvent a -> a

foldl1 :: (a -> a -> a) -> StoredEvent a -> a

toList :: StoredEvent a -> [a]

null :: StoredEvent a -> Bool

length :: StoredEvent a -> Int

elem :: Eq a => a -> StoredEvent a -> Bool

maximum :: Ord a => StoredEvent a -> a

minimum :: Ord a => StoredEvent a -> a

sum :: Num a => StoredEvent a -> a

product :: Num a => StoredEvent a -> a

Traversable StoredEvent

Methods

traverse :: Applicative f => (a -> f b) -> StoredEvent a -> f (StoredEvent b)

sequenceA :: Applicative f => StoredEvent (f a) -> f (StoredEvent a)

mapM :: Monad m => (a -> m b) -> StoredEvent a -> m (StoredEvent b)

sequence :: Monad m => StoredEvent (m a) -> m (StoredEvent a)

Eq event => Eq (StoredEvent event)

Methods

(==) :: StoredEvent event -> StoredEvent event -> Bool

(/=) :: StoredEvent event -> StoredEvent event -> Bool

Show event => Show (StoredEvent event)

Methods

showsPrec :: Int -> StoredEvent event -> ShowS

show :: StoredEvent event -> String

showList :: [StoredEvent event] -> ShowS

storedEventToProjectionEvent :: StoredEvent event -> ProjectionEvent event

data GloballyOrderedEvent event

A GloballyOrderedEvent is like a StoredEvent but has a global SequenceNumber.

Constructors

GloballyOrderedEvent

Fields

• globallyOrderedEventProjectionId :: !UUID

  The UUID of the Projection that the event belongs to.

• globallyOrderedEventVersion :: !EventVersion

  The version of the Projection corresponding to this event.

• globallyOrderedEventSequenceNumber :: !SequenceNumber

  The global sequence number of this event.

• globallyOrderedEventEvent :: !event

  The actual event type. Note that this can be a serialized event or the actual Haskell event type.

Instances

Functor GloballyOrderedEvent

Methods

fmap :: (a -> b) -> GloballyOrderedEvent a -> GloballyOrderedEvent b

(<$) :: a -> GloballyOrderedEvent b -> GloballyOrderedEvent a

Foldable GloballyOrderedEvent

Methods

fold :: Monoid m => GloballyOrderedEvent m -> m

foldMap :: Monoid m => (a -> m) -> GloballyOrderedEvent a -> m

foldr :: (a -> b -> b) -> b -> GloballyOrderedEvent a -> b

foldr' :: (a -> b -> b) -> b -> GloballyOrderedEvent a -> b

foldl :: (b -> a -> b) -> b -> GloballyOrderedEvent a -> b

foldl' :: (b -> a -> b) -> b -> GloballyOrderedEvent a -> b

foldr1 :: (a -> a -> a) -> GloballyOrderedEvent a -> a

foldl1 :: (a -> a -> a) -> GloballyOrderedEvent a -> a

toList :: GloballyOrderedEvent a -> [a]

null :: GloballyOrderedEvent a -> Bool

length :: GloballyOrderedEvent a -> Int

elem :: Eq a => a -> GloballyOrderedEvent a -> Bool

maximum :: Ord a => GloballyOrderedEvent a -> a

minimum :: Ord a => GloballyOrderedEvent a -> a

sum :: Num a => GloballyOrderedEvent a -> a

product :: Num a => GloballyOrderedEvent a -> a

Traversable GloballyOrderedEvent

Methods

traverse :: Applicative f => (a -> f b) -> GloballyOrderedEvent a -> f (GloballyOrderedEvent b)

sequenceA :: Applicative f => GloballyOrderedEvent (f a) -> f (GloballyOrderedEvent a)

mapM :: Monad m => (a -> m b) -> GloballyOrderedEvent a -> m (GloballyOrderedEvent b)

sequence :: Monad m => GloballyOrderedEvent (m a) -> m (GloballyOrderedEvent a)

Eq event => Eq (GloballyOrderedEvent event)

Methods

(==) :: GloballyOrderedEvent event -> GloballyOrderedEvent event -> Bool

(/=) :: GloballyOrderedEvent event -> GloballyOrderedEvent event -> Bool

Show event => Show (GloballyOrderedEvent event)

Methods

showsPrec :: Int -> GloballyOrderedEvent event -> ShowS

show :: GloballyOrderedEvent event -> String

showList :: [GloballyOrderedEvent event] -> ShowS

globallyOrderedEventToStoredEvent :: GloballyOrderedEvent event -> StoredEvent event

Extract the StoredEvent from a GloballyOrderedEvent

globallyOrderedEventToProjectionEvent :: GloballyOrderedEvent event -> ProjectionEvent event

Extract the ProjectionEvent from a GloballyOrderedEvent

storedEventToGloballyOrderedEvent :: SequenceNumber -> StoredEvent event -> GloballyOrderedEvent event

Convert a StoredEvent to a GloballyOrderedEvent by adding the SequenceNumber. This is mainly used by event stores to create globally ordered events.

newtype EventVersion

Event versions are a strictly increasing series of integers for each projection. They allow us to order the events when they are replayed, and they also help as a concurrency check in a multi-threaded environment so services modifying the projection can be sure the projection didn't change during their execution.

Constructors

EventVersion

Fields

• unEventVersion :: Int

Instances

Enum EventVersion

Methods

succ :: EventVersion -> EventVersion

pred :: EventVersion -> EventVersion

toEnum :: Int -> EventVersion

fromEnum :: EventVersion -> Int

enumFrom :: EventVersion -> [EventVersion]

enumFromThen :: EventVersion -> EventVersion -> [EventVersion]

enumFromTo :: EventVersion -> EventVersion -> [EventVersion]

enumFromThenTo :: EventVersion -> EventVersion -> EventVersion -> [EventVersion]

Eq EventVersion

Methods

(==) :: EventVersion -> EventVersion -> Bool

(/=) :: EventVersion -> EventVersion -> Bool

Num EventVersion

Methods

(+) :: EventVersion -> EventVersion -> EventVersion

(-) :: EventVersion -> EventVersion -> EventVersion

(*) :: EventVersion -> EventVersion -> EventVersion

negate :: EventVersion -> EventVersion

abs :: EventVersion -> EventVersion

signum :: EventVersion -> EventVersion

fromInteger :: Integer -> EventVersion

Ord EventVersion

Methods

compare :: EventVersion -> EventVersion -> Ordering

(<) :: EventVersion -> EventVersion -> Bool

(<=) :: EventVersion -> EventVersion -> Bool

(>) :: EventVersion -> EventVersion -> Bool

(>=) :: EventVersion -> EventVersion -> Bool

max :: EventVersion -> EventVersion -> EventVersion

min :: EventVersion -> EventVersion -> EventVersion

Read EventVersion

Methods

readsPrec :: Int -> ReadS EventVersion

readList :: ReadS [EventVersion]

readPrec :: ReadPrec EventVersion

readListPrec :: ReadPrec [EventVersion]

Show EventVersion

Methods

showsPrec :: Int -> EventVersion -> ShowS

show :: EventVersion -> String

showList :: [EventVersion] -> ShowS

ToJSON EventVersion

Methods

toJSON :: EventVersion -> Value

toEncoding :: EventVersion -> Encoding

toJSONList :: [EventVersion] -> Value

toEncodingList :: [EventVersion] -> Encoding

FromJSON EventVersion

Methods

parseJSON :: Value -> Parser EventVersion

parseJSONList :: Value -> Parser [EventVersion]

newtype SequenceNumber

The sequence number gives us a global ordering of events in a particular event store. Using sequence numbers is not strictly necessary for an event sourcing and CQRS system, but it makes it way easier to replay events consistently without having to use distributed transactions in an event bus. In SQL-based event stores, they are also very cheap to create.

Constructors

SequenceNumber

Fields

• unSequenceNumber :: Int

Instances

Enum SequenceNumber

Methods

succ :: SequenceNumber -> SequenceNumber

pred :: SequenceNumber -> SequenceNumber

toEnum :: Int -> SequenceNumber

fromEnum :: SequenceNumber -> Int

enumFrom :: SequenceNumber -> [SequenceNumber]

enumFromThen :: SequenceNumber -> SequenceNumber -> [SequenceNumber]

enumFromTo :: SequenceNumber -> SequenceNumber -> [SequenceNumber]

enumFromThenTo :: SequenceNumber -> SequenceNumber -> SequenceNumber -> [SequenceNumber]

Eq SequenceNumber

Methods

(==) :: SequenceNumber -> SequenceNumber -> Bool

(/=) :: SequenceNumber -> SequenceNumber -> Bool

Num SequenceNumber

Methods

(+) :: SequenceNumber -> SequenceNumber -> SequenceNumber

(-) :: SequenceNumber -> SequenceNumber -> SequenceNumber

(*) :: SequenceNumber -> SequenceNumber -> SequenceNumber

negate :: SequenceNumber -> SequenceNumber

abs :: SequenceNumber -> SequenceNumber

signum :: SequenceNumber -> SequenceNumber

fromInteger :: Integer -> SequenceNumber

Ord SequenceNumber

Methods

compare :: SequenceNumber -> SequenceNumber -> Ordering

(<) :: SequenceNumber -> SequenceNumber -> Bool

(<=) :: SequenceNumber -> SequenceNumber -> Bool

(>) :: SequenceNumber -> SequenceNumber -> Bool

(>=) :: SequenceNumber -> SequenceNumber -> Bool

max :: SequenceNumber -> SequenceNumber -> SequenceNumber

min :: SequenceNumber -> SequenceNumber -> SequenceNumber

Read SequenceNumber

Methods

readsPrec :: Int -> ReadS SequenceNumber

readList :: ReadS [SequenceNumber]

readPrec :: ReadPrec SequenceNumber

readListPrec :: ReadPrec [SequenceNumber]

Show SequenceNumber

Methods

showsPrec :: Int -> SequenceNumber -> ShowS

show :: SequenceNumber -> String

showList :: [SequenceNumber] -> ShowS

ToJSON SequenceNumber

Methods

toJSON :: SequenceNumber -> Value

toEncoding :: SequenceNumber -> Encoding

toJSONList :: [SequenceNumber] -> Value

toEncodingList :: [SequenceNumber] -> Encoding

FromJSON SequenceNumber

Methods

parseJSON :: Value -> Parser SequenceNumber

parseJSONList :: Value -> Parser [SequenceNumber]

ToHttpApiData SequenceNumber

Methods

toUrlPiece :: SequenceNumber -> Text

toEncodedUrlPiece :: SequenceNumber -> Builder

toHeader :: SequenceNumber -> ByteString

toQueryParam :: SequenceNumber -> Text

FromHttpApiData SequenceNumber

Methods

parseUrlPiece :: Text -> Either Text SequenceNumber

parseHeader :: ByteString -> Either Text SequenceNumber

parseQueryParam :: Text -> Either Text SequenceNumber

PathPiece SequenceNumber

Methods

fromPathPiece :: Text -> Maybe SequenceNumber

toPathPiece :: SequenceNumber -> Text

Utility functions

transactionalExpectedWriteHelper :: Monad m => (UUID -> m EventVersion) -> (UUID -> [serialized] -> m ()) -> ExpectedVersion -> UUID -> [serialized] -> m (Maybe EventWriteError)

Helper to create storeEventsRaw given a function to get the latest stream version and a function to write to the event store. **NOTE**: This only works if the monad m is transactional.