{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# OPTIONS_GHC -Wno-warnings-deprecations #-}

-- |
-- Module : Database.Bloodhound.Client
-- Copyright : (C) 2014, 2018 Chris Allen
-- License : BSD-style (see the file LICENSE)
-- Maintainer : Chris Allen <cma@bitemyapp.com>
-- Stability : provisional
-- Portability : GHC
--
-- Client side functions for talking to Elasticsearch servers.
module Database.Bloodhound.Common.Client
  ( -- * Bloodhound client functions

    -- | The examples in this module assume the following code has been run.
    --   The :{ and :} will only work in GHCi. You'll only need the data types
    --   and typeclass instances for the functions that make use of them.
    -- $setup
    withBH,

    -- ** Indices
    createIndex,
    createIndexWith,
    flushIndex,
    deleteIndex,
    updateIndexSettings,
    getIndexSettings,
    forceMergeIndex,
    indexExists,
    openIndex,
    closeIndex,
    listIndices,
    catIndices,
    waitForYellowIndex,
    Requests.HealthStatus (..),

    -- *** Index Aliases
    updateIndexAliases,
    getIndexAliases,
    deleteIndexAlias,

    -- *** Index Templates
    putTemplate,
    templateExists,
    deleteTemplate,

    -- ** Mapping
    putMapping,

    -- ** Documents
    indexDocument,
    updateDocument,
    updateByQuery,
    Requests.getDocument,
    documentExists,
    deleteDocument,
    deleteByQuery,
    Requests.IndexedDocument (..),
    Requests.DeletedDocuments (..),
    Requests.DeletedDocumentsRetries (..),

    -- ** Searching
    searchAll,
    searchByIndex,
    searchByIndices,
    searchByIndexTemplate,
    searchByIndicesTemplate,
    scanSearch,
    getInitialScroll,
    getInitialSortedScroll,
    advanceScroll,
    refreshIndex,
    Requests.mkSearch,
    Requests.mkAggregateSearch,
    Requests.mkHighlightSearch,
    Requests.mkSearchTemplate,
    bulk,
    Requests.pageSearch,
    Requests.mkShardCount,
    Requests.mkReplicaCount,
    getStatus,

    -- ** Templates
    storeSearchTemplate,
    getSearchTemplate,
    deleteSearchTemplate,

    -- ** Snapshot/Restore

    -- *** Snapshot Repos
    getSnapshotRepos,
    updateSnapshotRepo,
    verifySnapshotRepo,
    deleteSnapshotRepo,

    -- *** Snapshots
    createSnapshot,
    getSnapshots,
    deleteSnapshot,

    -- *** Restoring Snapshots
    restoreSnapshot,

    -- *** Reindex
    reindex,
    reindexAsync,

    -- *** Task
    getTask,

    -- ** Nodes
    getNodesInfo,
    getNodesStats,

    -- ** Request Utilities
    Requests.encodeBulkOperations,
    Requests.encodeBulkOperation,

    -- * Authentication
    basicAuthHook,

    -- * Count
    countByIndex,

    -- * Generic
    Acknowledged (..),
    Accepted (..),
    IgnoredBody (..),
  )
where

import Control.Monad
import Control.Monad.Catch
import Data.Aeson
import Data.List.NonEmpty (NonEmpty (..))
import qualified Data.Text.Encoding as T
import Data.Time.Clock
import qualified Data.Vector as V
import Database.Bloodhound.Client.Cluster
import qualified Database.Bloodhound.Common.Requests as Requests
import Database.Bloodhound.Common.Types
import Network.HTTP.Client hiding (Proxy)
import Prelude hiding (filter, head)

-- $setup
-- >>> :set -XOverloadedStrings
-- >>> :set -XDeriveGeneric
-- >>> import Database.Bloodhound
-- >>> import Network.HTTP.Client
-- >>> let testServer = (Server "http://localhost:9200")
-- >>> let runBH' = withBH defaultManagerSettings testServer
-- >>> let testIndex = IndexName "twitter"
-- >>> let defaultIndexSettings = IndexSettings (ShardCount 1) (ReplicaCount 0)
-- >>> data TweetMapping = TweetMapping deriving stock (Eq, Show)
-- >>> _ <- runBH' $ deleteIndex testIndex
-- >>> _ <- runBH' $ deleteIndex (IndexName "didimakeanindex")
-- >>> import GHC.Generics
-- >>> import           Data.Time.Calendar        (Day (..))
-- >>> import Data.Time.Clock (UTCTime (..), secondsToDiffTime)
-- >>> :{
-- instance ToJSON TweetMapping where
--          toJSON TweetMapping =
--            object ["properties" .=
--              object ["location" .=
--                object ["type" .= ("geo_point" :: Text)]]]
-- data Location = Location { lat :: Double
--                         , lon :: Double } deriving stock (Eq, Generic, Show)
-- data Tweet = Tweet { user     :: Text
--                    , postDate :: UTCTime
--                    , message  :: Text
--                    , age      :: Int
--                    , location :: Location } deriving stock (Eq, Generic, Show)
-- exampleTweet = Tweet { user     = "bitemyapp"
--                      , postDate = UTCTime
--                                   (ModifiedJulianDay 55000)
--                                   (secondsToDiffTime 10)
--                      , message  = "Use haskell!"
--                      , age      = 10000
--                      , location = Location 40.12 (-71.34) }
-- instance ToJSON   Tweet where
--  toJSON = genericToJSON defaultOptions
-- instance FromJSON Tweet where
--  parseJSON = genericParseJSON defaultOptions
-- instance ToJSON   Location where
--  toJSON = genericToJSON defaultOptions
-- instance FromJSON Location where
--  parseJSON = genericParseJSON defaultOptions
-- data BulkTest = BulkTest { name :: Text } deriving stock (Eq, Generic, Show)
-- instance FromJSON BulkTest where
--  parseJSON = genericParseJSON defaultOptions
-- instance ToJSON BulkTest where
--  toJSON = genericToJSON defaultOptions
-- :}

-- | Convenience function that sets up a manager and BHEnv and runs
-- the given set of bloodhound operations. Connections will be
-- pipelined automatically in accordance with the given manager
-- settings in IO. If you've got your own monad transformer stack, you
-- should use 'runBH' directly.
withBH :: ManagerSettings -> Server -> BH IO a -> IO a
withBH :: forall a. ManagerSettings -> Server -> BH IO a -> IO a
withBH ManagerSettings
ms Server
s BH IO a
f = do
  Manager
mgr <- ManagerSettings -> IO Manager
newManager ManagerSettings
ms
  let env :: BHEnv
env = Server -> Manager -> BHEnv
mkBHEnv Server
s Manager
mgr
  BHEnv -> BH IO a -> IO (Either EsError a)
forall (m :: * -> *) a. BHEnv -> BH m a -> m (Either EsError a)
runBH BHEnv
env BH IO a
f IO (Either EsError a) -> (Either EsError a -> IO a) -> IO a
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (EsError -> IO a) -> (a -> IO a) -> Either EsError a -> IO a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either EsError -> IO a
forall e a. (HasCallStack, Exception e) => e -> IO a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM a -> IO a
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return

-- | 'getStatus' fetches the 'Status' of a 'Server'
--
-- >>> serverStatus <- runBH' getStatus
-- >>> fmap tagline (serverStatus)
-- Just "You Know, for Search"
getStatus :: (MonadBH m) => m Status
getStatus :: forall (m :: * -> *). MonadBH m => m Status
getStatus = BHRequest StatusDependant Status -> m Status
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant Status -> m Status)
-> BHRequest StatusDependant Status -> m Status
forall a b. (a -> b) -> a -> b
$ BHRequest StatusDependant Status
Requests.getStatus

