{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses      #-}

module Opaleye.Trans.Exception
    ( OpaleyeT (..)
    , runOpaleyeT

    , -- * Transactions
      Transaction
    , transaction
    , run

    , -- * Queries
      query
    , queryFirst

    , -- * Inserts
      insert
    , insertMany
    , insertReturning
    , insertReturningFirst
    , insertManyReturning

    , -- * Updates
      update
    , updateReturning
    , updateReturningFirst

    , -- * Deletes
      delete

    , -- * Exceptions
      withExceptOpaleye
    , withExceptTrans

    , -- * Utilities
      withError
    , withoutError
    , liftError
    , withTrans
    , maybeError

    , -- * Reexports
      liftIO
    , MonadIO
    , ask
    , Int64

    , throwError
    , catchError
    ) where

import           Control.Exception               (catch, throw)
import           Control.Monad.Except            (ExceptT (..), MonadError,
                                                  catchError, runExceptT,
                                                  throwError, withExceptT)
import           Control.Monad.IO.Class          (MonadIO, liftIO)
import           Control.Monad.Reader            (MonadReader (..))
import           Control.Monad.Trans             (MonadTrans (..))
import           Control.Monad.Catch             (MonadCatch, MonadThrow)

import           Data.Profunctor.Product.Default (Default)

import           Database.PostgreSQL.Simple      (Connection)
import qualified Database.PostgreSQL.Simple      as PSQL

import           GHC.Int                         (Int64)

import           Opaleye

import qualified Opaleye.Trans                   as T


newtype OpaleyeT e m a = OpaleyeT { OpaleyeT e m a -> ExceptT e (OpaleyeT m) a
unOpaleyeT :: ExceptT e (T.OpaleyeT m) a }
    deriving ( a -> OpaleyeT e m b -> OpaleyeT e m a
(a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
(forall a b. (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b)
-> (forall a b. a -> OpaleyeT e m b -> OpaleyeT e m a)
-> Functor (OpaleyeT e m)
forall a b. a -> OpaleyeT e m b -> OpaleyeT e m a
forall a b. (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
forall e (m :: * -> *) a b.
Functor m =>
a -> OpaleyeT e m b -> OpaleyeT e m a
forall e (m :: * -> *) a b.
Functor m =>
(a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> OpaleyeT e m b -> OpaleyeT e m a
$c<$ :: forall e (m :: * -> *) a b.
Functor m =>
a -> OpaleyeT e m b -> OpaleyeT e m a
fmap :: (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
$cfmap :: forall e (m :: * -> *) a b.
Functor m =>
(a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
Functor, Functor (OpaleyeT e m)
a -> OpaleyeT e m a
Functor (OpaleyeT e m)
-> (forall a. a -> OpaleyeT e m a)
-> (forall a b.
    OpaleyeT e m (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b)
-> (forall a b c.
    (a -> b -> c)
    -> OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m c)
-> (forall a b. OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b)
-> (forall a b. OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m a)
-> Applicative (OpaleyeT e m)
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m a
OpaleyeT e m (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
(a -> b -> c) -> OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m c
forall a. a -> OpaleyeT e m a
forall a b. OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m a
forall a b. OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
forall a b.
OpaleyeT e m (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
forall a b c.
(a -> b -> c) -> OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m c
forall e (m :: * -> *). Monad m => Functor (OpaleyeT e m)
forall e (m :: * -> *) a. Monad m => a -> OpaleyeT e m a
forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m a
forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
forall e (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m a
$c<* :: forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m a
*> :: OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
$c*> :: forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
liftA2 :: (a -> b -> c) -> OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m c
$cliftA2 :: forall e (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m c
<*> :: OpaleyeT e m (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
$c<*> :: forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m (a -> b) -> OpaleyeT e m a -> OpaleyeT e m b
pure :: a -> OpaleyeT e m a
$cpure :: forall e (m :: * -> *) a. Monad m => a -> OpaleyeT e m a
$cp1Applicative :: forall e (m :: * -> *). Monad m => Functor (OpaleyeT e m)
Applicative, Applicative (OpaleyeT e m)
a -> OpaleyeT e m a
Applicative (OpaleyeT e m)
-> (forall a b.
    OpaleyeT e m a -> (a -> OpaleyeT e m b) -> OpaleyeT e m b)
-> (forall a b. OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b)
-> (forall a. a -> OpaleyeT e m a)
-> Monad (OpaleyeT e m)
OpaleyeT e m a -> (a -> OpaleyeT e m b) -> OpaleyeT e m b
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
forall a. a -> OpaleyeT e m a
forall a b. OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
forall a b.
OpaleyeT e m a -> (a -> OpaleyeT e m b) -> OpaleyeT e m b
forall e (m :: * -> *). Monad m => Applicative (OpaleyeT e m)
forall e (m :: * -> *) a. Monad m => a -> OpaleyeT e m a
forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m a -> (a -> OpaleyeT e m b) -> OpaleyeT e m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> OpaleyeT e m a
$creturn :: forall e (m :: * -> *) a. Monad m => a -> OpaleyeT e m a
>> :: OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
$c>> :: forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m a -> OpaleyeT e m b -> OpaleyeT e m b
>>= :: OpaleyeT e m a -> (a -> OpaleyeT e m b) -> OpaleyeT e m b
$c>>= :: forall e (m :: * -> *) a b.
Monad m =>
OpaleyeT e m a -> (a -> OpaleyeT e m b) -> OpaleyeT e m b
$cp1Monad :: forall e (m :: * -> *). Monad m => Applicative (OpaleyeT e m)
Monad, Monad (OpaleyeT e m)
Monad (OpaleyeT e m)
-> (forall a. IO a -> OpaleyeT e m a) -> MonadIO (OpaleyeT e m)
IO a -> OpaleyeT e m a
forall a. IO a -> OpaleyeT e m a
forall e (m :: * -> *). MonadIO m => Monad (OpaleyeT e m)
forall e (m :: * -> *) a. MonadIO m => IO a -> OpaleyeT e m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> OpaleyeT e m a
$cliftIO :: forall e (m :: * -> *) a. MonadIO m => IO a -> OpaleyeT e m a
$cp1MonadIO :: forall e (m :: * -> *). MonadIO m => Monad (OpaleyeT e m)
MonadIO, MonadReader Connection
             , MonadError e, MonadThrow (OpaleyeT e m)
MonadThrow (OpaleyeT e m)
-> (forall e a.
    Exception e =>
    OpaleyeT e m a -> (e -> OpaleyeT e m a) -> OpaleyeT e m a)
-> MonadCatch (OpaleyeT e m)
OpaleyeT e m a -> (e -> OpaleyeT e m a) -> OpaleyeT e m a
forall e a.
Exception e =>
OpaleyeT e m a -> (e -> OpaleyeT e m a) -> OpaleyeT e m a
forall e (m :: * -> *). MonadCatch m => MonadThrow (OpaleyeT e m)
forall e (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
OpaleyeT e m a -> (e -> OpaleyeT e m a) -> OpaleyeT e m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
catch :: OpaleyeT e m a -> (e -> OpaleyeT e m a) -> OpaleyeT e m a
$ccatch :: forall e (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
OpaleyeT e m a -> (e -> OpaleyeT e m a) -> OpaleyeT e m a
$cp1MonadCatch :: forall e (m :: * -> *). MonadCatch m => MonadThrow (OpaleyeT e m)
MonadCatch, Monad (OpaleyeT e m)
e -> OpaleyeT e m a
Monad (OpaleyeT e m)
-> (forall e a. Exception e => e -> OpaleyeT e m a)
-> MonadThrow (OpaleyeT e m)
forall e a. Exception e => e -> OpaleyeT e m a
forall e (m :: * -> *). MonadThrow m => Monad (OpaleyeT e m)
forall e (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> OpaleyeT e m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
throwM :: e -> OpaleyeT e m a
$cthrowM :: forall e (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> OpaleyeT e m a
$cp1MonadThrow :: forall e (m :: * -> *). MonadThrow m => Monad (OpaleyeT e m)
MonadThrow
             )


instance MonadTrans (OpaleyeT e) where
    lift :: m a -> OpaleyeT e m a
lift = ExceptT e (OpaleyeT m) a -> OpaleyeT e m a
forall e (m :: * -> *) a.
ExceptT e (OpaleyeT m) a -> OpaleyeT e m a
OpaleyeT (ExceptT e (OpaleyeT m) a -> OpaleyeT e m a)
-> (m a -> ExceptT e (OpaleyeT m) a) -> m a -> OpaleyeT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OpaleyeT m a -> ExceptT e (OpaleyeT m) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (OpaleyeT m a -> ExceptT e (OpaleyeT m) a)
-> (m a -> OpaleyeT m a) -> m a -> ExceptT e (OpaleyeT m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> OpaleyeT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift


withOpaleye :: Monad m => T.OpaleyeT m a -> OpaleyeT e m a
withOpaleye :: OpaleyeT m a -> OpaleyeT e m a
withOpaleye = ExceptT e (OpaleyeT m) a -> OpaleyeT e m a
forall e (m :: * -> *) a.
ExceptT e (OpaleyeT m) a -> OpaleyeT e m a
OpaleyeT (ExceptT e (OpaleyeT m) a -> OpaleyeT e m a)
-> (OpaleyeT m a -> ExceptT e (OpaleyeT m) a)
-> OpaleyeT m a
-> OpaleyeT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OpaleyeT m a -> ExceptT e (OpaleyeT m) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift


-- | Given a 'Connection', run an 'OpaleyeT'
runOpaleyeT :: PSQL.Connection -> OpaleyeT e m a -> m (Either e a)
runOpaleyeT :: Connection -> OpaleyeT e m a -> m (Either e a)
runOpaleyeT Connection
c = Connection -> OpaleyeT m (Either e a) -> m (Either e a)
forall (m :: * -> *) a. Connection -> OpaleyeT m a -> m a
T.runOpaleyeT Connection
c (OpaleyeT m (Either e a) -> m (Either e a))
-> (OpaleyeT e m a -> OpaleyeT m (Either e a))
-> OpaleyeT e m a
-> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT e (OpaleyeT m) a -> OpaleyeT m (Either e a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT e (OpaleyeT m) a -> OpaleyeT m (Either e a))
-> (OpaleyeT e m a -> ExceptT e (OpaleyeT m) a)
-> OpaleyeT e m a
-> OpaleyeT m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OpaleyeT e m a -> ExceptT e (OpaleyeT m) a
forall e (m :: * -> *) a.
OpaleyeT e m a -> ExceptT e (OpaleyeT m) a
unOpaleyeT


withExceptOpaleye :: Functor m => (e -> e') -> OpaleyeT e m a -> OpaleyeT e' m a
withExceptOpaleye :: (e -> e') -> OpaleyeT e m a -> OpaleyeT e' m a
withExceptOpaleye e -> e'
f = ExceptT e' (OpaleyeT m) a -> OpaleyeT e' m a
forall e (m :: * -> *) a.
ExceptT e (OpaleyeT m) a -> OpaleyeT e m a
OpaleyeT (ExceptT e' (OpaleyeT m) a -> OpaleyeT e' m a)
-> (OpaleyeT e m a -> ExceptT e' (OpaleyeT m) a)
-> OpaleyeT e m a
-> OpaleyeT e' m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> e') -> ExceptT e (OpaleyeT m) a -> ExceptT e' (OpaleyeT m) a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> e'
f (ExceptT e (OpaleyeT m) a -> ExceptT e' (OpaleyeT m) a)
-> (OpaleyeT e m a -> ExceptT e (OpaleyeT m) a)
-> OpaleyeT e m a
-> ExceptT e' (OpaleyeT m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OpaleyeT e m a -> ExceptT e (OpaleyeT m) a
forall e (m :: * -> *) a.
OpaleyeT e m a -> ExceptT e (OpaleyeT m) a
unOpaleyeT


-- | Just like 'T.Transaction' only with exception handling
newtype Transaction e a = Transaction { Transaction e a -> ExceptT e Transaction a
unTransaction :: ExceptT e T.Transaction a }
    deriving (a -> Transaction e b -> Transaction e a
(a -> b) -> Transaction e a -> Transaction e b
(forall a b. (a -> b) -> Transaction e a -> Transaction e b)
-> (forall a b. a -> Transaction e b -> Transaction e a)
-> Functor (Transaction e)
forall a b. a -> Transaction e b -> Transaction e a
forall a b. (a -> b) -> Transaction e a -> Transaction e b
forall e a b. a -> Transaction e b -> Transaction e a
forall e a b. (a -> b) -> Transaction e a -> Transaction e b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Transaction e b -> Transaction e a
$c<$ :: forall e a b. a -> Transaction e b -> Transaction e a
fmap :: (a -> b) -> Transaction e a -> Transaction e b
$cfmap :: forall e a b. (a -> b) -> Transaction e a -> Transaction e b
Functor, Functor (Transaction e)
a -> Transaction e a
Functor (Transaction e)
-> (forall a. a -> Transaction e a)
-> (forall a b.
    Transaction e (a -> b) -> Transaction e a -> Transaction e b)
-> (forall a b c.
    (a -> b -> c)
    -> Transaction e a -> Transaction e b -> Transaction e c)
-> (forall a b.
    Transaction e a -> Transaction e b -> Transaction e b)
-> (forall a b.
    Transaction e a -> Transaction e b -> Transaction e a)
-> Applicative (Transaction e)
Transaction e a -> Transaction e b -> Transaction e b
Transaction e a -> Transaction e b -> Transaction e a
Transaction e (a -> b) -> Transaction e a -> Transaction e b
(a -> b -> c)
-> Transaction e a -> Transaction e b -> Transaction e c
forall e. Functor (Transaction e)
forall a. a -> Transaction e a
forall e a. a -> Transaction e a
forall a b. Transaction e a -> Transaction e b -> Transaction e a
forall a b. Transaction e a -> Transaction e b -> Transaction e b
forall a b.
Transaction e (a -> b) -> Transaction e a -> Transaction e b
forall e a b. Transaction e a -> Transaction e b -> Transaction e a
forall e a b. Transaction e a -> Transaction e b -> Transaction e b
forall e a b.
Transaction e (a -> b) -> Transaction e a -> Transaction e b
forall a b c.
(a -> b -> c)
-> Transaction e a -> Transaction e b -> Transaction e c
forall e a b c.
(a -> b -> c)
-> Transaction e a -> Transaction e b -> Transaction e c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Transaction e a -> Transaction e b -> Transaction e a
$c<* :: forall e a b. Transaction e a -> Transaction e b -> Transaction e a
*> :: Transaction e a -> Transaction e b -> Transaction e b
$c*> :: forall e a b. Transaction e a -> Transaction e b -> Transaction e b
liftA2 :: (a -> b -> c)
-> Transaction e a -> Transaction e b -> Transaction e c
$cliftA2 :: forall e a b c.
(a -> b -> c)
-> Transaction e a -> Transaction e b -> Transaction e c
<*> :: Transaction e (a -> b) -> Transaction e a -> Transaction e b
$c<*> :: forall e a b.
Transaction e (a -> b) -> Transaction e a -> Transaction e b
pure :: a -> Transaction e a
$cpure :: forall e a. a -> Transaction e a
$cp1Applicative :: forall e. Functor (Transaction e)
Applicative, Applicative (Transaction e)
a -> Transaction e a
Applicative (Transaction e)
-> (forall a b.
    Transaction e a -> (a -> Transaction e b) -> Transaction e b)
-> (forall a b.
    Transaction e a -> Transaction e b -> Transaction e b)
-> (forall a. a -> Transaction e a)
-> Monad (Transaction e)
Transaction e a -> (a -> Transaction e b) -> Transaction e b
Transaction e a -> Transaction e b -> Transaction e b
forall e. Applicative (Transaction e)
forall a. a -> Transaction e a
forall e a. a -> Transaction e a
forall a b. Transaction e a -> Transaction e b -> Transaction e b
forall a b.
Transaction e a -> (a -> Transaction e b) -> Transaction e b
forall e a b. Transaction e a -> Transaction e b -> Transaction e b
forall e a b.
Transaction e a -> (a -> Transaction e b) -> Transaction e b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Transaction e a
$creturn :: forall e a. a -> Transaction e a
>> :: Transaction e a -> Transaction e b -> Transaction e b
$c>> :: forall e a b. Transaction e a -> Transaction e b -> Transaction e b
>>= :: Transaction e a -> (a -> Transaction e b) -> Transaction e b
$c>>= :: forall e a b.
Transaction e a -> (a -> Transaction e b) -> Transaction e b
$cp1Monad :: forall e. Applicative (Transaction e)
Monad, MonadReader Connection, MonadError e)


withExceptTrans :: (e -> e') -> Transaction e a -> Transaction e' a
withExceptTrans :: (e -> e') -> Transaction e a -> Transaction e' a
withExceptTrans e -> e'
f = ExceptT e' Transaction a -> Transaction e' a
forall e a. ExceptT e Transaction a -> Transaction e a
Transaction (ExceptT e' Transaction a -> Transaction e' a)
-> (Transaction e a -> ExceptT e' Transaction a)
-> Transaction e a
-> Transaction e' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> e') -> ExceptT e Transaction a -> ExceptT e' Transaction a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> e'
f (ExceptT e Transaction a -> ExceptT e' Transaction a)
-> (Transaction e a -> ExceptT e Transaction a)
-> Transaction e a
-> ExceptT e' Transaction a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Transaction e a -> ExceptT e Transaction a
forall e a. Transaction e a -> ExceptT e Transaction a
unTransaction


withError :: Monad m => T.OpaleyeT m (Either e a) -> OpaleyeT e m a
withError :: OpaleyeT m (Either e a) -> OpaleyeT e m a
withError OpaleyeT m (Either e a)
f = OpaleyeT m (Either e a) -> OpaleyeT e m (Either e a)
forall (m :: * -> *) a e. Monad m => OpaleyeT m a -> OpaleyeT e m a
withOpaleye OpaleyeT m (Either e a)
f OpaleyeT e m (Either e a)
-> (Either e a -> OpaleyeT e m a) -> OpaleyeT e m a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (e -> OpaleyeT e m a)
-> (a -> OpaleyeT e m a) -> Either e a -> OpaleyeT e m a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either e -> OpaleyeT e m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError a -> OpaleyeT e m a
forall (m :: * -> *) a. Monad m => a -> m a
return


withoutError :: Monad m => OpaleyeT e m a -> T.OpaleyeT m (Either e a)
withoutError :: OpaleyeT e m a -> OpaleyeT m (Either e a)
withoutError = ExceptT e (OpaleyeT m) a -> OpaleyeT m (Either e a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT e (OpaleyeT m) a -> OpaleyeT m (Either e a))
-> (OpaleyeT e m a -> ExceptT e (OpaleyeT m) a)
-> OpaleyeT e m a
-> OpaleyeT m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OpaleyeT e m a -> ExceptT e (OpaleyeT m) a
forall e (m :: * -> *) a.
OpaleyeT e m a -> ExceptT e (OpaleyeT m) a
unOpaleyeT


liftError :: Monad m
          => (T.Transaction (Either e a) -> T.OpaleyeT m (Either r b))
          -> Transaction e a -> OpaleyeT r m b
liftError :: (Transaction (Either e a) -> OpaleyeT m (Either r b))
-> Transaction e a -> OpaleyeT r m b
liftError Transaction (Either e a) -> OpaleyeT m (Either r b)
f = OpaleyeT m (Either r b) -> OpaleyeT r m b
forall (m :: * -> *) e a.
Monad m =>
OpaleyeT m (Either e a) -> OpaleyeT e m a
withError (OpaleyeT m (Either r b) -> OpaleyeT r m b)
-> (Transaction e a -> OpaleyeT m (Either r b))
-> Transaction e a
-> OpaleyeT r m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Transaction (Either e a) -> OpaleyeT m (Either r b)
f (Transaction (Either e a) -> OpaleyeT m (Either r b))
-> (Transaction e a -> Transaction (Either e a))
-> Transaction e a
-> OpaleyeT m (Either r b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT e Transaction a -> Transaction (Either e a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT e Transaction a -> Transaction (Either e a))
-> (Transaction e a -> ExceptT e Transaction a)
-> Transaction e a
-> Transaction (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Transaction e a -> ExceptT e Transaction a
forall e a. Transaction e a -> ExceptT e Transaction a
unTransaction


-- | Run a postgresql transaction in the 'OpaleyeT' monad
transaction :: MonadIO m => Transaction e a -> OpaleyeT e m a
transaction :: Transaction e a -> OpaleyeT e m a
transaction = (Transaction (Either e a) -> OpaleyeT m (Either e a))
-> Transaction e a -> OpaleyeT e m a
forall (m :: * -> *) e a r b.
Monad m =>
(Transaction (Either e a) -> OpaleyeT m (Either r b))
-> Transaction e a -> OpaleyeT r m b
liftError Transaction (Either e a) -> OpaleyeT m (Either e a)
forall (m :: * -> *) a. MonadIO m => Transaction a -> OpaleyeT m a
T.transaction


-- | Execute a query without a literal transaction
run :: MonadIO m => Transaction e a -> OpaleyeT e m a
run :: Transaction e a -> OpaleyeT e m a
run = (Transaction (Either e a) -> OpaleyeT m (Either e a))
-> Transaction e a -> OpaleyeT e m a
forall (m :: * -> *) e a r b.
Monad m =>
(Transaction (Either e a) -> OpaleyeT m (Either r b))
-> Transaction e a -> OpaleyeT r m b
liftError Transaction (Either e a) -> OpaleyeT m (Either e a)
forall (m :: * -> *) a. MonadIO m => Transaction a -> OpaleyeT m a
T.run


withTrans :: T.Transaction a -> Transaction e a
withTrans :: Transaction a -> Transaction e a
withTrans = ExceptT e Transaction a -> Transaction e a
forall e a. ExceptT e Transaction a -> Transaction e a
Transaction (ExceptT e Transaction a -> Transaction e a)
-> (Transaction a -> ExceptT e Transaction a)
-> Transaction a
-> Transaction e a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Transaction a -> ExceptT e Transaction a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift


-- | Execute a 'Query'. See 'runQuery'.
query :: Default QueryRunner a b => Query a -> Transaction e [b]
query :: Query a -> Transaction e [b]
query = Transaction [b] -> Transaction e [b]
forall a e. Transaction a -> Transaction e a
withTrans (Transaction [b] -> Transaction e [b])
-> (Query a -> Transaction [b]) -> Query a -> Transaction e [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Query a -> Transaction [b]
forall a b. Default QueryRunner a b => Query a -> Transaction [b]
T.query


maybeError :: T.Transaction (Maybe b) -> e -> Transaction e b
maybeError :: Transaction (Maybe b) -> e -> Transaction e b
maybeError Transaction (Maybe b)
f e
e = Transaction (Maybe b) -> Transaction e (Maybe b)
forall a e. Transaction a -> Transaction e a
withTrans Transaction (Maybe b)
f Transaction e (Maybe b)
-> (Maybe b -> Transaction e b) -> Transaction e b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Transaction e b
-> (b -> Transaction e b) -> Maybe b -> Transaction e b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (e -> Transaction e b
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError e
e) b -> Transaction e b
forall (m :: * -> *) a. Monad m => a -> m a
return


-- | Retrieve the first result from a 'Query'. Similar to @listToMaybe <$> runQuery@.
queryFirst :: Default QueryRunner a b => e -> Query a -> Transaction e b
queryFirst :: e -> Query a -> Transaction e b
queryFirst e
e Query a
q = Transaction (Maybe b) -> e -> Transaction e b
forall b e. Transaction (Maybe b) -> e -> Transaction e b
maybeError (Query a -> Transaction (Maybe b)
forall a b.
Default QueryRunner a b =>
Query a -> Transaction (Maybe b)
T.queryFirst Query a
q) e
e


-- | Insert into a 'Table'. See 'runInsert'.
insert :: Table w r -> w -> Transaction e Int64
insert :: Table w r -> w -> Transaction e Int64
insert Table w r
t = Transaction Int64 -> Transaction e Int64
forall a e. Transaction a -> Transaction e a
withTrans (Transaction Int64 -> Transaction e Int64)
-> (w -> Transaction Int64) -> w -> Transaction e Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Table w r -> w -> Transaction Int64
forall w r. Table w r -> w -> Transaction Int64
T.insert Table w r
t


-- | Insert many records into a 'Table'. See 'runInsertMany'.
insertMany :: Table w r -> [w] -> Transaction e Int64
insertMany :: Table w r -> [w] -> Transaction e Int64
insertMany Table w r
t = Transaction Int64 -> Transaction e Int64
forall a e. Transaction a -> Transaction e a
withTrans (Transaction Int64 -> Transaction e Int64)
-> ([w] -> Transaction Int64) -> [w] -> Transaction e Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Table w r -> [w] -> Transaction Int64
forall w r. Table w r -> [w] -> Transaction Int64
T.insertMany Table w r
t


-- | Insert a record into a 'Table' with a return value. See 'runInsertReturning'.
insertReturning :: Default QueryRunner a b => Table w r -> (r -> a) -> w -> Transaction e [b]
insertReturning :: Table w r -> (r -> a) -> w -> Transaction e [b]
insertReturning Table w r
t r -> a
ret = Transaction [b] -> Transaction e [b]
forall a e. Transaction a -> Transaction e a
withTrans (Transaction [b] -> Transaction e [b])
-> (w -> Transaction [b]) -> w -> Transaction e [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Table w r -> (r -> a) -> w -> Transaction [b]
forall a b w r.
Default QueryRunner a b =>
Table w r -> (r -> a) -> w -> Transaction [b]
T.insertReturning Table w r
t r -> a
ret


-- | Insert a record into a 'Table' with a return value. Retrieve only the first result.
-- Similar to @'listToMaybe' '<$>' 'insertReturning'@
insertReturningFirst :: Default QueryRunner a b => e -> Table w r -> (r -> a) -> w -> Transaction e b
insertReturningFirst :: e -> Table w r -> (r -> a) -> w -> Transaction e b
insertReturningFirst e
e Table w r
t r -> a
ret w
w = Transaction (Maybe b) -> e -> Transaction e b
forall b e. Transaction (Maybe b) -> e -> Transaction e b
maybeError (Table w r -> (r -> a) -> w -> Transaction (Maybe b)
forall a b w r.
Default QueryRunner a b =>
Table w r -> (r -> a) -> w -> Transaction (Maybe b)
T.insertReturningFirst Table w r
t r -> a
ret w
w) e
e


-- | Insert many records into a 'Table' with a return value for each record.
--
-- Maybe not worth defining. This almost certainly does the wrong thing.
insertManyReturning :: Default QueryRunner a b => Table w r -> [w] -> (r -> a) -> Transaction e [b]
insertManyReturning :: Table w r -> [w] -> (r -> a) -> Transaction e [b]
insertManyReturning Table w r
t [w]
ws = Transaction [b] -> Transaction e [b]
forall a e. Transaction a -> Transaction e a
withTrans (Transaction [b] -> Transaction e [b])
-> ((r -> a) -> Transaction [b]) -> (r -> a) -> Transaction e [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Table w r -> [w] -> (r -> a) -> Transaction [b]
forall a b w r.
Default QueryRunner a b =>
Table w r -> [w] -> (r -> a) -> Transaction [b]
T.insertManyReturning Table w r
t [w]
ws


-- | Update items in a 'Table' where the predicate is true. See 'runUpdate'.
update :: Table w r -> (r -> w) -> (r -> Column PGBool) -> Transaction e Int64
update :: Table w r
-> (r -> w) -> (r -> Column PGBool) -> Transaction e Int64
update Table w r
t r -> w
r2w = Transaction Int64 -> Transaction e Int64
forall a e. Transaction a -> Transaction e a
withTrans (Transaction Int64 -> Transaction e Int64)
-> ((r -> Column PGBool) -> Transaction Int64)
-> (r -> Column PGBool)
-> Transaction e Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Table w r -> (r -> w) -> (r -> Column PGBool) -> Transaction Int64
forall w r.
Table w r -> (r -> w) -> (r -> Column PGBool) -> Transaction Int64
T.update Table w r
t r -> w
r2w


-- | Update items in a 'Table' with a return value. See 'runUpdateReturning'.
updateReturning :: Default QueryRunner a b
                => Table w r
                -> (r -> w)
                -> (r -> Column PGBool)
                -> (r -> a)
                -> Transaction e [b]
updateReturning :: Table w r
-> (r -> w)
-> (r -> Column PGBool)
-> (r -> a)
-> Transaction e [b]
updateReturning Table w r
t r -> w
r2w r -> Column PGBool
p = Transaction [b] -> Transaction e [b]
forall a e. Transaction a -> Transaction e a
withTrans (Transaction [b] -> Transaction e [b])
-> ((r -> a) -> Transaction [b]) -> (r -> a) -> Transaction e [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Table w r
-> (r -> w) -> (r -> Column PGBool) -> (r -> a) -> Transaction [b]
forall a b w r.
Default QueryRunner a b =>
Table w r
-> (r -> w) -> (r -> Column PGBool) -> (r -> a) -> Transaction [b]
T.updateReturning Table w r
t r -> w
r2w r -> Column PGBool
p


-- | Update items in a 'Table' with a return value. Similar to @'listToMaybe' '<$>' 'updateReturning'@.
updateReturningFirst :: Default QueryRunner a b
                     => e
                     -> Table w r
                     -> (r -> w)
                     -> (r -> Column PGBool)
                     -> (r -> a)
                     -> Transaction e b
updateReturningFirst :: e
-> Table w r
-> (r -> w)
-> (r -> Column PGBool)
-> (r -> a)
-> Transaction e b
updateReturningFirst e
e Table w r
t r -> w
r2w r -> Column PGBool
p r -> a
r2r = Transaction (Maybe b) -> e -> Transaction e b
forall b e. Transaction (Maybe b) -> e -> Transaction e b
maybeError (Table w r
-> (r -> w)
-> (r -> Column PGBool)
-> (r -> a)
-> Transaction (Maybe b)
forall a b w r.
Default QueryRunner a b =>
Table w r
-> (r -> w)
-> (r -> Column PGBool)
-> (r -> a)
-> Transaction (Maybe b)
T.updateReturningFirst Table w r
t r -> w
r2w r -> Column PGBool
p r -> a
r2r) e
e


-- | Delete items in a 'Table' that satisfy some boolean predicate. See 'runDelete'.
delete :: Table a b -> (b -> Column PGBool) -> Transaction e Int64
delete :: Table a b -> (b -> Column PGBool) -> Transaction e Int64
delete Table a b
t = Transaction Int64 -> Transaction e Int64
forall a e. Transaction a -> Transaction e a
withTrans (Transaction Int64 -> Transaction e Int64)
-> ((b -> Column PGBool) -> Transaction Int64)
-> (b -> Column PGBool)
-> Transaction e Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Table a b -> (b -> Column PGBool) -> Transaction Int64
forall a b. Table a b -> (b -> Column PGBool) -> Transaction Int64
T.delete Table a b
t