Safe Haskell	Safe-Inferred
Language	Haskell2010

DomainDriven.Persistance.Postgres.Internal

Description

Postgres events with state as an IORef

Synopsis

data PostgresEvent model event = PostgresEvent {
- connectionPool :: Pool Connection
- eventTableName :: EventTableName
- modelIORef :: IORef (NumberedModel model)
- app :: model -> Stored event -> model
- seed :: model
- chunkSize :: ChunkSize
}
data PostgresEventTrans model event = PostgresEventTrans {
- transaction :: OngoingTransaction
- eventTableName :: EventTableName
- modelIORef :: IORef (NumberedModel model)
- app :: model -> Stored event -> model
- seed :: model
- chunkSize :: ChunkSize
}
getEventTableName :: EventTable -> EventTableName
createEventTable :: (FromJSON e, WriteModel (PostgresEventTrans m e)) => PostgresEventTrans m e -> IO ()
createEventTable' :: Connection -> EventTableName -> IO Int64
retireTable :: Connection -> EventTableName -> IO ()
createRetireFunction :: Connection -> IO ()
simplePool' :: MonadUnliftIO m => ConnectInfo -> m (Pool Connection)
simplePool :: MonadUnliftIO m => IO Connection -> m (Pool Connection)
postgresWriteModelNoMigration :: (FromJSON e, WriteModel (PostgresEventTrans m e)) => Pool Connection -> EventTableName -> (m -> Stored e -> m) -> m -> IO (PostgresEvent m e)
postgresWriteModel :: Pool Connection -> EventTable -> (m -> Stored e -> m) -> m -> IO (PostgresEvent m e)
newtype Exists = Exists {
- exists :: Bool
}
runMigrations :: OngoingTransaction -> EventTable -> IO ()
createPostgresPersistance :: forall event model. Pool Connection -> EventTableName -> (model -> Stored event -> model) -> model -> IO (PostgresEvent model event)
queryEvents :: FromJSON a => Connection -> EventTableName -> IO [(Stored a, EventNumber)]
queryEventsAfter :: FromJSON a => Connection -> EventTableName -> EventNumber -> IO [(Stored a, EventNumber)]
newtype EventQuery = EventQuery {
- getPgQuery :: Query
}
mkEventsAfterQuery :: EventTableName -> EventNumber -> EventQuery
mkEventQuery :: EventTableName -> EventQuery
headMay :: [a] -> Maybe a
queryHasEventsAfter :: Connection -> EventTableName -> EventNumber -> IO Bool
writeEvents :: forall a. ToJSON a => Connection -> EventTableName -> [Stored a] -> IO EventNumber
getEventStream' :: FromJSON event => PostgresEventTrans model event -> SerialT IO (Stored event)
withStreamReadTransaction :: forall t m a model event. (IsStream t, MonadAsync m, MonadCatch m) => PostgresEvent model event -> (PostgresEventTrans model event -> t m a) -> t m a
withIOTrans :: forall a model event. PostgresEvent model event -> (PostgresEventTrans model event -> IO a) -> IO a
mkEventStream :: FromJSON event => ChunkSize -> Connection -> EventQuery -> SerialT IO (Stored event, EventNumber)
getModel' :: forall e m. FromJSON e => PostgresEventTrans m e -> IO m
refreshModel :: forall m e. FromJSON e => PostgresEventTrans m e -> IO (m, EventNumber)
exclusiveLock :: OngoingTransaction -> EventTableName -> IO ()

Documentation

data PostgresEvent model event Source #

Constructors

PostgresEvent
Fields connectionPool :: Pool Connection eventTableName :: EventTableName modelIORef :: IORef (NumberedModel model) app :: model -> Stored event -> model seed :: model chunkSize :: ChunkSize Number of events read from postgres per batch

Instances

Instances details