-- | 'getSnapshotRepos' gets the definitions of a subset of the
-- defined snapshot repos.
getSnapshotRepos :: (MonadBH m) => SnapshotRepoSelection -> m [GenericSnapshotRepo]
getSnapshotRepos :: forall (m :: * -> *).
MonadBH m =>
SnapshotRepoSelection -> m [GenericSnapshotRepo]
getSnapshotRepos SnapshotRepoSelection
sel = BHRequest StatusDependant [GenericSnapshotRepo]
-> m [GenericSnapshotRepo]
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant [GenericSnapshotRepo]
 -> m [GenericSnapshotRepo])
-> BHRequest StatusDependant [GenericSnapshotRepo]
-> m [GenericSnapshotRepo]
forall a b. (a -> b) -> a -> b
$ SnapshotRepoSelection
-> BHRequest StatusDependant [GenericSnapshotRepo]
Requests.getSnapshotRepos SnapshotRepoSelection
sel

-- | Create or update a snapshot repo
updateSnapshotRepo ::
  (MonadBH m) =>
  (SnapshotRepo repo) =>
  -- | Use 'defaultSnapshotRepoUpdateSettings' if unsure
  SnapshotRepoUpdateSettings ->
  repo ->
  m Acknowledged
updateSnapshotRepo :: forall (m :: * -> *) repo.
(MonadBH m, SnapshotRepo repo) =>
SnapshotRepoUpdateSettings -> repo -> m Acknowledged
updateSnapshotRepo SnapshotRepoUpdateSettings
settings repo
repo = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ SnapshotRepoUpdateSettings
-> repo -> BHRequest StatusIndependant Acknowledged
forall repo.
SnapshotRepo repo =>
SnapshotRepoUpdateSettings
-> repo -> BHRequest StatusIndependant Acknowledged
Requests.updateSnapshotRepo SnapshotRepoUpdateSettings
settings repo
repo

-- | Verify if a snapshot repo is working. __NOTE:__ this API did not
-- make it into Elasticsearch until 1.4. If you use an older version,
-- you will get an error here.
verifySnapshotRepo :: (MonadBH m) => SnapshotRepoName -> m SnapshotVerification
verifySnapshotRepo :: forall (m :: * -> *).
MonadBH m =>
SnapshotRepoName -> m SnapshotVerification
verifySnapshotRepo SnapshotRepoName
repoName = BHRequest StatusDependant SnapshotVerification
-> m SnapshotVerification
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant SnapshotVerification
 -> m SnapshotVerification)
-> BHRequest StatusDependant SnapshotVerification
-> m SnapshotVerification
forall a b. (a -> b) -> a -> b
$ SnapshotRepoName -> BHRequest StatusDependant SnapshotVerification
Requests.verifySnapshotRepo SnapshotRepoName
repoName

deleteSnapshotRepo :: (MonadBH m) => SnapshotRepoName -> m Acknowledged
deleteSnapshotRepo :: forall (m :: * -> *).
MonadBH m =>
SnapshotRepoName -> m Acknowledged
deleteSnapshotRepo SnapshotRepoName
repoName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ SnapshotRepoName -> BHRequest StatusIndependant Acknowledged
Requests.deleteSnapshotRepo SnapshotRepoName
repoName

-- | Create and start a snapshot
createSnapshot ::
  (MonadBH m) =>
  SnapshotRepoName ->
  SnapshotName ->
  SnapshotCreateSettings ->
  m Acknowledged
createSnapshot :: forall (m :: * -> *).
MonadBH m =>
SnapshotRepoName
-> SnapshotName -> SnapshotCreateSettings -> m Acknowledged
createSnapshot SnapshotRepoName
repoName SnapshotName
snapName SnapshotCreateSettings
settings = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ SnapshotRepoName
-> SnapshotName
-> SnapshotCreateSettings
-> BHRequest StatusIndependant Acknowledged
Requests.createSnapshot SnapshotRepoName
repoName SnapshotName
snapName SnapshotCreateSettings
settings

-- | Get info about known snapshots given a pattern and repo name.
getSnapshots :: (MonadBH m) => SnapshotRepoName -> SnapshotSelection -> m [SnapshotInfo]
getSnapshots :: forall (m :: * -> *).
MonadBH m =>
SnapshotRepoName -> SnapshotSelection -> m [SnapshotInfo]
getSnapshots SnapshotRepoName
repoName SnapshotSelection
sel = BHRequest StatusDependant [SnapshotInfo] -> m [SnapshotInfo]
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant [SnapshotInfo] -> m [SnapshotInfo])
-> BHRequest StatusDependant [SnapshotInfo] -> m [SnapshotInfo]
forall a b. (a -> b) -> a -> b
$ SnapshotRepoName
-> SnapshotSelection -> BHRequest StatusDependant [SnapshotInfo]
Requests.getSnapshots SnapshotRepoName
repoName SnapshotSelection
sel

-- | Delete a snapshot. Cancels if it is running.
deleteSnapshot :: (MonadBH m) => SnapshotRepoName -> SnapshotName -> m Acknowledged
deleteSnapshot :: forall (m :: * -> *).
MonadBH m =>
SnapshotRepoName -> SnapshotName -> m Acknowledged
deleteSnapshot SnapshotRepoName
repoName SnapshotName
snapName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ SnapshotRepoName
-> SnapshotName -> BHRequest StatusIndependant Acknowledged
Requests.deleteSnapshot SnapshotRepoName
repoName SnapshotName
snapName

-- | Restore a snapshot to the cluster See
-- <https://www.elastic.co/guide/en/elasticsearch/reference/1.7/modules-snapshots.html#_restore>
-- for more details.
restoreSnapshot ::
  (MonadBH m) =>
  SnapshotRepoName ->
  SnapshotName ->
  -- | Start with 'defaultSnapshotRestoreSettings' and customize
  -- from there for reasonable defaults.
  SnapshotRestoreSettings ->
  m Accepted
restoreSnapshot :: forall (m :: * -> *).
MonadBH m =>
SnapshotRepoName
-> SnapshotName -> SnapshotRestoreSettings -> m Accepted
restoreSnapshot SnapshotRepoName
repoName SnapshotName
snapName SnapshotRestoreSettings
settings = BHRequest StatusIndependant Accepted -> m Accepted
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Accepted -> m Accepted)
-> BHRequest StatusIndependant Accepted -> m Accepted
forall a b. (a -> b) -> a -> b
$ SnapshotRepoName
-> SnapshotName
-> SnapshotRestoreSettings
-> BHRequest StatusIndependant Accepted
Requests.restoreSnapshot SnapshotRepoName
repoName SnapshotName
snapName SnapshotRestoreSettings
settings

getNodesInfo :: (MonadBH m) => NodeSelection -> m NodesInfo
getNodesInfo :: forall (m :: * -> *). MonadBH m => NodeSelection -> m NodesInfo
getNodesInfo NodeSelection
sel = BHRequest StatusDependant NodesInfo -> m NodesInfo
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant NodesInfo -> m NodesInfo)
-> BHRequest StatusDependant NodesInfo -> m NodesInfo
forall a b. (a -> b) -> a -> b
$ NodeSelection -> BHRequest StatusDependant NodesInfo
Requests.getNodesInfo NodeSelection
sel

getNodesStats :: (MonadBH m) => NodeSelection -> m NodesStats
getNodesStats :: forall (m :: * -> *). MonadBH m => NodeSelection -> m NodesStats
getNodesStats NodeSelection
sel = BHRequest StatusDependant NodesStats -> m NodesStats
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant NodesStats -> m NodesStats)
-> BHRequest StatusDependant NodesStats -> m NodesStats
forall a b. (a -> b) -> a -> b
$ NodeSelection -> BHRequest StatusDependant NodesStats
Requests.getNodesStats NodeSelection
sel

