--------------------------------------------------------------------------------
-- |
-- Module : Database.EventStore.Internal.Operation.Write.Common
-- Copyright : (C) 2015 Yorick Laupa
-- License : (see the file LICENSE)
--
-- Maintainer : Yorick Laupa <yo.eight@gmail.com>
-- Stability : provisional
-- Portability : non-portable
--
--------------------------------------------------------------------------------
module Database.EventStore.Internal.Operation.Write.Common where

--------------------------------------------------------------------------------
import Data.Int

--------------------------------------------------------------------------------
import Database.EventStore.Internal.Control (freshUUID)
import Database.EventStore.Internal.Prelude
import Database.EventStore.Internal.Types

--------------------------------------------------------------------------------
-- | Returned after writing to a stream.
data WriteResult
    = WriteResult
      { WriteResult -> Int64
writeNextExpectedVersion :: !Int64
        -- ^ Next expected version of the stream.
      , WriteResult -> Position
writePosition :: !Position
        -- ^ 'Position' of the write.
      }
    deriving (WriteResult -> WriteResult -> Bool
(WriteResult -> WriteResult -> Bool)
-> (WriteResult -> WriteResult -> Bool) -> Eq WriteResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WriteResult -> WriteResult -> Bool
$c/= :: WriteResult -> WriteResult -> Bool
== :: WriteResult -> WriteResult -> Bool
$c== :: WriteResult -> WriteResult -> Bool
Eq, Int -> WriteResult -> ShowS
[WriteResult] -> ShowS
WriteResult -> String
(Int -> WriteResult -> ShowS)
-> (WriteResult -> String)
-> ([WriteResult] -> ShowS)
-> Show WriteResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WriteResult] -> ShowS
$cshowList :: [WriteResult] -> ShowS
show :: WriteResult -> String
$cshow :: WriteResult -> String
showsPrec :: Int -> WriteResult -> ShowS
$cshowsPrec :: Int -> WriteResult -> ShowS
Show)

--------------------------------------------------------------------------------
-- | Constructs a 'NewEvent' from an 'Event'.
eventToNewEventIO :: Event -> IO NewEvent
eventToNewEventIO :: Event -> IO NewEvent
eventToNewEventIO Event
evt = do
    UUID
uuid <- IO UUID -> (UUID -> IO UUID) -> Maybe UUID -> IO UUID
forall b a. b -> (a -> b) -> Maybe a -> b
maybe IO UUID
forall (m :: * -> *). MonadIO m => m UUID
freshUUID UUID -> IO UUID
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe UUID
evt_id
    NewEvent -> IO NewEvent
forall (m :: * -> *) a. Monad m => a -> m a
return (NewEvent -> IO NewEvent) -> NewEvent -> IO NewEvent
forall a b. (a -> b) -> a -> b
$ Text
-> UUID
-> Int32
-> Int32
-> ByteString
-> Maybe ByteString
-> NewEvent
newEvent Text
evt_type
                      UUID
uuid
                      Int32
evt_data_type
                      Int32
evt_metadata_type
                      ByteString
evt_data_bytes
                      Maybe ByteString
evt_metadata_bytes
  where
    evt_type :: Text
evt_type           = EventType -> Text
eventTypeText (EventType -> Text) -> EventType -> Text
forall a b. (a -> b) -> a -> b
$ Event -> EventType
eventType Event
evt
    evt_id :: Maybe UUID
evt_id             = Event -> Maybe UUID
eventId Event
evt
    evt_data_bytes :: ByteString
evt_data_bytes     = EventData -> ByteString
eventDataBytes (EventData -> ByteString) -> EventData -> ByteString
forall a b. (a -> b) -> a -> b
$ Event -> EventData
eventData Event
evt
    evt_data_type :: Int32
evt_data_type      = EventData -> Int32
eventDataType (EventData -> Int32) -> EventData -> Int32
forall a b. (a -> b) -> a -> b
$ Event -> EventData
eventData Event
evt
    evt_metadata_bytes :: Maybe ByteString
evt_metadata_bytes = EventData -> Maybe ByteString
eventMetadataBytes (EventData -> Maybe ByteString) -> EventData -> Maybe ByteString
forall a b. (a -> b) -> a -> b
$ Event -> EventData
eventData Event
evt
    evt_metadata_type :: Int32
evt_metadata_type  = EventData -> Int32
eventMetadataType (EventData -> Int32) -> EventData -> Int32
forall a b. (a -> b) -> a -> b
$ Event -> EventData
eventData Event
evt