Imm.Database

Database module abstracts over a key-value database that supports CRUD operations.

Types

class (Ord (Key t), Show (Key t), Show (Entry t), Typeable t, Show t, Pretty t, Pretty (Key t)) => Table t

Generic database table

Associated Types

type Key t :: *

type Entry t :: *

Instances

Table FeedTable

Associated Types

type Key FeedTable :: *

type Entry FeedTable :: *

class MonadThrow m => MonadDatabase t m where

Monad capable of interacting with a key-value store.

Minimal complete definition

_describeDatabase, _fetchList, _fetchAll, _update, _insertList, _deleteList, _purge, _commit

Methods

_describeDatabase :: t -> m (Doc a)

_fetchList :: t -> [Key t] -> m (Map (Key t) (Entry t))

_fetchAll :: t -> m (Map (Key t) (Entry t))

_update :: t -> Key t -> (Entry t -> Entry t) -> m ()

_insertList :: t -> [(Key t, Entry t)] -> m ()

_deleteList :: t -> [Key t] -> m ()

_purge :: t -> m ()

_commit :: t -> m ()

Instances

(Table t, FromJSON (Key t), FromJSON (Entry t), ToJSON (Key t), ToJSON (Entry t)) => MonadDatabase t (ReaderT * (MVar (JsonFileDatabase t)) IO)

Methods

_describeDatabase :: t -> ReaderT * (MVar (JsonFileDatabase t)) IO (Doc a)

_fetchList :: t -> [Key t] -> ReaderT * (MVar (JsonFileDatabase t)) IO (Map (Key t) (Entry t))

_fetchAll :: t -> ReaderT * (MVar (JsonFileDatabase t)) IO (Map (Key t) (Entry t))

_update :: t -> Key t -> (Entry t -> Entry t) -> ReaderT * (MVar (JsonFileDatabase t)) IO ()

_insertList :: t -> [(Key t, Entry t)] -> ReaderT * (MVar (JsonFileDatabase t)) IO ()

_deleteList :: t -> [Key t] -> ReaderT * (MVar (JsonFileDatabase t)) IO ()

_purge :: t -> ReaderT * (MVar (JsonFileDatabase t)) IO ()

_commit :: t -> ReaderT * (MVar (JsonFileDatabase t)) IO ()

(MonadThrow m, MonadDatabase FeedTable (ReaderT * b m)) => MonadDatabase FeedTable (ReaderT * (Modules a b c d e) m)

Methods

_describeDatabase :: FeedTable -> ReaderT * (Modules a b c d e) m (Doc a)

_fetchList :: FeedTable -> [Key FeedTable] -> ReaderT * (Modules a b c d e) m (Map (Key FeedTable) (Entry FeedTable))

_fetchAll :: FeedTable -> ReaderT * (Modules a b c d e) m (Map (Key FeedTable) (Entry FeedTable))

_update :: FeedTable -> Key FeedTable -> (Entry FeedTable -> Entry FeedTable) -> ReaderT * (Modules a b c d e) m ()

_insertList :: FeedTable -> [(Key FeedTable, Entry FeedTable)] -> ReaderT * (Modules a b c d e) m ()

_deleteList :: FeedTable -> [Key FeedTable] -> ReaderT * (Modules a b c d e) m ()

_purge :: FeedTable -> ReaderT * (Modules a b c d e) m ()

_commit :: FeedTable -> ReaderT * (Modules a b c d e) m ()

data DatabaseException t

Constructors

NotCommitted t

NotDeleted t [Key t]

NotFound t [Key t]

NotInserted t [(Key t, Entry t)]

NotPurged t

NotUpdated t (Key t)

UnableFetchAll t

Instances

(Eq t, Eq (Key t), Eq (Entry t)) => Eq (DatabaseException t)

Methods

(==) :: DatabaseException t -> DatabaseException t -> Bool

(/=) :: DatabaseException t -> DatabaseException t -> Bool

(Show t, Show (Key t), Show (Entry t)) => Show (DatabaseException t)

Methods

showsPrec :: Int -> DatabaseException t -> ShowS

show :: DatabaseException t -> String

showList :: [DatabaseException t] -> ShowS

(Table t, Show (Key t), Show (Entry t), Pretty (Key t), Typeable * t) => Exception (DatabaseException t)

Methods

toException :: DatabaseException t -> SomeException

fromException :: SomeException -> Maybe (DatabaseException t)

displayException :: DatabaseException t -> String

(Pretty t, Pretty (Key t)) => Pretty (DatabaseException t)

Methods

pretty :: DatabaseException t -> Doc ann

prettyList :: [DatabaseException t] -> Doc ann

Primitives

fetch :: (MonadDatabase t m, Table t, MonadThrow m) => t -> Key t -> m (Entry t)

fetchList :: (MonadDatabase t m, MonadThrow m) => t -> [Key t] -> m (Map (Key t) (Entry t))

fetchAll :: (MonadThrow m, MonadDatabase t m) => t -> m (Map (Key t) (Entry t))

update :: (MonadDatabase t m, MonadThrow m) => t -> Key t -> (Entry t -> Entry t) -> m ()

insert :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> Key t -> Entry t -> m ()

insertList :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> [(Key t, Entry t)] -> m ()

delete :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> Key t -> m ()

deleteList :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> [Key t] -> m ()

purge :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> m ()

commit :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> m ()