-- | 'createIndex' will create an index given a 'Server', 'IndexSettings', and an 'IndexName'.
--
-- >>> response <- runBH' $ createIndex defaultIndexSettings (IndexName "didimakeanindex")
-- >>> isSuccess response
-- True
-- >>> runBH' $ indexExists (IndexName "didimakeanindex")
-- True
createIndex :: (MonadBH m) => IndexSettings -> IndexName -> m Acknowledged
createIndex :: forall (m :: * -> *).
MonadBH m =>
IndexSettings -> IndexName -> m Acknowledged
createIndex IndexSettings
indexSettings IndexName
indexName = BHRequest StatusDependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant Acknowledged -> m Acknowledged)
-> BHRequest StatusDependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ IndexSettings
-> IndexName -> BHRequest StatusDependant Acknowledged
Requests.createIndex IndexSettings
indexSettings IndexName
indexName

-- | Create an index, providing it with any number of settings. This
--  is more expressive than 'createIndex' but makes is more verbose
--  for the common case of configuring only the shard count and
--  replica count.
createIndexWith ::
  (MonadBH m) =>
  [UpdatableIndexSetting] ->
  -- | shard count
  Int ->
  IndexName ->
  m Acknowledged
createIndexWith :: forall (m :: * -> *).
MonadBH m =>
[UpdatableIndexSetting] -> Int -> IndexName -> m Acknowledged
createIndexWith [UpdatableIndexSetting]
updates Int
shards IndexName
indexName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ [UpdatableIndexSetting]
-> Int -> IndexName -> BHRequest StatusIndependant Acknowledged
Requests.createIndexWith [UpdatableIndexSetting]
updates Int
shards IndexName
indexName

-- | 'flushIndex' will flush an index given a 'Server' and an 'IndexName'.
flushIndex :: (MonadBH m) => IndexName -> m ShardResult
flushIndex :: forall (m :: * -> *). MonadBH m => IndexName -> m ShardResult
flushIndex IndexName
indexName = BHRequest StatusDependant ShardResult -> m ShardResult
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant ShardResult -> m ShardResult)
-> BHRequest StatusDependant ShardResult -> m ShardResult
forall a b. (a -> b) -> a -> b
$ IndexName -> BHRequest StatusDependant ShardResult
Requests.flushIndex IndexName
indexName

-- | 'deleteIndex' will delete an index given a 'Server' and an 'IndexName'.
--
-- >>> _ <- runBH' $ createIndex defaultIndexSettings (IndexName "didimakeanindex")
-- >>> response <- runBH' $ deleteIndex (IndexName "didimakeanindex")
-- >>> isSuccess response
-- True
-- >>> runBH' $ indexExists (IndexName "didimakeanindex")
-- False
deleteIndex :: (MonadBH m) => IndexName -> m Acknowledged
deleteIndex :: forall (m :: * -> *). MonadBH m => IndexName -> m Acknowledged
deleteIndex IndexName
indexName = BHRequest StatusDependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant Acknowledged -> m Acknowledged)
-> BHRequest StatusDependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ IndexName -> BHRequest StatusDependant Acknowledged
Requests.deleteIndex IndexName
indexName

-- | 'updateIndexSettings' will apply a non-empty list of setting updates to an index
--
-- >>> _ <- runBH' $ createIndex defaultIndexSettings (IndexName "unconfiguredindex")
-- >>> response <- runBH' $ updateIndexSettings (BlocksWrite False :| []) (IndexName "unconfiguredindex")
-- >>> isSuccess response
-- True
updateIndexSettings ::
  (MonadBH m) =>
  NonEmpty UpdatableIndexSetting ->
  IndexName ->
  m Acknowledged
updateIndexSettings :: forall (m :: * -> *).
MonadBH m =>
NonEmpty UpdatableIndexSetting -> IndexName -> m Acknowledged
updateIndexSettings NonEmpty UpdatableIndexSetting
updates IndexName
indexName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ NonEmpty UpdatableIndexSetting
-> IndexName -> BHRequest StatusIndependant Acknowledged
Requests.updateIndexSettings NonEmpty UpdatableIndexSetting
updates IndexName
indexName

getIndexSettings :: (MonadBH m) => IndexName -> m IndexSettingsSummary
getIndexSettings :: forall (m :: * -> *).
MonadBH m =>
IndexName -> m IndexSettingsSummary
getIndexSettings IndexName
indexName = BHRequest StatusDependant IndexSettingsSummary
-> m IndexSettingsSummary
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant IndexSettingsSummary
 -> m IndexSettingsSummary)
-> BHRequest StatusDependant IndexSettingsSummary
-> m IndexSettingsSummary
forall a b. (a -> b) -> a -> b
$ IndexName -> BHRequest StatusDependant IndexSettingsSummary
Requests.getIndexSettings IndexName
indexName

-- | 'forceMergeIndex'
--
-- The force merge API allows to force merging of one or more indices through
-- an API. The merge relates to the number of segments a Lucene index holds
-- within each shard. The force merge operation allows to reduce the number of
-- segments by merging them.
--
-- This call will block until the merge is complete. If the http connection is
-- lost, the request will continue in the background, and any new requests will
-- block until the previous force merge is complete.

-- For more information see
-- <https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-forcemerge.html#indices-forcemerge>.
-- Nothing
-- worthwhile comes back in the response body, so matching on the status
-- should suffice.
--
-- 'forceMergeIndex' with a maxNumSegments of 1 and onlyExpungeDeletes
-- to True is the main way to release disk space back to the OS being
-- held by deleted documents.
--
-- >>> let ixn = IndexName "unoptimizedindex"
-- >>> _ <- runBH' $ deleteIndex ixn >> createIndex defaultIndexSettings ixn
-- >>> response <- runBH' $ forceMergeIndex (IndexList (ixn :| [])) (defaultIndexOptimizationSettings { maxNumSegments = Just 1, onlyExpungeDeletes = True })
-- >>> isSuccess response
-- True
forceMergeIndex :: (MonadBH m) => IndexSelection -> ForceMergeIndexSettings -> m ShardsResult
forceMergeIndex :: forall (m :: * -> *).
MonadBH m =>
IndexSelection -> ForceMergeIndexSettings -> m ShardsResult
forceMergeIndex IndexSelection
ixs ForceMergeIndexSettings
settings = BHRequest StatusDependant ShardsResult -> m ShardsResult
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant ShardsResult -> m ShardsResult)
-> BHRequest StatusDependant ShardsResult -> m ShardsResult
forall a b. (a -> b) -> a -> b
$ IndexSelection
-> ForceMergeIndexSettings
-> BHRequest StatusDependant ShardsResult
Requests.forceMergeIndex IndexSelection
ixs ForceMergeIndexSettings
settings

-- | 'indexExists' enables you to check if an index exists. Returns 'Bool'
--  in IO
--
-- >>> exists <- runBH' $ indexExists testIndex
indexExists :: (MonadBH m) => IndexName -> m Bool
indexExists :: forall (m :: * -> *). MonadBH m => IndexName -> m Bool
indexExists IndexName
indexName = BHRequest StatusDependant Bool -> m Bool
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant Bool -> m Bool)
-> BHRequest StatusDependant Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ IndexName -> BHRequest StatusDependant Bool
Requests.indexExists IndexName
indexName

