Copyright	(C) 2014 Yorick Laupa
License	(see the file LICENSE)
Maintainer	Yorick Laupa <yo.eight@gmail.com>
Stability	provisional
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Database.EventStore

Contents

Event
Connection
Read Operations
Write Operations
Transaction
Volatile Subscription
Catch-up Subscription
Results
Misc
Re-export

Description

Synopsis

Event

data Event Source

Contains event information like its type and data. Only used for write queries.

data EventData Source

Holds event data.

createEvent Source

Arguments

:: Text	Event type
-> Maybe UUID	Event ID, generated if `Nothing`
-> EventData	Event data
-> Event

withJson :: Value -> EventData Source

Creates a event using JSON format

withJsonAndMetadata :: Value -> Value -> EventData Source

Create a event with metadata using JSON format

Connection

data Connection Source

Represents a connection to a single EventStore node.

data ConnectionException Source

Constructors

MaxAttempt HostName Int Int

HostName Port MaxAttempt's value

Instances

Show ConnectionException
Exception ConnectionException
Typeable * ConnectionException

data Credentials Source

Holds login and password information.

Instances

Show Credentials

data Settings Source

Global Connection settings

Constructors

Settings
Fields s_heartbeatInterval :: NominalDiffTime s_heartbeatTimeout :: NominalDiffTime s_requireMaster :: Bool s_credentials :: Maybe Credentials s_retry :: Retry s_reconnect_delay_secs :: Int In seconds

data Retry Source

Represents reconnection strategy.

atMost :: Int -> Retry Source

Indicates how many times we should try to reconnect to the server. A value less than or equal to 0 means no retry.

keepRetrying :: Retry Source

Indicates we should try to reconnect to the server until the end of the Universe.

credentials Source

Arguments

:: ByteString	Login
-> ByteString	Password
-> Credentials

defaultSettings :: Settings Source

Default global settings.

connect Source

Arguments

:: Settings
-> String	HostName
-> Int	Port
-> IO Connection

Creates a new Connection to a single node. It maintains a full duplex connection to the EventStore. An EventStore Connection operates quite differently than say a SQL connection. Normally when you use a SQL connection you want to keep the connection open for a much longer of time than when you use a SQL connection.

Another difference is that with the EventStore Connection all operation are handled in a full async manner (even if you call the synchronous behaviors). Many threads can use an EvenStore Connection at the same time or a single thread can make many asynchronous requests. To get the most performance out of the connection it is generally recommend to use it in this way.

shutdown :: Connection -> IO () Source

Asynchronously closes the Connection.

Read Operations

readEvent Source

Arguments

:: Connection
-> Text	Stream name
-> Int32	Event number
-> Bool	Resolve Link Tos
-> IO (Async ReadResult)

Reads a single event from given stream.

readAllEventsBackward Source

Arguments

:: Connection
-> Position
-> Int32	Batch size
-> Bool	Resolve Link Tos
-> IO (Async AllEventsSlice)

Reads events from the $all stream backward

readAllEventsForward Source

Arguments

:: Connection
-> Position
-> Int32	Batch size
-> Bool	Resolve Link Tos
-> IO (Async AllEventsSlice)

Reads events from the $all stream forward.

readStreamEventsBackward Source

Arguments

:: Connection
-> Text	Stream name
-> Int32	From event number
-> Int32	Batch size
-> Bool	Resolve Link Tos
-> IO (Async StreamEventsSlice)

Reads events from a given stream backward.

readStreamEventsForward Source

Arguments

:: Connection
-> Text	Stream name
-> Int32	From event number
-> Int32	Batch size
-> Bool	Resolve Link Tos
-> IO (Async StreamEventsSlice)

Reads events from a given stream forward.

Write Operations

deleteStream Source

Arguments

:: Connection
-> Text	Stream name
-> ExpectedVersion
-> Maybe Bool	Hard delete
-> IO (Async DeleteResult)

Deletes given stream.

sendEvent Source

Arguments

:: Connection
-> Text	Stream name
-> ExpectedVersion
-> Event
-> IO (Async WriteResult)

Sends a single Event to given stream.

sendEvents Source

Arguments

:: Connection
-> Text	Stream name
-> ExpectedVersion
-> [Event]
-> IO (Async WriteResult)

Sends a list of Event to given stream.

Transaction

data Transaction Source

Represents a multi-request transaction with the EventStore.

transactionStart Source

Arguments

:: Connection
-> Text	Stream name
-> ExpectedVersion
-> IO (Async Transaction)

Starts a transaction on given stream.

transactionCommit :: Transaction -> IO (Async WriteResult) Source

Asynchronously commits this transaction.

transactionRollback :: Transaction -> IO () Source

Rollback this transaction.

transactionSendEvents :: Transaction -> [Event] -> IO (Async ()) Source

Asynchronously writes to a transaction in the EventStore.

