{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

module Database.Bloodhound.Client.Cluster
  ( module ReexportCompat,
    BH (..),
    BHEnv (..),
    MonadBH (..),
    BackendType (..),
    WithBackend,
    WithBackendType,
    StaticBH (..),
    SBackendType (..),
    emptyBody,
    mkBHEnv,
    performBHRequest,
    runBH,
    tryPerformBHRequest,
    unsafePerformBH,
    withDynamicBH,
  )
where

import Control.Monad.Catch
import Control.Monad.Except
import qualified Data.ByteString.Lazy.Char8 as L
import Data.Kind
import qualified Data.Text as T
import Database.Bloodhound.Internal.Client.BHRequest
import Database.Bloodhound.Internal.Utils.Imports
import Database.Bloodhound.Internal.Versions.Common.Types.Bulk as ReexportCompat
import Database.Bloodhound.Internal.Versions.Common.Types.Count as ReexportCompat
import Database.Bloodhound.Internal.Versions.Common.Types.Indices as ReexportCompat
import Database.Bloodhound.Internal.Versions.Common.Types.Nodes as ReexportCompat
import Database.Bloodhound.Internal.Versions.Common.Types.Snapshots as ReexportCompat
import Database.Bloodhound.Internal.Versions.Common.Types.Units as ReexportCompat
import qualified Network.HTTP.Client as HTTP
import qualified Network.URI as URI

-- | Common environment for Elasticsearch calls. Connections will be
--   pipelined according to the provided HTTP connection manager.
data BHEnv = BHEnv
  { BHEnv -> Server
bhServer :: Server,
    BHEnv -> Manager
bhManager :: HTTP.Manager,
    -- | Low-level hook that is run before every request is sent. Used to implement custom authentication strategies. Defaults to 'return' with 'mkBHEnv'.
    BHEnv -> Request -> IO Request
bhRequestHook :: HTTP.Request -> IO HTTP.Request
  }

-- | All API calls to Elasticsearch operate within
--   MonadBH
--   . The idea is that it can be easily embedded in your
--   own monad transformer stack. A default instance for a ReaderT and
--   alias 'BH' is provided for the simple case.
class (Functor m, Applicative m, MonadIO m, MonadCatch m) => MonadBH m where
  type Backend m :: BackendType
  dispatch :: BHRequest contextualized body -> m (BHResponse contextualized body)
  tryEsError :: m a -> m (Either EsError a)
  throwEsError :: EsError -> m a

-- | Backend (i.e. implementation) the queries are ran against
data BackendType
  = ElasticSearch7
  | OpenSearch1
  | OpenSearch2
  | -- | unknown, can be anything
    Dynamic

-- | Best-effort, by-passed for 'Dynamic', statically enforced implementation
type family WithBackendType (expected :: BackendType) (actual :: BackendType) :: Constraint where
  WithBackendType e 'Dynamic = ()
  WithBackendType e a = e ~ a

-- | Helper for 'WithBackendType'
type WithBackend (backend :: BackendType) (m :: Type -> Type) = WithBackendType backend (Backend m)

-- | Create a 'BHEnv' with all optional fields defaulted. HTTP hook
-- will be a noop. You can use the exported fields to customize
-- it further, e.g.:
--
-- >> (mkBHEnv myServer myManager) { bhRequestHook = customHook }
mkBHEnv :: Server -> HTTP.Manager -> BHEnv
mkBHEnv :: Server -> Manager -> BHEnv
mkBHEnv Server
s Manager
m = Server -> Manager -> (Request -> IO Request) -> BHEnv
BHEnv Server
s Manager
m Request -> IO Request
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return

-- | Basic BH implementation
newtype BH m a = BH
  { forall (m :: * -> *) a.
BH m a -> ReaderT BHEnv (ExceptT EsError m) a
unBH :: ReaderT BHEnv (ExceptT EsError m) a
  }
  deriving newtype
    ( (forall a b. (a -> b) -> BH m a -> BH m b)
-> (forall a b. a -> BH m b -> BH m a) -> Functor (BH m)
forall a b. a -> BH m b -> BH m a
forall a b. (a -> b) -> BH m a -> BH m b
forall (m :: * -> *) a b. Functor m => a -> BH m b -> BH m a
forall (m :: * -> *) a b. Functor m => (a -> b) -> BH m a -> BH m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (m :: * -> *) a b. Functor m => (a -> b) -> BH m a -> BH m b
fmap :: forall a b. (a -> b) -> BH m a -> BH m b
$c<$ :: forall (m :: * -> *) a b. Functor m => a -> BH m b -> BH m a
<$ :: forall a b. a -> BH m b -> BH m a
Functor,
      Functor (BH m)
Functor (BH m) =>
(forall a. a -> BH m a)
-> (forall a b. BH m (a -> b) -> BH m a -> BH m b)
-> (forall a b c. (a -> b -> c) -> BH m a -> BH m b -> BH m c)
-> (forall a b. BH m a -> BH m b -> BH m b)
-> (forall a b. BH m a -> BH m b -> BH m a)
-> Applicative (BH m)
forall a. a -> BH m a
forall a b. BH m a -> BH m b -> BH m a
forall a b. BH m a -> BH m b -> BH m b
forall a b. BH m (a -> b) -> BH m a -> BH m b
forall a b c. (a -> b -> c) -> BH m a -> BH m b -> BH m c
forall (m :: * -> *). Monad m => Functor (BH m)
forall (m :: * -> *) a. Monad m => a -> BH m a
forall (m :: * -> *) a b. Monad m => BH m a -> BH m b -> BH m a
forall (m :: * -> *) a b. Monad m => BH m a -> BH m b -> BH m b
forall (m :: * -> *) a b.
Monad m =>
BH m (a -> b) -> BH m a -> BH m b
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> BH m a -> BH m b -> BH 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
$cpure :: forall (m :: * -> *) a. Monad m => a -> BH m a
pure :: forall a. a -> BH m a
$c<*> :: forall (m :: * -> *) a b.
Monad m =>
BH m (a -> b) -> BH m a -> BH m b
<*> :: forall a b. BH m (a -> b) -> BH m a -> BH m b
$cliftA2 :: forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> BH m a -> BH m b -> BH m c
liftA2 :: forall a b c. (a -> b -> c) -> BH m a -> BH m b -> BH m c
$c*> :: forall (m :: * -> *) a b. Monad m => BH m a -> BH m b -> BH m b
*> :: forall a b. BH m a -> BH m b -> BH m b
$c<* :: forall (m :: * -> *) a b. Monad m => BH m a -> BH m b -> BH m a
<* :: forall a b. BH m a -> BH m b -> BH m a
Applicative,
      Applicative (BH m)
Applicative (BH m) =>
(forall a b. BH m a -> (a -> BH m b) -> BH m b)
-> (forall a b. BH m a -> BH m b -> BH m b)
-> (forall a. a -> BH m a)
-> Monad (BH m)
forall a. a -> BH m a
forall a b. BH m a -> BH m b -> BH m b
forall a b. BH m a -> (a -> BH m b) -> BH m b
forall (m :: * -> *). Monad m => Applicative (BH m)
forall (m :: * -> *) a. Monad m => a -> BH m a
forall (m :: * -> *) a b. Monad m => BH m a -> BH m b -> BH m b
forall (m :: * -> *) a b.
Monad m =>
BH m a -> (a -> BH m b) -> BH 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
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
BH m a -> (a -> BH m b) -> BH m b
>>= :: forall a b. BH m a -> (a -> BH m b) -> BH m b
$c>> :: forall (m :: * -> *) a b. Monad m => BH m a -> BH m b -> BH m b
>> :: forall a b. BH m a -> BH m b -> BH m b
$creturn :: forall (m :: * -> *) a. Monad m => a -> BH m a
return :: forall a. a -> BH m a
Monad,
      Monad (BH m)
Monad (BH m) => (forall a. IO a -> BH m a) -> MonadIO (BH m)
forall a. IO a -> BH m a
forall (m :: * -> *).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *). MonadIO m => Monad (BH m)
forall (m :: * -> *) a. MonadIO m => IO a -> BH m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> BH m a
liftIO :: forall a. IO a -> BH m a
MonadIO,
      MonadState s,
      MonadWriter w,
      Applicative (BH m)
Applicative (BH m) =>
(forall a. BH m a)
-> (forall a. BH m a -> BH m a -> BH m a)
-> (forall a. BH m a -> BH m [a])
-> (forall a. BH m a -> BH m [a])
-> Alternative (BH m)
forall a. BH m a
forall a. BH m a -> BH m [a]
forall a. BH m a -> BH m a -> BH m a
forall (m :: * -> *). Monad m => Applicative (BH m)
forall (m :: * -> *) a. Monad m => BH m a
forall (m :: * -> *) a. Monad m => BH m a -> BH m [a]
forall (m :: * -> *) a. Monad m => BH m a -> BH m a -> BH m a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
$cempty :: forall (m :: * -> *) a. Monad m => BH m a
empty :: forall a. BH m a
$c<|> :: forall (m :: * -> *) a. Monad m => BH m a -> BH m a -> BH m a
<|> :: forall a. BH m a -> BH m a -> BH m a
$csome :: forall (m :: * -> *) a. Monad m => BH m a -> BH m [a]
some :: forall a. BH m a -> BH m [a]
$cmany :: forall (m :: * -> *) a. Monad m => BH m a -> BH m [a]
many :: forall a. BH m a -> BH m [a]
Alternative,
      Monad (BH m)
Alternative (BH m)
(Alternative (BH m), Monad (BH m)) =>
(forall a. BH m a)
-> (forall a. BH m a -> BH m a -> BH m a) -> MonadPlus (BH m)
forall a. BH m a
forall a. BH m a -> BH m a -> BH m a
forall (m :: * -> *). Monad m => Monad (BH m)
forall (m :: * -> *). Monad m => Alternative (BH m)
forall (m :: * -> *) a. Monad m => BH m a
forall (m :: * -> *) a. Monad m => BH m a -> BH m a -> BH m a
forall (m :: * -> *).
(Alternative m, Monad m) =>
(forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
$cmzero :: forall (m :: * -> *) a. Monad m => BH m a
mzero :: forall a. BH m a
$cmplus :: forall (m :: * -> *) a. Monad m => BH m a -> BH m a -> BH m a
mplus :: forall a. BH m a -> BH m a -> BH m a
MonadPlus,
      Monad (BH m)
Monad (BH m) =>
(forall a. (a -> BH m a) -> BH m a) -> MonadFix (BH m)
forall a. (a -> BH m a) -> BH m a
forall (m :: * -> *).
Monad m =>
(forall a. (a -> m a) -> m a) -> MonadFix m
forall (m :: * -> *). MonadFix m => Monad (BH m)
forall (m :: * -> *) a. MonadFix m => (a -> BH m a) -> BH m a
$cmfix :: forall (m :: * -> *) a. MonadFix m => (a -> BH m a) -> BH m a
mfix :: forall a. (a -> BH m a) -> BH m a
MonadFix,
      Monad (BH m)
Monad (BH m) =>
(forall e a. (HasCallStack, Exception e) => e -> BH m a)
-> MonadThrow (BH m)
forall e a. (HasCallStack, Exception e) => e -> BH m a
forall (m :: * -> *).
Monad m =>
(forall e a. (HasCallStack, Exception e) => e -> m a)
-> MonadThrow m
forall (m :: * -> *). MonadThrow m => Monad (BH m)
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> BH m a
$cthrowM :: forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> BH m a
throwM :: forall e a. (HasCallStack, Exception e) => e -> BH m a
MonadThrow,
      MonadThrow (BH m)
MonadThrow (BH m) =>
(forall e a.
 (HasCallStack, Exception e) =>
 BH m a -> (e -> BH m a) -> BH m a)
-> MonadCatch (BH m)
forall e a.
(HasCallStack, Exception e) =>
BH m a -> (e -> BH m a) -> BH m a
forall (m :: * -> *). MonadCatch m => MonadThrow (BH m)
forall (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
BH m a -> (e -> BH m a) -> BH m a
forall (m :: * -> *).
MonadThrow m =>
(forall e a.
 (HasCallStack, Exception e) =>
 m a -> (e -> m a) -> m a)
-> MonadCatch m
$ccatch :: forall (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
BH m a -> (e -> BH m a) -> BH m a
catch :: forall e a.
(HasCallStack, Exception e) =>
BH m a -> (e -> BH m a) -> BH m a
MonadCatch,
      Monad (BH m)
Monad (BH m) => (forall a. String -> BH m a) -> MonadFail (BH m)
forall a. String -> BH m a
forall (m :: * -> *).
Monad m =>
(forall a. String -> m a) -> MonadFail m
forall (m :: * -> *). MonadFail m => Monad (BH m)
forall (m :: * -> *) a. MonadFail m => String -> BH m a
$cfail :: forall (m :: * -> *) a. MonadFail m => String -> BH m a
fail :: forall a. String -> BH m a
MonadFail,
      MonadCatch (BH m)
MonadCatch (BH m) =>
(forall b.
 HasCallStack =>
 ((forall a. BH m a -> BH m a) -> BH m b) -> BH m b)
-> (forall b.
    HasCallStack =>
    ((forall a. BH m a -> BH m a) -> BH m b) -> BH m b)
-> (forall a b c.
    HasCallStack =>
    BH m a
    -> (a -> ExitCase b -> BH m c) -> (a -> BH m b) -> BH m (b, c))
-> MonadMask (BH m)
forall b.
HasCallStack =>
((forall a. BH m a -> BH m a) -> BH m b) -> BH m b
forall a b c.
HasCallStack =>
BH m a
-> (a -> ExitCase b -> BH m c) -> (a -> BH m b) -> BH m (b, c)
forall (m :: * -> *). MonadMask m => MonadCatch (BH m)
forall (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. BH m a -> BH m a) -> BH m b) -> BH m b
forall (m :: * -> *) a b c.
(MonadMask m, HasCallStack) =>
BH m a
-> (a -> ExitCase b -> BH m c) -> (a -> BH m b) -> BH m (b, c)
forall (m :: * -> *).
MonadCatch m =>
(forall b. HasCallStack => ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b.
    HasCallStack =>
    ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    HasCallStack =>
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
$cmask :: forall (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. BH m a -> BH m a) -> BH m b) -> BH m b
mask :: forall b.
HasCallStack =>
((forall a. BH m a -> BH m a) -> BH m b) -> BH m b
$cuninterruptibleMask :: forall (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. BH m a -> BH m a) -> BH m b) -> BH m b
uninterruptibleMask :: forall b.
HasCallStack =>
((forall a. BH m a -> BH m a) -> BH m b) -> BH m b
$cgeneralBracket :: forall (m :: * -> *) a b c.
(MonadMask m, HasCallStack) =>
BH m a
-> (a -> ExitCase b -> BH m c) -> (a -> BH m b) -> BH m (b, c)
generalBracket :: forall a b c.
HasCallStack =>
BH m a
-> (a -> ExitCase b -> BH m c) -> (a -> BH m b) -> BH m (b, c)
MonadMask
    )

instance MonadTrans BH where
  lift :: forall (m :: * -> *) a. Monad m => m a -> BH m a
lift = ReaderT BHEnv (ExceptT EsError m) a -> BH m a
forall (m :: * -> *) a.
ReaderT BHEnv (ExceptT EsError m) a -> BH m a
BH (ReaderT BHEnv (ExceptT EsError m) a -> BH m a)
-> (m a -> ReaderT BHEnv (ExceptT EsError m) a) -> m a -> BH m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT EsError m a -> ReaderT BHEnv (ExceptT EsError m) a
forall (m :: * -> *) a. Monad m => m a -> ReaderT BHEnv m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ExceptT EsError m a -> ReaderT BHEnv (ExceptT EsError m) a)
-> (m a -> ExceptT EsError m a)
-> m a
-> ReaderT BHEnv (ExceptT EsError m) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> ExceptT EsError m a
forall (m :: * -> *) a. Monad m => m a -> ExceptT EsError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