-- | 'refreshIndex' will force a refresh on an index. You must
-- do this if you want to read what you wrote.
--
-- >>> _ <- runBH' $ createIndex defaultIndexSettings testIndex
-- >>> _ <- runBH' $ refreshIndex testIndex
refreshIndex :: (MonadBH m) => IndexName -> m ShardResult
refreshIndex :: forall (m :: * -> *). MonadBH m => IndexName -> m ShardResult
refreshIndex IndexName
indexName = BHRequest StatusDependant ShardResult -> m ShardResult
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant ShardResult -> m ShardResult)
-> BHRequest StatusDependant ShardResult -> m ShardResult
forall a b. (a -> b) -> a -> b
$ IndexName -> BHRequest StatusDependant ShardResult
Requests.refreshIndex IndexName
indexName

-- | Block until the index becomes available for indexing
--  documents. This is useful for integration tests in which
--  indices are rapidly created and deleted.
waitForYellowIndex :: (MonadBH m) => IndexName -> m Requests.HealthStatus
waitForYellowIndex :: forall (m :: * -> *). MonadBH m => IndexName -> m HealthStatus
waitForYellowIndex IndexName
indexName = BHRequest StatusIndependant HealthStatus -> m HealthStatus
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant HealthStatus -> m HealthStatus)
-> BHRequest StatusIndependant HealthStatus -> m HealthStatus
forall a b. (a -> b) -> a -> b
$ IndexName -> BHRequest StatusIndependant HealthStatus
Requests.waitForYellowIndex IndexName
indexName

-- | 'openIndex' opens an index given a 'Server' and an 'IndexName'. Explained in further detail at
--  <http://www.elastic.co/guide/en/elasticsearch/reference/current/indices-open-close.html>
--
-- >>> response <- runBH' $ openIndex testIndex
openIndex :: (MonadBH m) => IndexName -> m Acknowledged
openIndex :: forall (m :: * -> *). MonadBH m => IndexName -> m Acknowledged
openIndex IndexName
indexName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ IndexName -> BHRequest StatusIndependant Acknowledged
Requests.openIndex IndexName
indexName

-- | 'closeIndex' closes an index given a 'Server' and an 'IndexName'. Explained in further detail at
--  <http://www.elastic.co/guide/en/elasticsearch/reference/current/indices-open-close.html>
--
-- >>> response <- runBH' $ closeIndex testIndex
closeIndex :: (MonadBH m) => IndexName -> m Acknowledged
closeIndex :: forall (m :: * -> *). MonadBH m => IndexName -> m Acknowledged
closeIndex IndexName
indexName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ IndexName -> BHRequest StatusIndependant Acknowledged
Requests.closeIndex IndexName
indexName

-- | 'listIndices' returns a list of all index names on a given 'Server'
listIndices :: (MonadBH m) => m [IndexName]
listIndices :: forall (m :: * -> *). MonadBH m => m [IndexName]
listIndices = BHRequest StatusDependant [IndexName] -> m [IndexName]
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant [IndexName] -> m [IndexName])
-> BHRequest StatusDependant [IndexName] -> m [IndexName]
forall a b. (a -> b) -> a -> b
$ BHRequest StatusDependant [IndexName]
Requests.listIndices

-- | 'catIndices' returns a list of all index names on a given 'Server' as well as their doc counts
catIndices :: (MonadBH m) => m [(IndexName, Int)]
catIndices :: forall (m :: * -> *). MonadBH m => m [(IndexName, Int)]
catIndices = BHRequest StatusDependant [(IndexName, Int)]
-> m [(IndexName, Int)]
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant [(IndexName, Int)]
 -> m [(IndexName, Int)])
-> BHRequest StatusDependant [(IndexName, Int)]
-> m [(IndexName, Int)]
forall a b. (a -> b) -> a -> b
$ BHRequest StatusDependant [(IndexName, Int)]
Requests.catIndices

-- | 'updateIndexAliases' updates the server's index alias
-- table. Operations are atomic. Explained in further detail at
-- <https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-aliases.html>
--
-- >>> let src = IndexName "a-real-index"
-- >>> let aliasName = IndexName "an-alias"
-- >>> let iAlias = IndexAlias src (IndexAliasName aliasName)
-- >>> let aliasCreate = IndexAliasCreate Nothing Nothing
-- >>> _ <- runBH' $ deleteIndex src
-- >>> isSuccess <$> runBH' (createIndex defaultIndexSettings src)
-- True
-- >>> runBH' $ indexExists src
-- True
-- >>> isSuccess <$> runBH' (updateIndexAliases (AddAlias iAlias aliasCreate :| []))
-- True
-- >>> runBH' $ indexExists aliasName
-- True
updateIndexAliases :: (MonadBH m) => NonEmpty IndexAliasAction -> m Acknowledged
updateIndexAliases :: forall (m :: * -> *).
MonadBH m =>
NonEmpty IndexAliasAction -> m Acknowledged
updateIndexAliases NonEmpty IndexAliasAction
actions = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ NonEmpty IndexAliasAction
-> BHRequest StatusIndependant Acknowledged
Requests.updateIndexAliases NonEmpty IndexAliasAction
actions

-- | Get all aliases configured on the server.
getIndexAliases :: (MonadBH m) => m IndexAliasesSummary
getIndexAliases :: forall (m :: * -> *). MonadBH m => m IndexAliasesSummary
getIndexAliases = BHRequest StatusDependant IndexAliasesSummary
-> m IndexAliasesSummary
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant IndexAliasesSummary
 -> m IndexAliasesSummary)
-> BHRequest StatusDependant IndexAliasesSummary
-> m IndexAliasesSummary
forall a b. (a -> b) -> a -> b
$ BHRequest StatusDependant IndexAliasesSummary
Requests.getIndexAliases

-- | Delete a single alias, removing it from all indices it
--  is currently associated with.
deleteIndexAlias :: (MonadBH m) => IndexAliasName -> m Acknowledged
deleteIndexAlias :: forall (m :: * -> *). MonadBH m => IndexAliasName -> m Acknowledged
deleteIndexAlias IndexAliasName
indexAliasName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ IndexAliasName -> BHRequest StatusIndependant Acknowledged
Requests.deleteIndexAlias IndexAliasName
indexAliasName

-- | 'putTemplate' creates a template given an 'IndexTemplate' and a 'TemplateName'.
--  Explained in further detail at
--  <https://www.elastic.co/guide/en/elasticsearch/reference/1.7/indices-templates.html>
--
--  >>> let idxTpl = IndexTemplate [IndexPattern "tweet-*"] (Just (IndexSettings (ShardCount 1) (ReplicaCount 1))) [toJSON TweetMapping]
--  >>> resp <- runBH' $ putTemplate idxTpl (TemplateName "tweet-tpl")
putTemplate :: (MonadBH m) => IndexTemplate -> TemplateName -> m Acknowledged
putTemplate :: forall (m :: * -> *).
MonadBH m =>
IndexTemplate -> TemplateName -> m Acknowledged
putTemplate IndexTemplate
indexTemplate TemplateName
templateName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ IndexTemplate
-> TemplateName -> BHRequest StatusIndependant Acknowledged
Requests.putTemplate IndexTemplate
indexTemplate TemplateName
templateName

-- | 'templateExists' checks to see if a template exists.
--
--  >>> exists <- runBH' $ templateExists (TemplateName "tweet-tpl")
templateExists :: (MonadBH m) => TemplateName -> m Bool
templateExists :: forall (m :: * -> *). MonadBH m => TemplateName -> m Bool
templateExists TemplateName
templateName = BHRequest StatusDependant Bool -> m Bool
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant Bool -> m Bool)
-> BHRequest StatusDependant Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ TemplateName -> BHRequest StatusDependant Bool
Requests.templateExists TemplateName
templateName