Generic (PostgresEvent model event) Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Associated Types type Rep (PostgresEvent model event) :: Type -> Type # Methods from :: PostgresEvent model event -> Rep (PostgresEvent model event) x # to :: Rep (PostgresEvent model event) x -> PostgresEvent model event #
FromJSON e => ReadModel (PostgresEvent m e) Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Associated Types type Model (PostgresEvent m e) Source # type Event (PostgresEvent m e) Source # Methods applyEvent :: PostgresEvent m e -> Model (PostgresEvent m e) -> Stored (Event (PostgresEvent m e)) -> Model (PostgresEvent m e) Source # getModel :: PostgresEvent m e -> IO (Model (PostgresEvent m e)) Source # getEventList :: PostgresEvent m e -> IO [Stored (Event (PostgresEvent m e))] Source # getEventStream :: PostgresEvent m e -> SerialT IO (Stored (Event (PostgresEvent m e))) Source #
(ToJSON e, FromJSON e) => WriteModel (PostgresEvent m e) Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Methods transactionalUpdate :: MonadUnliftIO m0 => PostgresEvent m e -> (Model (PostgresEvent m e) -> m0 (Model (PostgresEvent m e) -> a, [Event (PostgresEvent m e)])) -> m0 a Source #
type Rep (PostgresEvent model event) Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal type Rep (PostgresEvent model event) = D1 ('MetaData "PostgresEvent" "DomainDriven.Persistance.Postgres.Internal" "domaindriven-core-0.5.0-7rYqBJZZqKF59TNQHBa9rT" 'False) (C1 ('MetaCons "PostgresEvent" 'PrefixI 'True) ((S1 ('MetaSel ('Just "connectionPool") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pool Connection)) :: (S1 ('MetaSel ('Just "eventTableName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 EventTableName) :: S1 ('MetaSel ('Just "modelIORef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (IORef (NumberedModel model))))) :: (S1 ('MetaSel ('Just "app") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (model -> Stored event -> model)) :: (S1 ('MetaSel ('Just "seed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 model) :*: S1 ('MetaSel ('Just "chunkSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChunkSize)))))
type Event (PostgresEvent m e) Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal type Event (PostgresEvent m e) = e
type Model (PostgresEvent m e) Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal type Model (PostgresEvent m e) = m

data PostgresEventTrans model event Source #

Constructors

PostgresEventTrans
Fields transaction :: OngoingTransaction eventTableName :: EventTableName modelIORef :: IORef (NumberedModel model) app :: model -> Stored event -> model seed :: model chunkSize :: ChunkSize Number of events read from postgres per batch

Instances

Instances details

Generic (PostgresEventTrans model event) Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Associated Types type Rep (PostgresEventTrans model event) :: Type -> Type # Methods from :: PostgresEventTrans model event -> Rep (PostgresEventTrans model event) x # to :: Rep (PostgresEventTrans model event) x -> PostgresEventTrans model event #
type Rep (PostgresEventTrans model event) Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal type Rep (PostgresEventTrans model event) = D1 ('MetaData "PostgresEventTrans" "DomainDriven.Persistance.Postgres.Internal" "domaindriven-core-0.5.0-7rYqBJZZqKF59TNQHBa9rT" 'False) (C1 ('MetaCons "PostgresEventTrans" 'PrefixI 'True) ((S1 ('MetaSel ('Just "transaction") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 OngoingTransaction) :: (S1 ('MetaSel ('Just "eventTableName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 EventTableName) :: S1 ('MetaSel ('Just "modelIORef") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (IORef (NumberedModel model))))) :: (S1 ('MetaSel ('Just "app") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (model -> Stored event -> model)) :: (S1 ('MetaSel ('Just "seed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 model) :*: S1 ('MetaSel ('Just "chunkSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChunkSize)))))

getEventTableName :: EventTable -> EventTableName Source #

createEventTable :: (FromJSON e, WriteModel (PostgresEventTrans m e)) => PostgresEventTrans m e -> IO () Source #

Create the table required for storing state and events, if they do not yet exist.

createEventTable' :: Connection -> EventTableName -> IO Int64 Source #

retireTable :: Connection -> EventTableName -> IO () Source #

createRetireFunction :: Connection -> IO () Source #

simplePool' :: MonadUnliftIO m => ConnectInfo -> m (Pool Connection) Source #

simplePool :: MonadUnliftIO m => IO Connection -> m (Pool Connection) Source #

postgresWriteModelNoMigration :: (FromJSON e, WriteModel (PostgresEventTrans m e)) => Pool Connection -> EventTableName -> (m -> Stored e -> m) -> m -> IO (PostgresEvent m e) Source #

Setup the persistance model and verify that the tables exist.

postgresWriteModel :: Pool Connection -> EventTable -> (m -> Stored e -> m) -> m -> IO (PostgresEvent m e) Source #

Setup the persistance model and verify that the tables exist.

newtype Exists Source #

Constructors

Exists
Fields exists :: Bool

Instances

Instances details

Generic Exists Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Associated Types type Rep Exists :: Type -> Type # Methods from :: Exists -> Rep Exists x # to :: Rep Exists x -> Exists #
Show Exists Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Methods showsPrec :: Int -> Exists -> ShowS # show :: Exists -> String # showList :: [Exists] -> ShowS #
Eq Exists Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Methods (==) :: Exists -> Exists -> Bool # (/=) :: Exists -> Exists -> Bool #
FromRow Exists Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Methods fromRow :: RowParser Exists #
type Rep Exists Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal type Rep Exists = D1 ('MetaData "Exists" "DomainDriven.Persistance.Postgres.Internal" "domaindriven-core-0.5.0-7rYqBJZZqKF59TNQHBa9rT" 'True) (C1 ('MetaCons "Exists" 'PrefixI 'True) (S1 ('MetaSel ('Just "exists") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)))

runMigrations :: OngoingTransaction -> EventTable -> IO () Source #

createPostgresPersistance :: forall event model. Pool Connection -> EventTableName -> (model -> Stored event -> model) -> model -> IO (PostgresEvent model event) Source #

queryEvents :: FromJSON a => Connection -> EventTableName -> IO [(Stored a, EventNumber)] Source #

queryEventsAfter :: FromJSON a => Connection -> EventTableName -> EventNumber -> IO [(Stored a, EventNumber)] Source #

newtype EventQuery Source #

Constructors

EventQuery
Fields getPgQuery :: Query

Instances

Instances details

Generic EventQuery Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Associated Types type Rep EventQuery :: Type -> Type # Methods from :: EventQuery -> Rep EventQuery x # to :: Rep EventQuery x -> EventQuery #
Show EventQuery Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal Methods showsPrec :: Int -> EventQuery -> ShowS # show :: EventQuery -> String # showList :: [EventQuery] -> ShowS #
type Rep EventQuery Source #
Instance details Defined in DomainDriven.Persistance.Postgres.Internal type Rep EventQuery = D1 ('MetaData "EventQuery" "DomainDriven.Persistance.Postgres.Internal" "domaindriven-core-0.5.0-7rYqBJZZqKF59TNQHBa9rT" 'True) (C1 ('MetaCons "EventQuery" 'PrefixI 'True) (S1 ('MetaSel ('Just "getPgQuery") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Query)))

mkEventsAfterQuery :: EventTableName -> EventNumber -> EventQuery Source #

mkEventQuery :: EventTableName -> EventQuery Source #

headMay :: [a] -> Maybe a Source #

queryHasEventsAfter :: Connection -> EventTableName -> EventNumber -> IO Bool Source #

writeEvents :: forall a. ToJSON a => Connection -> EventTableName -> [Stored a] -> IO EventNumber Source #

getEventStream' :: FromJSON event => PostgresEventTrans model event -> SerialT IO (Stored event) Source #

withStreamReadTransaction :: forall t m a model event. (IsStream t, MonadAsync m, MonadCatch m) => PostgresEvent model event -> (PostgresEventTrans model event -> t m a) -> t m a Source #

A transaction that is always rolled back at the end. This is useful when using cursors as they can only be used inside a transaction.

withIOTrans :: forall a model event. PostgresEvent model event -> (PostgresEventTrans model event -> IO a) -> IO a Source #

mkEventStream :: FromJSON event => ChunkSize -> Connection -> EventQuery -> SerialT IO (Stored event, EventNumber) Source #

getModel' :: forall e m. FromJSON e => PostgresEventTrans m e -> IO m Source #

refreshModel :: forall m e. FromJSON e => PostgresEventTrans m e -> IO (m, EventNumber) Source #

exclusiveLock :: OngoingTransaction -> EventTableName -> IO () Source #