instance (MonadReader r m) => MonadReader r (BH m) where
  ask :: BH m r
ask = m r -> BH m r
forall (m :: * -> *) a. Monad m => m a -> BH m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m r
forall r (m :: * -> *). MonadReader r m => m r
ask
  local :: forall a. (r -> r) -> BH m a -> BH m a
local r -> r
f (BH (ReaderT BHEnv -> ExceptT EsError m a
m)) = ReaderT BHEnv (ExceptT EsError m) a -> BH m a
forall (m :: * -> *) a.
ReaderT BHEnv (ExceptT EsError m) a -> BH m a
BH (ReaderT BHEnv (ExceptT EsError m) a -> BH m a)
-> ReaderT BHEnv (ExceptT EsError m) a -> BH m a
forall a b. (a -> b) -> a -> b
$
    (BHEnv -> ExceptT EsError m a)
-> ReaderT BHEnv (ExceptT EsError m) a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((BHEnv -> ExceptT EsError m a)
 -> ReaderT BHEnv (ExceptT EsError m) a)
-> (BHEnv -> ExceptT EsError m a)
-> ReaderT BHEnv (ExceptT EsError m) a
forall a b. (a -> b) -> a -> b
$ \BHEnv
r ->
      (r -> r) -> ExceptT EsError m a -> ExceptT EsError m a