-- | 'deleteTemplate' is an HTTP DELETE and deletes a template.
--
--  >>> let idxTpl = IndexTemplate [IndexPattern "tweet-*"] (Just (IndexSettings (ShardCount 1) (ReplicaCount 1))) [toJSON TweetMapping]
--  >>> _ <- runBH' $ putTemplate idxTpl (TemplateName "tweet-tpl")
--  >>> resp <- runBH' $ deleteTemplate (TemplateName "tweet-tpl")
deleteTemplate :: (MonadBH m) => TemplateName -> m Acknowledged
deleteTemplate :: forall (m :: * -> *). MonadBH m => TemplateName -> m Acknowledged
deleteTemplate TemplateName
templateName = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ TemplateName -> BHRequest StatusIndependant Acknowledged
Requests.deleteTemplate TemplateName
templateName

-- | 'putMapping' is an HTTP PUT and has upsert semantics. Mappings are schemas
-- for documents in indexes.
--
-- >>> _ <- runBH' $ createIndex defaultIndexSettings testIndex
-- >>> resp <- runBH' $ putMapping testIndex TweetMapping
-- >>> print resp
-- Response {responseStatus = Status {statusCode = 200, statusMessage = "OK"}, responseVersion = HTTP/1.1, responseHeaders = [("content-type","application/json; charset=UTF-8"),("content-encoding","gzip"),("transfer-encoding","chunked")], responseBody = "{\"acknowledged\":true}", responseCookieJar = CJ {expose = []}, responseClose' = ResponseClose}
putMapping :: forall r a m. (MonadBH m, FromJSON r, ToJSON a) => IndexName -> a -> m r
putMapping :: forall r a (m :: * -> *).
(MonadBH m, FromJSON r, ToJSON a) =>
IndexName -> a -> m r
putMapping IndexName
indexName a
mapping = BHRequest StatusDependant r -> m r
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant r -> m r)
-> BHRequest StatusDependant r -> m r
forall a b. (a -> b) -> a -> b
$ IndexName -> a -> BHRequest StatusDependant r
forall r a.
(FromJSON r, ToJSON a) =>
IndexName -> a -> BHRequest StatusDependant r
Requests.putMapping IndexName
indexName a
mapping

-- | 'indexDocument' is the primary way to save a single document in
--  Elasticsearch. The document itself is simply something we can
--  convert into a JSON 'Value'. The 'DocId' will function as the
--  primary key for the document. You are encouraged to generate
--  your own id's and not rely on Elasticsearch's automatic id
--  generation. Read more about it here:
--  https://github.com/bitemyapp/bloodhound/issues/107
--
-- >>> resp <- runBH' $ indexDocument testIndex defaultIndexDocumentSettings exampleTweet (DocId "1")
-- >>> print resp
-- Response {responseStatus = Status {statusCode = 200, statusMessage = "OK"}, responseVersion = HTTP/1.1, responseHeaders = [("content-type","application/json; charset=UTF-8"),("content-encoding","gzip"),("content-length","152")], responseBody = "{\"_index\":\"twitter\",\"_type\":\"_doc\",\"_id\":\"1\",\"_version\":2,\"result\":\"updated\",\"_shards\":{\"total\":1,\"successful\":1,\"failed\":0},\"_seq_no\":1,\"_primary_term\":1}", responseCookieJar = CJ {expose = []}, responseClose' = ResponseClose}
indexDocument ::
  forall doc m.
  (MonadBH m, ToJSON doc) =>
  IndexName ->
  IndexDocumentSettings ->
  doc ->
  DocId ->
  m Requests.IndexedDocument
indexDocument :: forall doc (m :: * -> *).
(MonadBH m, ToJSON doc) =>
IndexName
-> IndexDocumentSettings -> doc -> DocId -> m IndexedDocument
indexDocument IndexName
indexName IndexDocumentSettings
cfg doc
document DocId
docId = BHRequest StatusDependant IndexedDocument -> m IndexedDocument
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant IndexedDocument -> m IndexedDocument)
-> BHRequest StatusDependant IndexedDocument -> m IndexedDocument
forall a b. (a -> b) -> a -> b
$ IndexName
-> IndexDocumentSettings
-> doc
-> DocId
-> BHRequest StatusDependant IndexedDocument
forall doc.
ToJSON doc =>
IndexName
-> IndexDocumentSettings
-> doc
-> DocId
-> BHRequest StatusDependant IndexedDocument
Requests.indexDocument IndexName
indexName IndexDocumentSettings
cfg doc
document DocId
docId

-- | 'updateDocument' provides a way to perform an partial update of a
-- an already indexed document.
updateDocument ::
  forall patch m.
  (MonadBH m, ToJSON patch) =>
  IndexName ->
  IndexDocumentSettings ->
  patch ->
  DocId ->
  m Requests.IndexedDocument
updateDocument :: forall doc (m :: * -> *).
(MonadBH m, ToJSON doc) =>
IndexName
-> IndexDocumentSettings -> doc -> DocId -> m IndexedDocument
updateDocument IndexName
indexName IndexDocumentSettings
cfg patch
patch DocId
docId = BHRequest StatusDependant IndexedDocument -> m IndexedDocument
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant IndexedDocument -> m IndexedDocument)
-> BHRequest StatusDependant IndexedDocument -> m IndexedDocument
forall a b. (a -> b) -> a -> b
$ IndexName
-> IndexDocumentSettings
-> patch
-> DocId
-> BHRequest StatusDependant IndexedDocument
forall doc.
ToJSON doc =>
IndexName
-> IndexDocumentSettings
-> doc
-> DocId
-> BHRequest StatusDependant IndexedDocument
Requests.updateDocument IndexName
indexName IndexDocumentSettings
cfg patch
patch DocId
docId

updateByQuery :: (MonadBH m, FromJSON a) => IndexName -> Query -> Maybe Script -> m a
updateByQuery :: forall (m :: * -> *) a.
(MonadBH m, FromJSON a) =>
IndexName -> Query -> Maybe Script -> m a
updateByQuery IndexName
indexName Query
q Maybe Script
mScript = BHRequest StatusDependant a -> m a
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant a -> m a)
-> BHRequest StatusDependant a -> m a
forall a b. (a -> b) -> a -> b
$ IndexName -> Query -> Maybe Script -> BHRequest StatusDependant a
forall a.
FromJSON a =>
IndexName -> Query -> Maybe Script -> BHRequest StatusDependant a
Requests.updateByQuery IndexName
indexName Query
q Maybe Script
mScript

-- | 'deleteDocument' is the primary way to delete a single document.
--
-- >>> _ <- runBH' $ deleteDocument testIndex (DocId "1")
deleteDocument :: (MonadBH m) => IndexName -> DocId -> m Requests.IndexedDocument
deleteDocument :: forall (m :: * -> *).
MonadBH m =>
IndexName -> DocId -> m IndexedDocument
deleteDocument IndexName
indexName DocId
docId = BHRequest StatusDependant IndexedDocument -> m IndexedDocument
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant IndexedDocument -> m IndexedDocument)
-> BHRequest StatusDependant IndexedDocument -> m IndexedDocument
forall a b. (a -> b) -> a -> b
$ IndexName -> DocId -> BHRequest StatusDependant IndexedDocument
Requests.deleteDocument IndexName
indexName DocId
docId

-- | 'deleteByQuery' performs a deletion on every document that matches a query.
--
-- >>> let query = TermQuery (Term "user" "bitemyapp") Nothing
-- >>> _ <- runBH' $ deleteDocument testIndex query
deleteByQuery :: (MonadBH m) => IndexName -> Query -> m Requests.DeletedDocuments
deleteByQuery :: forall (m :: * -> *).
MonadBH m =>
IndexName -> Query -> m DeletedDocuments
deleteByQuery IndexName
indexName Query
query = BHRequest StatusDependant DeletedDocuments -> m DeletedDocuments
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant DeletedDocuments -> m DeletedDocuments)
-> BHRequest StatusDependant DeletedDocuments -> m DeletedDocuments
forall a b. (a -> b) -> a -> b
$ IndexName -> Query -> BHRequest StatusDependant DeletedDocuments
Requests.deleteByQuery IndexName
indexName Query
query