Volatile Subscription

data DropReason Source

Represents the reason subscription drop happened.

Constructors

D_Unsubscribed
D_AccessDenied
D_NotFound
D_PersistentSubscriptionDeleted

Instances

Enum DropReason
Eq DropReason
Show DropReason

data Subscription Source

Represents a subscription to a single stream or $all stream in the EventStore.

subscribe Source

Arguments

:: Connection
-> Text	Stream name
-> Bool	Resolve Link Tos
-> IO (Async Subscription)

Subcribes to given stream.

subscribeToAll Source

Arguments

:: Connection
-> Bool	Resolve Link Tos
-> IO (Async Subscription)

Subcribes to $all stream.

subAwait :: Subscription -> IO (Either DropReason ResolvedEvent) Source

Awaits for the next ResolvedEvent.

subId :: Subscription -> UUID Source

ID of the subscription.

subStream :: Subscription -> Text Source

The name of the stream to which the subscription is subscribed.

subResolveLinkTos :: Subscription -> Bool Source

Determines whether or not any link events encontered in the stream will be resolved.

subLastCommitPos :: Subscription -> Int64 Source

The last commit position seen on the subscription (if this a subscription to $all stream).

subLastEventNumber :: Subscription -> Maybe Int32 Source

The last event number seen on the subscription (if this is a subscription to a single stream).

subUnsubscribe :: Subscription -> IO () Source

Asynchronously unsubscribe from the the stream.

Catch-up Subscription

data Catchup Source

Representing catch-up subscriptions.

data CatchupError Source

Errors that could arise during a catch-up subscription. Text value represents the stream name.

Constructors

CatchupStreamDeleted Text
CatchupUnexpectedStreamStatus Text ReadStreamResult
CatchupSubscriptionDropReason Text DropReason

Instances

Show CatchupError
Exception CatchupError
Typeable * CatchupError

subscribeFrom Source

Arguments

:: Connection
-> Text	Stream name
-> Bool	Resolve Link Tos
-> Maybe Int32	Last checkpoint
-> Maybe Int32	Batch size
-> IO Catchup

Subscribes to given stream. If last checkpoint is defined, this will readStreamEventsForward from that event number, otherwise from the beginning. Once last stream event reached up, a subscription request will be sent using subscribe.

subscribeToAllFrom Source

Arguments

:: Connection
-> Bool	Resolve Link Tos
-> Maybe Position	Last checkpoint
-> Maybe Int32	Batch size
-> IO Catchup

Same as subscribeFrom but applied to $all stream.

catchupAwait :: Catchup -> IO (Either CatchupError ResolvedEvent) Source

Awaits for the next ResolvedEvent.

catchupStream :: Catchup -> Text Source

The name of the stream to which the subscription is subscribed.

catchupUnsubscribe :: Catchup -> IO () Source

Asynchronously unsubscribes from the stream.

waitTillCatchup :: Catchup -> IO () Source

Waits until Catchup subscription catch-up its stream.

hasCaughtUp :: Catchup -> IO Bool Source

Non blocking version of waitTillCatchup.

Results

data AllEventsSlice Source

The result of a read operation from the $all stream.

Constructors

AllEventsSlice

Fields

allEventsSliceResult :: !ReadAllResult: Representing the status of the read attempt.
allEventsSliceFrom :: !Position: Representing the position where the next slice should be read from.
allEventsSliceNext :: !Position: Representing the position where the next slice should be read from.
allEventsSliceIsEOS :: !Bool: Representing whether or not this is the end of the $all stream.
allEventsSliceEvents :: ![ResolvedEvent]: The events read.
allEventsSliceDirection :: !ReadDirection: The direction of read request.

Instances

Show AllEventsSlice

newtype DeleteResult Source

Returned after deleting a stream. Position of the write.

Constructors

DeleteResult
Fields deleteStreamPosition :: Position

Instances

Show DeleteResult

data WriteResult Source

Returned after writing to a stream.

Constructors

WriteResult
Fields writeNextExpectedVersion :: !Int32 Next expected version of the stream. writePosition :: !Position `Position` of the write.

Instances

Show WriteResult

data ReadResult Source

Result of a single event read operation to the EventStore.

Constructors

ReadResult
Fields readResultStatus :: !ReadEventResult Attempt status readResultStreamId :: !Text Stream name readResultEventNumber :: !Int32 Event number readResultResolvedEvent :: !(Maybe ResolvedEvent)

Instances

Show ReadResult

data RecordedEvent Source

Represents a previously written event.

Constructors

RecordedEvent

Fields

recordedEventStreamId :: !Text: The event stream that this event belongs to.
recordedEventId :: !UUID: Unique identifier representing this event.
recordedEventNumber :: !Int32: Number of this event in the stream.
recordedEventType :: !Text: Type of this event.
recordedEventData :: !ByteString: Representing the data of this event.
recordedEventMetadata :: !(Maybe ByteString): Representing the metadada associated with this event.
recordedEventIsJson :: !Bool: Indicates whether the content is internally marked as json.
recordedEventCreated :: !(Maybe UTCTime): Representing when this event was created in the system.