forall a. (r -> r) -> ExceptT EsError m a -> ExceptT EsError m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f (BHEnv -> ExceptT EsError m a
m BHEnv
r)

instance (Functor m, Applicative m, MonadIO m, MonadCatch m, MonadThrow m) => MonadBH (BH m) where
  type Backend (BH m) = 'Dynamic
  dispatch :: forall contextualized body.
BHRequest contextualized body
-> BH m (BHResponse contextualized body)
dispatch BHRequest contextualized body
request = ReaderT BHEnv (ExceptT EsError m) (BHResponse contextualized body)
-> BH m (BHResponse contextualized body)
forall (m :: * -> *) a.
ReaderT BHEnv (ExceptT EsError m) a -> BH m a
BH (ReaderT BHEnv (ExceptT EsError m) (BHResponse contextualized body)
 -> BH m (BHResponse contextualized body))
-> ReaderT
     BHEnv (ExceptT EsError m) (BHResponse contextualized body)
-> BH m (BHResponse contextualized body)
forall a b. (a -> b) -> a -> b
$ do
    BHEnv
env <- forall r (m :: * -> *). MonadReader r m => m r
ask @BHEnv
    let url :: Text
url = Server -> Endpoint -> Text
getEndpoint (BHEnv -> Server
bhServer BHEnv
env) (BHRequest contextualized body -> Endpoint
forall parsingContext responseBody.
BHRequest parsingContext responseBody -> Endpoint
bhRequestEndpoint BHRequest contextualized body
request)
    Request