-- | 'bulk' uses
--   <http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-bulk.html Elasticsearch's bulk API>
--   to perform bulk operations. The 'BulkOperation' data type encodes the
--   index\/update\/delete\/create operations. You pass a 'V.Vector' of 'BulkOperation's
--   and a 'Server' to 'bulk' in order to send those operations up to your Elasticsearch
--   server to be performed. I changed from [BulkOperation] to a Vector due to memory overhead.
--
-- >>> let stream = V.fromList [BulkIndex testIndex (DocId "2") (toJSON (BulkTest "blah"))]
-- >>> _ <- runBH' $ bulk stream
-- >>> _ <- runBH' $ refreshIndex testIndex
bulk ::
  forall m.
  (MonadBH m) =>
  V.Vector BulkOperation ->
  m BulkResponse
bulk :: forall (m :: * -> *).
MonadBH m =>
Vector BulkOperation -> m BulkResponse
bulk Vector BulkOperation
ops = BHRequest StatusDependant BulkResponse -> m BulkResponse
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant BulkResponse -> m BulkResponse)
-> BHRequest StatusDependant BulkResponse -> m BulkResponse
forall a b. (a -> b) -> a -> b
$ forall contextualized.
ParseBHResponse contextualized =>
Vector BulkOperation -> BHRequest contextualized BulkResponse
Requests.bulk @StatusDependant Vector BulkOperation
ops

-- | 'documentExists' enables you to check if a document exists.
documentExists :: (MonadBH m) => IndexName -> DocId -> m Bool
documentExists :: forall (m :: * -> *). MonadBH m => IndexName -> DocId -> m Bool
documentExists IndexName
indexName DocId
docId = BHRequest StatusDependant Bool -> m Bool
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant Bool -> m Bool)
-> BHRequest StatusDependant Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ IndexName -> DocId -> BHRequest StatusDependant Bool
Requests.documentExists IndexName
indexName DocId
docId

-- | 'searchAll', given a 'Search', will perform that search against all indexes
--  on an Elasticsearch server. Try to avoid doing this if it can be helped.
--
-- >>> let query = TermQuery (Term "user" "bitemyapp") Nothing
-- >>> let search = mkSearch (Just query) Nothing
-- >>> response <- runBH' $ searchAll search
searchAll :: forall a m. (MonadBH m, FromJSON a) => Search -> m (SearchResult a)
searchAll :: forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
Search -> m (SearchResult a)
searchAll Search
search = BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (SearchResult a) -> m (SearchResult a))
-> BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall a b. (a -> b) -> a -> b
$ Search -> BHRequest StatusDependant (SearchResult a)
forall a.
FromJSON a =>
Search -> BHRequest StatusDependant (SearchResult a)
Requests.searchAll Search
search

-- | 'searchByIndex', given a 'Search' and an 'IndexName', will perform that search
--  within an index on an Elasticsearch server.
--
-- >>> let query = TermQuery (Term "user" "bitemyapp") Nothing
-- >>> let search = mkSearch (Just query) Nothing
-- >>> response <- runBH' $ searchByIndex testIndex search
searchByIndex :: forall a m. (MonadBH m, FromJSON a) => IndexName -> Search -> m (SearchResult a)
searchByIndex :: forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
IndexName -> Search -> m (SearchResult a)
searchByIndex IndexName
indexName Search
search = BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (SearchResult a) -> m (SearchResult a))
-> BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall a b. (a -> b) -> a -> b
$ IndexName -> Search -> BHRequest StatusDependant (SearchResult a)
forall a.
FromJSON a =>
IndexName -> Search -> BHRequest StatusDependant (SearchResult a)
Requests.searchByIndex IndexName
indexName Search
search

-- | 'searchByIndices' is a variant of 'searchByIndex' that executes a
--  'Search' over many indices. This is much faster than using
--  'mapM' to 'searchByIndex' over a collection since it only
--  causes a single HTTP request to be emitted.
searchByIndices :: forall a m. (MonadBH m, FromJSON a) => NonEmpty IndexName -> Search -> m (SearchResult a)
searchByIndices :: forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
NonEmpty IndexName -> Search -> m (SearchResult a)
searchByIndices NonEmpty IndexName
ixs Search
search = BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (SearchResult a) -> m (SearchResult a))
-> BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall a b. (a -> b) -> a -> b
$ NonEmpty IndexName
-> Search -> BHRequest StatusDependant (SearchResult a)
forall a.
FromJSON a =>
NonEmpty IndexName
-> Search -> BHRequest StatusDependant (SearchResult a)
Requests.searchByIndices NonEmpty IndexName
ixs Search
search

-- | 'searchByIndexTemplate', given a 'SearchTemplate' and an 'IndexName', will perform that search
--  within an index on an Elasticsearch server.
--
-- >>> let query = SearchTemplateSource "{\"query\": { \"match\" : { \"{{my_field}}\" : \"{{my_value}}\" } }, \"size\" : \"{{my_size}}\"}"
-- >>> let search = mkSearchTemplate (Right query) Nothing
-- >>> response <- runBH' $ searchByIndexTemplate testIndex search
searchByIndexTemplate ::
  forall a m.
  (MonadBH m, FromJSON a) =>
  IndexName ->
  SearchTemplate ->
  m (SearchResult a)
searchByIndexTemplate :: forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
IndexName -> SearchTemplate -> m (SearchResult a)
searchByIndexTemplate IndexName
indexName SearchTemplate
search = BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (SearchResult a) -> m (SearchResult a))
-> BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall a b. (a -> b) -> a -> b
$ IndexName
-> SearchTemplate -> BHRequest StatusDependant (SearchResult a)
forall a.
FromJSON a =>
IndexName
-> SearchTemplate -> BHRequest StatusDependant (SearchResult a)
Requests.searchByIndexTemplate IndexName
indexName SearchTemplate
search

-- | 'searchByIndicesTemplate' is a variant of 'searchByIndexTemplate' that executes a
--  'SearchTemplate' over many indices. This is much faster than using
--  'mapM' to 'searchByIndexTemplate' over a collection since it only
--  causes a single HTTP request to be emitted.
searchByIndicesTemplate ::
  forall a m.
  (MonadBH m, FromJSON a) =>
  NonEmpty IndexName ->
  SearchTemplate ->
  m (SearchResult a)
searchByIndicesTemplate :: forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
NonEmpty IndexName -> SearchTemplate -> m (SearchResult a)
searchByIndicesTemplate NonEmpty IndexName
ixs SearchTemplate
search = BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (SearchResult a) -> m (SearchResult a))
-> BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall a b. (a -> b) -> a -> b
$ NonEmpty IndexName
-> SearchTemplate -> BHRequest StatusDependant (SearchResult a)
forall a.
FromJSON a =>
NonEmpty IndexName
-> SearchTemplate -> BHRequest StatusDependant (SearchResult a)
Requests.searchByIndicesTemplate NonEmpty IndexName
ixs SearchTemplate
search

-- | 'storeSearchTemplate', saves a 'SearchTemplateSource' to be used later.
storeSearchTemplate :: (MonadBH m) => SearchTemplateId -> SearchTemplateSource -> m Acknowledged
storeSearchTemplate :: forall (m :: * -> *).
MonadBH m =>
SearchTemplateId -> SearchTemplateSource -> m Acknowledged
storeSearchTemplate SearchTemplateId
tid SearchTemplateSource
ts = BHRequest StatusDependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant Acknowledged -> m Acknowledged)
-> BHRequest StatusDependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ SearchTemplateId
-> SearchTemplateSource -> BHRequest StatusDependant Acknowledged
Requests.storeSearchTemplate SearchTemplateId
tid SearchTemplateSource
ts