Instances

Show RecordedEvent

data StreamEventsSlice Source

Represents the result of a single read operation to the EventStore.

Constructors

StreamEventsSlice

Fields

streamEventsSliceResult :: !ReadStreamResult: Representing the status of the read attempt.
streamEventsSliceStreamId :: !Text: The name of the stream read.
streamEventsSliceStart :: !Int32: The starting point (represented as a sequence number) of the read operation.
streamEventsSliceNext :: !Int32: The next event number that can be read.
streamEventsSliceLast :: !Int32: The last event number in the stream.
streamEventsSliceIsEOS :: !Bool: Representing whether or not this is the end of the stream.
streamEventsSliceEvents :: ![ResolvedEvent]: The events read represented as ResolvedEvent
streamEventsSliceDirection :: !ReadDirection: The direction of the read request.

Instances

Show StreamEventsSlice

data Position Source

A structure referring to a potential logical record position in the EventStore transaction file.

Constructors

Position
Fields positionCommit :: !Int64 Commit position of the record positionPrepare :: !Int64 Prepare position of the record

Instances

Show Position

data ReadDirection Source

Represents the direction of read operation (both from $all an usual streams).

Constructors

Forward	From beginning to end
Backward	From end to beginning

Instances

Show ReadDirection

data ReadAllResult Source

Enumeration detailing the possible outcomes of reading a slice of $all stream.

Constructors

RA_SUCCESS
RA_NOT_MODIFIED
RA_ERROR
RA_ACCESS_DENIED

Instances

Enum ReadAllResult
Eq ReadAllResult
Show ReadAllResult

data ReadEventResult Source

Enumeration representing the status of a single event read operation.

Constructors

RE_SUCCESS
RE_NOT_FOUND
RE_NO_STREAM
RE_STREAM_DELETED
RE_ERROR
RE_ACCESS_DENIED

Instances

Enum ReadEventResult
Eq ReadEventResult
Show ReadEventResult

data ResolvedEvent Source

A structure representing a single event or an resolved link event.

Constructors

ResolvedEvent
Fields resolvedEventRecord :: !(Maybe RecordedEvent) The event, or the resolved link event if this `ResolvedEvent` is a link event. resolvedEventLink :: !(Maybe RecordedEvent) The link event if this `ResolvedEvent` is a link event.

Instances

Show ResolvedEvent

data ReadStreamResult Source

Enumeration detailing the possible outcomes of reading a slice of a stream

Constructors

RS_SUCCESS
RS_NO_STREAM
RS_STREAM_DELETED
RS_NOT_MODIFIED
RS_ERROR
RS_ACCESS_DENIED

Instances

Enum ReadStreamResult
Eq ReadStreamResult
Show ReadStreamResult

data OperationException Source

Constructors

WrongExpectedVersion Text ExpectedVersion	Stream and Expected Version
StreamDeleted Text	Stream
InvalidTransaction
AccessDenied Text	Stream
InvalidServerResponse Word8 Word8	Expected, Found
ProtobufDecodingError String
ServerError (Maybe Text)	Reason

Instances

Show OperationException
Exception OperationException
Typeable * OperationException

eventResolved :: ResolvedEvent -> Bool Source

Indicates whether this ResolvedEvent is a resolved link event.

resolvedEventOriginal :: ResolvedEvent -> Maybe RecordedEvent Source

Returns the event that was read or which triggered the subscription.

If this ResolvedEvent represents a link event, the link will be the original event, otherwise it will be the event.

resolvedEventOriginalStreamId :: ResolvedEvent -> Maybe Text Source

The stream name of the original event.

positionStart :: Position Source

Representing the start of the transaction file.

positionEnd :: Position Source

Representing the end of the transaction file.

Misc

data ExpectedVersion Source

Constants used for expected version control.

The use of expected version can be a bit tricky especially when discussing idempotency assurances given by the EventStore.

The EventStore will assure idempotency for all operations using any value in ExpectedVersion except for anyStream. When using anyStream the EventStore will do its best to assure idempotency but will not guarantee idempotency.

Instances

Show ExpectedVersion

anyStream :: ExpectedVersion Source

This write should not conflict with anything and should always succeed.

noStream :: ExpectedVersion Source

The stream being written to should not yet exist. If it does exist treat that as a concurrency problem.

emptyStream :: ExpectedVersion Source

The stream should exist and should be empty. If it does not exist or is not empty, treat that as a concurrency problem.

exactStream :: Int32 -> ExpectedVersion Source

States that the last event written to the stream should have a sequence number matching your expected value.

Re-export

module Control.Concurrent.Async