initReq <- IO Request -> ReaderT BHEnv (ExceptT EsError m) Request
forall a. IO a -> ReaderT BHEnv (ExceptT EsError m) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Request -> ReaderT BHEnv (ExceptT EsError m) Request)
-> IO Request -> ReaderT BHEnv (ExceptT EsError m) Request
forall a b. (a -> b) -> a -> b
$ Text -> IO Request
forall (m :: * -> *). MonadThrow m => Text -> m Request
parseUrl' Text
url
    let reqHook :: Request -> IO Request
reqHook = BHEnv -> Request -> IO Request
bhRequestHook BHEnv
env
    let reqBody :: RequestBody
reqBody = ByteString -> RequestBody
HTTP.RequestBodyLBS (ByteString -> RequestBody) -> ByteString -> RequestBody
forall a b. (a -> b) -> a -> b
$ ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
emptyBody (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ BHRequest contextualized body -> Maybe ByteString
forall parsingContext responseBody.
BHRequest parsingContext responseBody -> Maybe ByteString
bhRequestBody BHRequest contextualized body
request
    Request
req <-
      IO Request -> ReaderT BHEnv (ExceptT EsError m) Request
forall a. IO a -> ReaderT BHEnv (ExceptT EsError m) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Request -> ReaderT BHEnv (ExceptT EsError m) Request)
-> IO Request -> ReaderT BHEnv (ExceptT EsError m) Request
forall a b. (a -> b) -> a -> b
$
        Request -> IO Request
reqHook (Request -> IO Request) -> Request -> IO Request
forall a b. (a -> b) -> a -> b
$
          Request -> Request
HTTP.setRequestIgnoreStatus (Request -> Request) -> Request -> Request
forall a b. (a -> b) -> a -> b
$
            Request
initReq
              { HTTP.method = bhRequestMethod request,
                HTTP.requestHeaders =
                  ("Content-Type", "application/json") : HTTP.requestHeaders initReq,
                HTTP.requestBody = reqBody
              }

    let mgr :: Manager
mgr = BHEnv -> Manager
bhManager BHEnv
env
    Response ByteString -> BHResponse contextualized body
forall parsingContext body.
Response ByteString -> BHResponse parsingContext body
BHResponse (Response ByteString -> BHResponse contextualized body)
-> ReaderT BHEnv (ExceptT EsError m) (Response ByteString)
-> ReaderT
     BHEnv (ExceptT EsError m) (BHResponse contextualized body)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Response ByteString)
-> ReaderT BHEnv (ExceptT EsError m) (Response ByteString)
forall a. IO a -> ReaderT BHEnv (ExceptT EsError m) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Request -> Manager -> IO (Response ByteString)
HTTP.httpLbs Request
req Manager
mgr)
  tryEsError :: forall a. BH m a -> BH m (Either EsError a)
tryEsError = BH m a -> BH m (Either EsError a)
forall (m :: * -> *) e a.
(HasCallStack, MonadCatch m, Exception e) =>
m a -> m (Either e a)
try
  throwEsError :: forall a. EsError -> BH m a
throwEsError = EsError -> BH m a
forall e a. (HasCallStack, Exception e) => e -> BH m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM

tryPerformBHRequest ::
  (MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
  BHRequest contextualized a ->
  m (ParsedEsResponse a)
tryPerformBHRequest :: forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m (ParsedEsResponse a)
tryPerformBHRequest BHRequest contextualized a
req = BHRequest contextualized a -> m (BHResponse contextualized a)
forall contextualized body.
BHRequest contextualized body -> m (BHResponse contextualized body)
forall (m :: * -> *) contextualized body.
MonadBH m =>
BHRequest contextualized body -> m (BHResponse contextualized body)
dispatch BHRequest contextualized a
req m (BHResponse contextualized a)
-> (BHResponse contextualized a -> m (ParsedEsResponse a))
-> m (ParsedEsResponse a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (EsProtocolException -> m (ParsedEsResponse a))
-> (ParsedEsResponse a -> m (ParsedEsResponse a))
-> Either EsProtocolException (ParsedEsResponse a)
-> m (ParsedEsResponse a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either EsProtocolException -> m (ParsedEsResponse a)
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM ParsedEsResponse a -> m (ParsedEsResponse a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either EsProtocolException (ParsedEsResponse a)
 -> m (ParsedEsResponse a))
-> (BHResponse contextualized a
    -> Either EsProtocolException (ParsedEsResponse a))
-> BHResponse contextualized a
-> m (ParsedEsResponse a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BHRequest contextualized a
-> BHResponse contextualized a
-> Either EsProtocolException (ParsedEsResponse a)
forall parsingContext responseBody.
BHRequest parsingContext responseBody
-> BHResponse parsingContext responseBody
-> Either EsProtocolException (ParsedEsResponse responseBody)
bhRequestParser BHRequest contextualized a
req

performBHRequest ::
  (MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
  BHRequest contextualized a ->
  m a
performBHRequest :: forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest BHRequest contextualized a
req = BHRequest contextualized a -> m (ParsedEsResponse a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m (ParsedEsResponse a)
tryPerformBHRequest BHRequest contextualized a
req m (ParsedEsResponse a) -> (ParsedEsResponse a -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (EsError -> m a) -> (a -> m a) -> ParsedEsResponse a -> m a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either EsError -> m a
forall a. EsError -> m a
forall (m :: * -> *) a. MonadBH m => EsError -> m a
throwEsError a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return

emptyBody :: L.ByteString
emptyBody :: ByteString
emptyBody = String -> ByteString
L.pack String
""

parseUrl' :: (MonadThrow m) => Text -> m HTTP.Request
parseUrl' :: forall (m :: * -> *). MonadThrow m => Text -> m Request
parseUrl' Text
t = String -> m Request
forall (m :: * -> *). MonadThrow m => String -> m Request
HTTP.parseRequest ((Char -> Bool) -> String -> String
URI.escapeURIString Char -> Bool
URI.isAllowedInURI (Text -> String
T.unpack Text
t))

runBH :: BHEnv -> BH m a -> m (Either EsError a)
runBH :: forall (m :: * -> *) a. BHEnv -> BH m a -> m (Either EsError a)
runBH BHEnv
e BH m a
f = ExceptT EsError m a -> m (Either EsError a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT EsError m a -> m (Either EsError a))
-> ExceptT EsError m a -> m (Either EsError a)
forall a b. (a -> b) -> a -> b
$ ReaderT BHEnv (ExceptT EsError m) a -> BHEnv -> ExceptT EsError m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (BH m a -> ReaderT BHEnv (ExceptT EsError m) a
forall (m :: * -> *) a.
BH m a -> ReaderT BHEnv (ExceptT EsError m) a
unBH BH m a
f) BHEnv
e

-- | Statically-type backend.
--
-- It's also an useful wrapper for 'DerivingVia'
newtype StaticBH (backend :: BackendType) m a = StaticBH
  {forall (backend :: BackendType) (m :: * -> *) a.
StaticBH backend m a -> m a
runStaticBH :: m a}
  deriving newtype
    ( (forall a b.
 (a -> b) -> StaticBH backend m a -> StaticBH backend m b)
-> (forall a b. a -> StaticBH backend m b -> StaticBH backend m a)
-> Functor (StaticBH backend m)
forall a b. a -> StaticBH backend m b -> StaticBH backend m a
forall a b.
(a -> b) -> StaticBH backend m a -> StaticBH backend m b
forall (backend :: BackendType) (m :: * -> *) a b.
Functor m =>
a -> StaticBH backend m b -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *) a b.
Functor m =>
(a -> b) -> StaticBH backend m a -> StaticBH backend m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (backend :: BackendType) (m :: * -> *) a b.
Functor m =>
(a -> b) -> StaticBH backend m a -> StaticBH backend m b
fmap :: forall a b.
(a -> b) -> StaticBH backend m a -> StaticBH backend m b
$c<$ :: forall (backend :: BackendType) (m :: * -> *) a b.
Functor m =>
a -> StaticBH backend m b -> StaticBH backend m a
<$ :: forall a b. a -> StaticBH backend m b -> StaticBH backend m a
Functor,
      Functor (StaticBH backend m)
Functor (StaticBH backend m) =>
(forall a. a -> StaticBH backend m a)
-> (forall a b.
    StaticBH backend m (a -> b)
    -> StaticBH backend m a -> StaticBH backend m b)
-> (forall a b c.
    (a -> b -> c)
    -> StaticBH backend m a
    -> StaticBH backend m b
    -> StaticBH backend m c)
-> (forall a b.
    StaticBH backend m a
    -> StaticBH backend m b -> StaticBH backend m b)
-> (forall a b.
    StaticBH backend m a
    -> StaticBH backend m b -> StaticBH backend m a)
-> Applicative (StaticBH backend m)
forall a. a -> StaticBH backend m a
forall a b.
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m a
forall a b.
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m b
forall a b.
StaticBH backend m (a -> b)
-> StaticBH backend m a -> StaticBH backend m b
forall a b c.
(a -> b -> c)
-> StaticBH backend m a
-> StaticBH backend m b
-> StaticBH backend m c
forall (backend :: BackendType) (m :: * -> *).
Applicative m =>
Functor (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) a.
Applicative m =>
a -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *) a b.
Applicative m =>
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *) a b.
Applicative m =>
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m b
forall (backend :: BackendType) (m :: * -> *) a b.
Applicative m =>
StaticBH backend m (a -> b)
-> StaticBH backend m a -> StaticBH backend m b
forall (backend :: BackendType) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> StaticBH backend m a
-> StaticBH backend m b
-> StaticBH backend 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
$cpure :: forall (backend :: BackendType) (m :: * -> *) a.
Applicative m =>
a -> StaticBH backend m a
pure :: forall a. a -> StaticBH backend m a
$c<*> :: forall (backend :: BackendType) (m :: * -> *) a b.
Applicative m =>
StaticBH backend m (a -> b)
-> StaticBH backend m a -> StaticBH backend m b
<*> :: forall a b.
StaticBH backend m (a -> b)
-> StaticBH backend m a -> StaticBH backend m b
$cliftA2 :: forall (backend :: BackendType) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> StaticBH backend m a
-> StaticBH backend m b
-> StaticBH backend m c
liftA2 :: forall a b c.
(a -> b -> c)
-> StaticBH backend m a
-> StaticBH backend m b
-> StaticBH backend m c
$c*> :: forall (backend :: BackendType) (m :: * -> *) a b.
Applicative m =>
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m b
*> :: forall a b.
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m b
$c<* :: forall (backend :: BackendType) (m :: * -> *) a b.
Applicative m =>
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m a
<* :: forall a b.
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m a
Applicative,
      Applicative (StaticBH backend m)
Applicative (StaticBH backend m) =>
(forall a b.
 StaticBH backend m a
 -> (a -> StaticBH backend m b) -> StaticBH backend m b)
-> (forall a b.
    StaticBH backend m a
    -> StaticBH backend m b -> StaticBH backend m b)
-> (forall a. a -> StaticBH backend m a)
-> Monad (StaticBH backend m)
forall a. a -> StaticBH backend m a
forall a b.
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m b
forall a b.
StaticBH backend m a
-> (a -> StaticBH backend m b) -> StaticBH backend m b
forall (backend :: BackendType) (m :: * -> *).
Monad m =>
Applicative (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) a.
Monad m =>
a -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *) a b.
Monad m =>
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m b
forall (backend :: BackendType) (m :: * -> *) a b.
Monad m =>
StaticBH backend m a
-> (a -> StaticBH backend m b) -> StaticBH backend 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
$c>>= :: forall (backend :: BackendType) (m :: * -> *) a b.
Monad m =>
StaticBH backend m a
-> (a -> StaticBH backend m b) -> StaticBH backend m b
>>= :: forall a b.
StaticBH backend m a
-> (a -> StaticBH backend m b) -> StaticBH backend m b
$c>> :: forall (backend :: BackendType) (m :: * -> *) a b.
Monad m =>
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m b
>> :: forall a b.
StaticBH backend m a
-> StaticBH backend m b -> StaticBH backend m b
$creturn :: forall (backend :: BackendType) (m :: * -> *) a.
Monad m =>
a -> StaticBH backend m a
return :: forall a. a -> StaticBH backend m a
Monad,
      Monad (StaticBH backend m)
Monad (StaticBH backend m) =>
(forall a. IO a -> StaticBH backend m a)
-> MonadIO (StaticBH backend m)
forall a. IO a -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *).
MonadIO m =>
Monad (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) a.
MonadIO m =>
IO a -> StaticBH backend m a
forall (m :: * -> *).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
$cliftIO :: forall (backend :: BackendType) (m :: * -> *) a.
MonadIO m =>
IO a -> StaticBH backend m a
liftIO :: forall a. IO a -> StaticBH backend m a
MonadIO,
      MonadReader r,
      MonadState s,
      MonadWriter w,
      Applicative (StaticBH backend m)
Applicative (StaticBH backend m) =>
(forall a. StaticBH backend m a)
-> (forall a.
    StaticBH backend m a
    -> StaticBH backend m a -> StaticBH backend m a)
-> (forall a. StaticBH backend m a -> StaticBH backend m [a])
-> (forall a. StaticBH backend m a -> StaticBH backend m [a])
-> Alternative (StaticBH backend m)
forall a. StaticBH backend m a
forall a. StaticBH backend m a -> StaticBH backend m [a]
forall a.
StaticBH backend m a
-> StaticBH backend m a -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *).
Alternative m =>
Applicative (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) a.
Alternative m =>
StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *) a.
Alternative m =>
StaticBH backend m a -> StaticBH backend m [a]
forall (backend :: BackendType) (m :: * -> *) a.
Alternative m =>
StaticBH backend m a
-> StaticBH backend m a -> StaticBH backend m a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
$cempty :: forall (backend :: BackendType) (m :: * -> *) a.
Alternative m =>
StaticBH backend m a
empty :: forall a. StaticBH backend m a
$c<|> :: forall (backend :: BackendType) (m :: * -> *) a.
Alternative m =>
StaticBH backend m a
-> StaticBH backend m a -> StaticBH backend m a
<|> :: forall a.
StaticBH backend m a
-> StaticBH backend m a -> StaticBH backend m a
$csome :: forall (backend :: BackendType) (m :: * -> *) a.
Alternative m =>
StaticBH backend m a -> StaticBH backend m [a]
some :: forall a. StaticBH backend m a -> StaticBH backend m [a]
$cmany :: forall (backend :: BackendType) (m :: * -> *) a.
Alternative m =>
StaticBH backend m a -> StaticBH backend m [a]
many :: forall a. StaticBH backend m a -> StaticBH backend m [a]
Alternative,
      Monad (StaticBH backend m)
Alternative (StaticBH backend m)
(Alternative (StaticBH backend m), Monad (StaticBH backend m)) =>
(forall a. StaticBH backend m a)
-> (forall a.
    StaticBH backend m a
    -> StaticBH backend m a -> StaticBH backend m a)
-> MonadPlus (StaticBH backend m)
forall a. StaticBH backend m a
forall a.
StaticBH backend m a
-> StaticBH backend m a -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *).
MonadPlus m =>
Monad (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *).
MonadPlus m =>
Alternative (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) a.
MonadPlus m =>
StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *) a.
MonadPlus m =>
StaticBH backend m a
-> StaticBH backend m a -> StaticBH backend m a
forall (m :: * -> *).
(Alternative m, Monad m) =>
(forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
$cmzero :: forall (backend :: BackendType) (m :: * -> *) a.
MonadPlus m =>
StaticBH backend m a
mzero :: forall a. StaticBH backend m a
$cmplus :: forall (backend :: BackendType) (m :: * -> *) a.
MonadPlus m =>
StaticBH backend m a
-> StaticBH backend m a -> StaticBH backend m a
mplus :: forall a.
StaticBH backend m a
-> StaticBH backend m a -> StaticBH backend m a
MonadPlus,
      Monad (StaticBH backend m)
Monad (StaticBH backend m) =>
(forall a. (a -> StaticBH backend m a) -> StaticBH backend m a)
-> MonadFix (StaticBH backend m)
forall a. (a -> StaticBH backend m a) -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *).
MonadFix m =>
Monad (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) a.
MonadFix m =>
(a -> StaticBH backend m a) -> StaticBH backend m a
forall (m :: * -> *).
Monad m =>
(forall a. (a -> m a) -> m a) -> MonadFix m
$cmfix :: forall (backend :: BackendType) (m :: * -> *) a.
MonadFix m =>
(a -> StaticBH backend m a) -> StaticBH backend m a
mfix :: forall a. (a -> StaticBH backend m a) -> StaticBH backend m a
MonadFix,
      Monad (StaticBH backend m)