-- | 'getSearchTemplate', get info of an stored 'SearchTemplateSource'.
getSearchTemplate :: (MonadBH m) => SearchTemplateId -> m GetTemplateScript
getSearchTemplate :: forall (m :: * -> *).
MonadBH m =>
SearchTemplateId -> m GetTemplateScript
getSearchTemplate SearchTemplateId
tid = BHRequest StatusIndependant GetTemplateScript
-> m GetTemplateScript
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant GetTemplateScript
 -> m GetTemplateScript)
-> BHRequest StatusIndependant GetTemplateScript
-> m GetTemplateScript
forall a b. (a -> b) -> a -> b
$ SearchTemplateId -> BHRequest StatusIndependant GetTemplateScript
Requests.getSearchTemplate SearchTemplateId
tid

-- | 'storeSearchTemplate',
deleteSearchTemplate :: (MonadBH m) => SearchTemplateId -> m Acknowledged
deleteSearchTemplate :: forall (m :: * -> *).
MonadBH m =>
SearchTemplateId -> m Acknowledged
deleteSearchTemplate SearchTemplateId
tid = BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusIndependant Acknowledged -> m Acknowledged)
-> BHRequest StatusIndependant Acknowledged -> m Acknowledged
forall a b. (a -> b) -> a -> b
$ SearchTemplateId -> BHRequest StatusIndependant Acknowledged
Requests.deleteSearchTemplate SearchTemplateId
tid

-- | For a given search, request a scroll for efficient streaming of
-- search results. Note that the search is put into 'SearchTypeScan'
-- mode and thus results will not be sorted. Combine this with
-- 'advanceScroll' to efficiently stream through the full result set
getInitialScroll ::
  forall a m.
  (MonadBH m, FromJSON a) =>
  IndexName ->
  Search ->
  m (ParsedEsResponse (SearchResult a))
getInitialScroll :: forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
IndexName -> Search -> m (ParsedEsResponse (SearchResult a))
getInitialScroll IndexName
indexName Search
search' = BHRequest StatusDependant (ParsedEsResponse (SearchResult a))
-> m (ParsedEsResponse (SearchResult a))
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (ParsedEsResponse (SearchResult a))
 -> m (ParsedEsResponse (SearchResult a)))
-> BHRequest StatusDependant (ParsedEsResponse (SearchResult a))
-> m (ParsedEsResponse (SearchResult a))
forall a b. (a -> b) -> a -> b
$ IndexName
-> Search
-> BHRequest StatusDependant (ParsedEsResponse (SearchResult a))
forall a.
FromJSON a =>
IndexName
-> Search
-> BHRequest StatusDependant (ParsedEsResponse (SearchResult a))
Requests.getInitialScroll IndexName
indexName Search
search'

-- | For a given search, request a scroll for efficient streaming of
-- search results. Combine this with 'advanceScroll' to efficiently
-- stream through the full result set. Note that this search respects
-- sorting and may be less efficient than 'getInitialScroll'.
getInitialSortedScroll ::
  forall a m.
  (MonadBH m, FromJSON a) =>
  IndexName ->
  Search ->
  m (SearchResult a)
getInitialSortedScroll :: forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
IndexName -> Search -> m (SearchResult a)
getInitialSortedScroll IndexName
indexName Search
search = BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (SearchResult a) -> m (SearchResult a))
-> BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall a b. (a -> b) -> a -> b
$ IndexName -> Search -> BHRequest StatusDependant (SearchResult a)
forall a.
FromJSON a =>
IndexName -> Search -> BHRequest StatusDependant (SearchResult a)
Requests.getInitialSortedScroll IndexName
indexName Search
search

-- | Use the given scroll to fetch the next page of documents. If there are no
-- further pages, 'SearchResult.searchHits.hits' will be '[]'.
advanceScroll ::
  forall a m.
  (MonadBH m, FromJSON a) =>
  ScrollId ->
  -- | How long should the snapshot of data be kept around? This timeout is updated every time 'advanceScroll' is used, so don't feel the need to set it to the entire duration of your search processing. Note that durations < 1s will be rounded up. Also note that 'NominalDiffTime' is an instance of Num so literals like 60 will be interpreted as seconds. 60s is a reasonable default.
  NominalDiffTime ->
  m (SearchResult a)
advanceScroll :: forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
ScrollId -> NominalDiffTime -> m (SearchResult a)
advanceScroll ScrollId
sid NominalDiffTime
scroll = BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (SearchResult a) -> m (SearchResult a))
-> BHRequest StatusDependant (SearchResult a) -> m (SearchResult a)
forall a b. (a -> b) -> a -> b
$ ScrollId
-> NominalDiffTime -> BHRequest StatusDependant (SearchResult a)
forall a.
FromJSON a =>
ScrollId
-> NominalDiffTime -> BHRequest StatusDependant (SearchResult a)
Requests.advanceScroll ScrollId
sid NominalDiffTime
scroll

-- | 'scanSearch' uses the 'scroll' API of elastic,
-- for a given 'IndexName'. Note that this will
-- consume the entire search result set and will be doing O(n) list
-- appends so this may not be suitable for large result sets. In that
-- case, 'getInitialScroll' and 'advanceScroll' are good low level
-- tools. You should be able to hook them up trivially to conduit,
-- pipes, or your favorite streaming IO abstraction of choice. Note
-- that ordering on the search would destroy performance and thus is
-- ignored.
scanSearch :: forall a m. (FromJSON a, MonadBH m) => IndexName -> Search -> m [Hit a]
scanSearch :: forall a (m :: * -> *).
(FromJSON a, MonadBH m) =>
IndexName -> Search -> m [Hit a]
scanSearch IndexName
indexName Search
search = do
  ParsedEsResponse (SearchResult a)
initialSearchResult <- IndexName -> Search -> m (ParsedEsResponse (SearchResult a))
forall a (m :: * -> *).
(MonadBH m, FromJSON a) =>
IndexName -> Search -> m (ParsedEsResponse (SearchResult a))
getInitialScroll IndexName
indexName Search
search
  let ([Hit a]
hits', Maybe ScrollId
josh) = case ParsedEsResponse (SearchResult a)
initialSearchResult of
        Right SearchResult {Bool
Int
Maybe Text
Maybe AggregationResults
Maybe NamedSuggestionResponse
Maybe ScrollId
ShardResult
SearchHits a
took :: Int
timedOut :: Bool
shards :: ShardResult
searchHits :: SearchHits a
aggregations :: Maybe AggregationResults
scrollId :: Maybe ScrollId
suggest :: Maybe NamedSuggestionResponse
pitId :: Maybe Text
pitId :: forall a. SearchResult a -> Maybe Text
suggest :: forall a. SearchResult a -> Maybe NamedSuggestionResponse
scrollId :: forall a. SearchResult a -> Maybe ScrollId
aggregations :: forall a. SearchResult a -> Maybe AggregationResults
searchHits :: forall a. SearchResult a -> SearchHits a
shards :: forall a. SearchResult a -> ShardResult
timedOut :: forall a. SearchResult a -> Bool
took :: forall a. SearchResult a -> Int
..} -> (SearchHits a -> [Hit a]
forall a. SearchHits a -> [Hit a]
hits SearchHits a
searchHits, Maybe ScrollId
scrollId)
        Left EsError
_ -> ([], Maybe ScrollId
forall a. Maybe a
Nothing)
  ([Hit a]
totalHits, Maybe ScrollId
_) <- [Hit a] -> ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
scanAccumulator [] ([Hit a]
hits', Maybe ScrollId
josh)
  [Hit a] -> m [Hit a]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return [Hit a]
totalHits
  where
    scanAccumulator :: [Hit a] -> ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
    scanAccumulator :: [Hit a] -> ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
scanAccumulator [Hit a]
oldHits ([Hit a]
newHits, Maybe ScrollId
Nothing) = ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Hit a]
oldHits [Hit a] -> [Hit a] -> [Hit a]
forall a. [a] -> [a] -> [a]
++ [Hit a]
newHits, Maybe ScrollId
forall a. Maybe a
Nothing)
    scanAccumulator [Hit a]
oldHits ([], Maybe ScrollId
_) = ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Hit a]
oldHits, Maybe ScrollId
forall a. Maybe a
Nothing)
    scanAccumulator [Hit a]
oldHits ([Hit a]
newHits, Maybe ScrollId
msid) = do
      ([Hit a]
newHits', Maybe ScrollId
msid') <- Maybe ScrollId -> m ([Hit a], Maybe ScrollId)
scroll' Maybe ScrollId
msid
      [Hit a] -> ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
scanAccumulator ([Hit a]
oldHits [Hit a] -> [Hit a] -> [Hit a]
forall a. [a] -> [a] -> [a]
++ [Hit a]
newHits) ([Hit a]
newHits', Maybe ScrollId
msid')

    scroll' :: Maybe ScrollId -> m ([Hit a], Maybe ScrollId)
    scroll' :: Maybe ScrollId -> m ([Hit a], Maybe ScrollId)
scroll' Maybe ScrollId
Nothing = ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([], Maybe ScrollId
forall a. Maybe a
Nothing)
    scroll' (Just ScrollId
sid) = do
      ParsedEsResponse (SearchResult a)
res <- BHRequest StatusDependant (SearchResult a)
-> m (ParsedEsResponse (SearchResult a))
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m (ParsedEsResponse a)
tryPerformBHRequest (BHRequest StatusDependant (SearchResult a)
 -> m (ParsedEsResponse (SearchResult a)))
-> BHRequest StatusDependant (SearchResult a)
-> m (ParsedEsResponse (SearchResult a))
forall a b. (a -> b) -> a -> b
$ ScrollId
-> NominalDiffTime -> BHRequest StatusDependant (SearchResult a)
forall a.
FromJSON a =>
ScrollId
-> NominalDiffTime -> BHRequest StatusDependant (SearchResult a)
Requests.advanceScroll ScrollId
sid NominalDiffTime
60
      case ParsedEsResponse (SearchResult a)
res of
        Right SearchResult {Bool
Int
Maybe Text
Maybe AggregationResults
Maybe NamedSuggestionResponse
Maybe ScrollId
ShardResult
SearchHits a
pitId :: forall a. SearchResult a -> Maybe Text
suggest :: forall a. SearchResult a -> Maybe NamedSuggestionResponse
scrollId :: forall a. SearchResult a -> Maybe ScrollId
aggregations :: forall a. SearchResult a -> Maybe AggregationResults
searchHits :: forall a. SearchResult a -> SearchHits a
shards :: forall a. SearchResult a -> ShardResult
timedOut :: forall a. SearchResult a -> Bool
took :: forall a. SearchResult a -> Int
took :: Int
timedOut :: Bool
shards :: ShardResult
searchHits :: SearchHits a
aggregations :: Maybe AggregationResults
scrollId :: Maybe ScrollId
suggest :: Maybe NamedSuggestionResponse
pitId :: Maybe Text
..} -> ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (SearchHits a -> [Hit a]
forall a. SearchHits a -> [Hit a]
hits SearchHits a
searchHits, Maybe ScrollId
scrollId)
        Left EsError
_ -> ([Hit a], Maybe ScrollId) -> m ([Hit a], Maybe ScrollId)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([], Maybe ScrollId
forall a. Maybe a
Nothing)

-- | This is a hook that can be set via the 'bhRequestHook' function
-- that will authenticate all requests using an HTTP Basic
-- Authentication header. Note that it is *strongly* recommended that
-- this option only be used over an SSL connection.
--
-- >> (mkBHEnv myServer myManager) { bhRequestHook = basicAuthHook (EsUsername "myuser") (EsPassword "mypass") }
basicAuthHook :: (Monad m) => EsUsername -> EsPassword -> Request -> m Request
basicAuthHook :: forall (m :: * -> *).
Monad m =>
EsUsername -> EsPassword -> Request -> m Request
basicAuthHook (EsUsername Text
u) (EsPassword Text
p) = Request -> m Request
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Request -> m Request)
-> (Request -> Request) -> Request -> m Request
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString -> Request -> Request
applyBasicAuth ByteString
u' ByteString
p'
  where
    u' :: ByteString
u' = Text -> ByteString
T.encodeUtf8 Text
u
    p' :: ByteString
p' = Text -> ByteString
T.encodeUtf8 Text
p

countByIndex :: (MonadBH m) => IndexName -> CountQuery -> m CountResponse
countByIndex :: forall (m :: * -> *).
MonadBH m =>
IndexName -> CountQuery -> m CountResponse
countByIndex IndexName
indexName CountQuery
q = BHRequest StatusDependant CountResponse -> m CountResponse
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant CountResponse -> m CountResponse)
-> BHRequest StatusDependant CountResponse -> m CountResponse
forall a b. (a -> b) -> a -> b
$ IndexName -> CountQuery -> BHRequest StatusDependant CountResponse
Requests.countByIndex IndexName
indexName CountQuery
q

reindex :: (MonadBH m) => ReindexRequest -> m ReindexResponse
reindex :: forall (m :: * -> *).
MonadBH m =>
ReindexRequest -> m ReindexResponse
reindex = BHRequest StatusDependant ReindexResponse -> m ReindexResponse
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant ReindexResponse -> m ReindexResponse)
-> (ReindexRequest -> BHRequest StatusDependant ReindexResponse)
-> ReindexRequest
-> m ReindexResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReindexRequest -> BHRequest StatusDependant ReindexResponse
Requests.reindex

reindexAsync :: (MonadBH m) => ReindexRequest -> m TaskNodeId
reindexAsync :: forall (m :: * -> *). MonadBH m => ReindexRequest -> m TaskNodeId
reindexAsync = BHRequest StatusDependant TaskNodeId -> m TaskNodeId
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant TaskNodeId -> m TaskNodeId)
-> (ReindexRequest -> BHRequest StatusDependant TaskNodeId)
-> ReindexRequest
-> m TaskNodeId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReindexRequest -> BHRequest StatusDependant TaskNodeId
Requests.reindexAsync

getTask :: (MonadBH m, FromJSON a) => TaskNodeId -> m (TaskResponse a)
getTask :: forall (m :: * -> *) a.
(MonadBH m, FromJSON a) =>
TaskNodeId -> m (TaskResponse a)
getTask = BHRequest StatusDependant (TaskResponse a) -> m (TaskResponse a)
forall (m :: * -> *) contextualized a.
(MonadBH m, MonadThrow m, ParseBHResponse contextualized) =>
BHRequest contextualized a -> m a
performBHRequest (BHRequest StatusDependant (TaskResponse a) -> m (TaskResponse a))
-> (TaskNodeId -> BHRequest StatusDependant (TaskResponse a))
-> TaskNodeId
-> m (TaskResponse a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaskNodeId -> BHRequest StatusDependant (TaskResponse a)
forall a.
FromJSON a =>
TaskNodeId -> BHRequest StatusDependant (TaskResponse a)
Requests.getTask