Monad (StaticBH backend m) =>
(forall e a.
 (HasCallStack, Exception e) =>
 e -> StaticBH backend m a)
-> MonadThrow (StaticBH backend m)
forall e a.
(HasCallStack, Exception e) =>
e -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *).
MonadThrow m =>
Monad (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> StaticBH backend m a
forall (m :: * -> *).
Monad m =>
(forall e a. (HasCallStack, Exception e) => e -> m a)
-> MonadThrow m
$cthrowM :: forall (backend :: BackendType) (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> StaticBH backend m a
throwM :: forall e a.
(HasCallStack, Exception e) =>
e -> StaticBH backend m a
MonadThrow,
      MonadThrow (StaticBH backend m)
MonadThrow (StaticBH backend m) =>
(forall e a.
 (HasCallStack, Exception e) =>
 StaticBH backend m a
 -> (e -> StaticBH backend m a) -> StaticBH backend m a)
-> MonadCatch (StaticBH backend m)
forall e a.
(HasCallStack, Exception e) =>
StaticBH backend m a
-> (e -> StaticBH backend m a) -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *).
MonadCatch m =>
MonadThrow (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
StaticBH backend m a
-> (e -> StaticBH backend m a) -> StaticBH backend m a
forall (m :: * -> *).
MonadThrow m =>
(forall e a.
 (HasCallStack, Exception e) =>
 m a -> (e -> m a) -> m a)
-> MonadCatch m
$ccatch :: forall (backend :: BackendType) (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
StaticBH backend m a
-> (e -> StaticBH backend m a) -> StaticBH backend m a
catch :: forall e a.
(HasCallStack, Exception e) =>
StaticBH backend m a
-> (e -> StaticBH backend m a) -> StaticBH backend m a
MonadCatch,
      Monad (StaticBH backend m)
Monad (StaticBH backend m) =>
(forall a. String -> StaticBH backend m a)
-> MonadFail (StaticBH backend m)
forall a. String -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *).
MonadFail m =>
Monad (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) a.
MonadFail m =>
String -> StaticBH backend m a
forall (m :: * -> *).
Monad m =>
(forall a. String -> m a) -> MonadFail m
$cfail :: forall (backend :: BackendType) (m :: * -> *) a.
MonadFail m =>
String -> StaticBH backend m a
fail :: forall a. String -> StaticBH backend m a
MonadFail,
      MonadCatch (StaticBH backend m)
MonadCatch (StaticBH backend m) =>
(forall b.
 HasCallStack =>
 ((forall a. StaticBH backend m a -> StaticBH backend m a)
  -> StaticBH backend m b)
 -> StaticBH backend m b)
-> (forall b.
    HasCallStack =>
    ((forall a. StaticBH backend m a -> StaticBH backend m a)
     -> StaticBH backend m b)
    -> StaticBH backend m b)
-> (forall a b c.
    HasCallStack =>
    StaticBH backend m a
    -> (a -> ExitCase b -> StaticBH backend m c)
    -> (a -> StaticBH backend m b)
    -> StaticBH backend m (b, c))
-> MonadMask (StaticBH backend m)
forall b.
HasCallStack =>
((forall a. StaticBH backend m a -> StaticBH backend m a)
 -> StaticBH backend m b)
-> StaticBH backend m b
forall a b c.
HasCallStack =>
StaticBH backend m a
-> (a -> ExitCase b -> StaticBH backend m c)
-> (a -> StaticBH backend m b)
-> StaticBH backend m (b, c)
forall (backend :: BackendType) (m :: * -> *).
MonadMask m =>
MonadCatch (StaticBH backend m)
forall (backend :: BackendType) (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. StaticBH backend m a -> StaticBH backend m a)
 -> StaticBH backend m b)
-> StaticBH backend m b
forall (backend :: BackendType) (m :: * -> *) a b c.
(MonadMask m, HasCallStack) =>
StaticBH backend m a
-> (a -> ExitCase b -> StaticBH backend m c)
-> (a -> StaticBH backend m b)
-> StaticBH backend m (b, c)
forall (m :: * -> *).
MonadCatch m =>
(forall b. HasCallStack => ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b.
    HasCallStack =>
    ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
    HasCallStack =>
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
$cmask :: forall (backend :: BackendType) (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. StaticBH backend m a -> StaticBH backend m a)
 -> StaticBH backend m b)
-> StaticBH backend m b
mask :: forall b.
HasCallStack =>
((forall a. StaticBH backend m a -> StaticBH backend m a)
 -> StaticBH backend m b)
-> StaticBH backend m b
$cuninterruptibleMask :: forall (backend :: BackendType) (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. StaticBH backend m a -> StaticBH backend m a)
 -> StaticBH backend m b)
-> StaticBH backend m b
uninterruptibleMask :: forall b.
HasCallStack =>
((forall a. StaticBH backend m a -> StaticBH backend m a)
 -> StaticBH backend m b)
-> StaticBH backend m b
$cgeneralBracket :: forall (backend :: BackendType) (m :: * -> *) a b c.
(MonadMask m, HasCallStack) =>
StaticBH backend m a
-> (a -> ExitCase b -> StaticBH backend m c)
-> (a -> StaticBH backend m b)
-> StaticBH backend m (b, c)
generalBracket :: forall a b c.
HasCallStack =>
StaticBH backend m a
-> (a -> ExitCase b -> StaticBH backend m c)
-> (a -> StaticBH backend m b)
-> StaticBH backend m (b, c)
MonadMask
    )

instance MonadTrans (StaticBH backend) where
  lift :: forall (m :: * -> *) a. Monad m => m a -> StaticBH backend m a
lift = m a -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *) a.
m a -> StaticBH backend m a
StaticBH

instance (MonadBH m) => MonadBH (StaticBH backend m) where
  type Backend (StaticBH backend m) = backend
  dispatch :: forall contextualized body.
BHRequest contextualized body
-> StaticBH backend m (BHResponse contextualized body)
dispatch = m (BHResponse contextualized body)
-> StaticBH backend m (BHResponse contextualized body)
forall (backend :: BackendType) (m :: * -> *) a.
m a -> StaticBH backend m a
StaticBH (m (BHResponse contextualized body)
 -> StaticBH backend m (BHResponse contextualized body))
-> (BHRequest contextualized body
    -> m (BHResponse contextualized body))
-> BHRequest contextualized body
-> StaticBH backend m (BHResponse contextualized body)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BHRequest contextualized body -> m (BHResponse contextualized body)
forall contextualized body.
BHRequest contextualized body -> m (BHResponse contextualized body)
forall (m :: * -> *) contextualized body.
MonadBH m =>
BHRequest contextualized body -> m (BHResponse contextualized body)
dispatch
  tryEsError :: forall a.
StaticBH backend m a -> StaticBH backend m (Either EsError a)
tryEsError = m (Either EsError a) -> StaticBH backend m (Either EsError a)
forall (backend :: BackendType) (m :: * -> *) a.
m a -> StaticBH backend m a
StaticBH (m (Either EsError a) -> StaticBH backend m (Either EsError a))
-> (StaticBH backend m a -> m (Either EsError a))
-> StaticBH backend m a
-> StaticBH backend m (Either EsError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> m (Either EsError a)
forall a. m a -> m (Either EsError a)
forall (m :: * -> *) a. MonadBH m => m a -> m (Either EsError a)
tryEsError (m a -> m (Either EsError a))
-> (StaticBH backend m a -> m a)
-> StaticBH backend m a
-> m (Either EsError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StaticBH backend m a -> m a
forall (backend :: BackendType) (m :: * -> *) a.
StaticBH backend m a -> m a
runStaticBH
  throwEsError :: forall a. EsError -> StaticBH backend m a
throwEsError = m a -> StaticBH backend m a
forall (backend :: BackendType) (m :: * -> *) a.
m a -> StaticBH backend m a
StaticBH (m a -> StaticBH backend m a)
-> (EsError -> m a) -> EsError -> StaticBH backend m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EsError -> m a
forall a. EsError -> m a
forall (m :: * -> *) a. MonadBH m => EsError -> m a
throwEsError

-- | Run a piece of code as-if we are on a given backend
unsafePerformBH :: StaticBH backend m a -> m a
unsafePerformBH :: forall (backend :: BackendType) (m :: * -> *) a.
StaticBH backend m a -> m a
unsafePerformBH = StaticBH backend m a -> m a
forall (backend :: BackendType) (m :: * -> *) a.
StaticBH backend m a -> m a
runStaticBH

-- | Dependently-typed version of 'BackendType'
data SBackendType :: BackendType -> Type where
  SElasticSearch7 :: SBackendType 'ElasticSearch7
  SOpenSearch1 :: SBackendType 'OpenSearch1
  SOpenSearch2 :: SBackendType 'OpenSearch2

-- | Run an action given an actual backend
withDynamicBH ::
  (MonadBH m) =>
  BackendType ->
  (forall backend. SBackendType backend -> StaticBH backend m a) ->
  m a
withDynamicBH :: forall (m :: * -> *) a.
MonadBH m =>
BackendType
-> (forall (backend :: BackendType).
    SBackendType backend -> StaticBH backend m a)
-> m a
withDynamicBH BackendType
backend forall (backend :: BackendType).
SBackendType backend -> StaticBH backend m a
f =
  case BackendType
backend of
    BackendType
ElasticSearch7 -> StaticBH 'ElasticSearch7 m a -> m a
forall (backend :: BackendType) (m :: * -> *) a.
StaticBH backend m a -> m a
unsafePerformBH (StaticBH 'ElasticSearch7 m a -> m a)
-> StaticBH 'ElasticSearch7 m a -> m a
forall a b. (a -> b) -> a -> b
$ SBackendType 'ElasticSearch7 -> StaticBH 'ElasticSearch7 m a
forall (backend :: BackendType).
SBackendType backend -> StaticBH backend m a
f SBackendType 'ElasticSearch7
SElasticSearch7
    BackendType
OpenSearch1 -> StaticBH 'OpenSearch1 m a -> m a
forall (backend :: BackendType) (m :: * -> *) a.
StaticBH backend m a -> m a
unsafePerformBH (StaticBH 'OpenSearch1 m a -> m a)
-> StaticBH 'OpenSearch1 m a -> m a
forall a b. (a -> b) -> a -> b
$ SBackendType 'OpenSearch1 -> StaticBH 'OpenSearch1 m a
forall (backend :: BackendType).
SBackendType backend -> StaticBH backend m a
f SBackendType 'OpenSearch1
SOpenSearch1
    BackendType
OpenSearch2 -> StaticBH 'OpenSearch2 m a -> m a
forall (backend :: BackendType) (m :: * -> *) a.
StaticBH backend m a -> m a
unsafePerformBH (StaticBH 'OpenSearch2 m a -> m a)
-> StaticBH 'OpenSearch2 m a -> m a
forall a b. (a -> b) -> a -> b
$ SBackendType 'OpenSearch2 -> StaticBH 'OpenSearch2 m a
forall (backend :: BackendType).
SBackendType backend -> StaticBH backend m a
f SBackendType 'OpenSearch2
SOpenSearch2
    BackendType
Dynamic -> EsError -> m a
forall a. EsError -> m a
forall (m :: * -> *) a. MonadBH m => EsError -> m a
throwEsError (EsError -> m a) -> EsError -> m a
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Text -> EsError
EsError Maybe Int
forall a. Maybe a
Nothing Text
"Cannot perform on a 'Dynamic' backend"