{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}

module Database.Bloodhound.Internal.Versions.Common.Types.Aggregation where

import qualified Data.Aeson as Aeson
import qualified Data.Aeson.KeyMap as X
import qualified Data.Map.Strict as M
import qualified Data.Text as T
import Database.Bloodhound.Internal.Utils.Imports
import Database.Bloodhound.Internal.Versions.Common.Types.Highlight (HitHighlight)
import Database.Bloodhound.Internal.Versions.Common.Types.Newtypes
import Database.Bloodhound.Internal.Versions.Common.Types.Query
import Database.Bloodhound.Internal.Versions.Common.Types.Sort
import Database.Bloodhound.Internal.Versions.Common.Types.Units

type Aggregations = M.Map Key Aggregation

emptyAggregations :: Aggregations
emptyAggregations :: Aggregations
emptyAggregations = Aggregations
forall k a. Map k a
M.empty

mkAggregations :: Key -> Aggregation -> Aggregations
mkAggregations :: Key -> Aggregation -> Aggregations
mkAggregations Key
name Aggregation
aggregation = Key -> Aggregation -> Aggregations -> Aggregations
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Key
name Aggregation
aggregation Aggregations
emptyAggregations

data Aggregation
  = TermsAgg TermsAggregation
  | CardinalityAgg CardinalityAggregation
  | DateHistogramAgg DateHistogramAggregation
  | ValueCountAgg ValueCountAggregation
  | FilterAgg FilterAggregation
  | DateRangeAgg DateRangeAggregation
  | MissingAgg MissingAggregation
  | TopHitsAgg TopHitsAggregation
  | StatsAgg StatisticsAggregation
  | SumAgg SumAggregation
  deriving stock (Aggregation -> Aggregation -> Bool
(Aggregation -> Aggregation -> Bool)
-> (Aggregation -> Aggregation -> Bool) -> Eq Aggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Aggregation -> Aggregation -> Bool
== :: Aggregation -> Aggregation -> Bool
$c/= :: Aggregation -> Aggregation -> Bool
/= :: Aggregation -> Aggregation -> Bool
Eq, Int -> Aggregation -> ShowS
[Aggregation] -> ShowS
Aggregation -> String
(Int -> Aggregation -> ShowS)
-> (Aggregation -> String)
-> ([Aggregation] -> ShowS)
-> Show Aggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Aggregation -> ShowS
showsPrec :: Int -> Aggregation -> ShowS
$cshow :: Aggregation -> String
show :: Aggregation -> String
$cshowList :: [Aggregation] -> ShowS
showList :: [Aggregation] -> ShowS
Show)

instance ToJSON Aggregation where
  toJSON :: Aggregation -> Value
toJSON (TermsAgg (TermsAggregation Either Text Text
term Maybe TermInclusion
include Maybe TermInclusion
exclude Maybe TermOrder
order Maybe Int
minDocCount Maybe Int
size Maybe Int
shardSize Maybe CollectionMode
collectMode Maybe ExecutionHint
executionHint Maybe Aggregations
termAggs)) =
    [(Key, Value)] -> Value
omitNulls
      [ Key
"terms"
          Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls
            [ Either Text Text -> (Key, Value)
forall {e} {kv} {v} {v}.
(KeyValue e kv, ToJSON v, ToJSON v) =>
Either v v -> kv
toJSON' Either Text Text
term,
              Key
"include" Key -> Maybe TermInclusion -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe TermInclusion
include,
              Key
"exclude" Key -> Maybe TermInclusion -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe TermInclusion
exclude,
              Key
"order" Key -> Maybe TermOrder -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe TermOrder
order,
              Key
"min_doc_count" Key -> Maybe Int -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Int
minDocCount,
              Key
"size" Key -> Maybe Int -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Int
size,
              Key
"shard_size" Key -> Maybe Int -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Int
shardSize,
              Key
"collect_mode" Key -> Maybe CollectionMode -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe CollectionMode
collectMode,
              Key
"execution_hint" Key -> Maybe ExecutionHint -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe ExecutionHint
executionHint
            ],
        Key
"aggs" Key -> Maybe Aggregations -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Aggregations
termAggs
      ]
    where
      toJSON' :: Either v v -> kv
toJSON' Either v v
x = case Either v v
x of Left v
y -> Key
"field" Key -> v -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
y; Right v
y -> Key
"script" Key -> v -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
y
  toJSON (CardinalityAgg (CardinalityAggregation FieldName
field Maybe Int
precisionThreshold)) =
    [(Key, Value)] -> Value
object
      [ Key
"cardinality"
          Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls
            [ Key
"field" Key -> FieldName -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= FieldName
field,
              Key
"precisionThreshold" Key -> Maybe Int -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Int
precisionThreshold
            ]
      ]
  toJSON
    ( DateHistogramAgg
        ( DateHistogramAggregation
            FieldName
field
            Interval
interval
            Maybe Text
format
            Maybe Text
preZone
            Maybe Text
postZone
            Maybe Text
preOffset
            Maybe Text
postOffset
            Maybe Aggregations
dateHistoAggs
          )
      ) =
      [(Key, Value)] -> Value
omitNulls
        [ Key
"date_histogram"
            Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls
              [ Key
"field" Key -> FieldName -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= FieldName
field,
                Key
"interval" Key -> Interval -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Interval
interval,
                Key
"format" Key -> Maybe Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
format,
                Key
"pre_zone" Key -> Maybe Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
preZone,
                Key
"post_zone" Key -> Maybe Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
postZone,
                Key
"pre_offset" Key -> Maybe Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
preOffset,
                Key
"post_offset" Key -> Maybe Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
postOffset
              ],
          Key
"aggs" Key -> Maybe Aggregations -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Aggregations
dateHistoAggs
        ]
  toJSON (ValueCountAgg ValueCountAggregation
a) = [(Key, Value)] -> Value
object [Key
"value_count" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Value
v]
    where
      v :: Value
v = case ValueCountAggregation
a of
        (FieldValueCount (FieldName Text
n)) ->
          [(Key, Value)] -> Value
object [Key
"field" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
n]
        (ScriptValueCount Script
s) ->
          [(Key, Value)] -> Value
object [Key
"script" Key -> Script -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Script
s]
  toJSON (FilterAgg (FilterAggregation Filter
filt Maybe Aggregations
ags)) =
    [(Key, Value)] -> Value
omitNulls
      [ Key
"filter" Key -> Filter -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Filter
filt,
        Key
"aggs" Key -> Maybe Aggregations -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Aggregations
ags
      ]
  toJSON (DateRangeAgg DateRangeAggregation
a) =
    [(Key, Value)] -> Value
object
      [ Key
"date_range" Key -> DateRangeAggregation -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= DateRangeAggregation
a
      ]
  toJSON (MissingAgg (MissingAggregation {Text
maField :: Text
maField :: MissingAggregation -> Text
..})) =
    [(Key, Value)] -> Value
object [Key
"missing" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object [Key
"field" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
maField]]
  toJSON (TopHitsAgg (TopHitsAggregation Maybe From
mfrom Maybe Size
msize Maybe Sort
msort)) =
    [(Key, Value)] -> Value
omitNulls
      [ Key
"top_hits"
          Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls
            [ Key
"size" Key -> Maybe Size -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Size
msize,
              Key
"from" Key -> Maybe From -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe From
mfrom,
              Key
"sort" Key -> Maybe Sort -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Sort
msort
            ]
      ]
  toJSON (StatsAgg (StatisticsAggregation StatsType
typ FieldName
field)) =
    [(Key, Value)] -> Value
object [Key
stType Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls [Key
"field" Key -> FieldName -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= FieldName
field]]
    where
      stType :: Key
stType
        | StatsType
typ StatsType -> StatsType -> Bool
forall a. Eq a => a -> a -> Bool
== StatsType
Basic = Key
"stats"
        | Bool
otherwise = Key
"extended_stats"
  toJSON (SumAgg (SumAggregation (FieldName Text
n))) =
    [(Key, Value)] -> Value
omitNulls [Key
"sum" Key -> Value -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls [Key
"field" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
n]]

data TopHitsAggregation = TopHitsAggregation
  { TopHitsAggregation -> Maybe From
taFrom :: Maybe From,
    TopHitsAggregation -> Maybe Size
taSize :: Maybe Size,
    TopHitsAggregation -> Maybe Sort
taSort :: Maybe Sort
  }
  deriving stock (TopHitsAggregation -> TopHitsAggregation -> Bool
(TopHitsAggregation -> TopHitsAggregation -> Bool)
-> (TopHitsAggregation -> TopHitsAggregation -> Bool)
-> Eq TopHitsAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TopHitsAggregation -> TopHitsAggregation -> Bool
== :: TopHitsAggregation -> TopHitsAggregation -> Bool
$c/= :: TopHitsAggregation -> TopHitsAggregation -> Bool
/= :: TopHitsAggregation -> TopHitsAggregation -> Bool
Eq, Int -> TopHitsAggregation -> ShowS
[TopHitsAggregation] -> ShowS
TopHitsAggregation -> String
(Int -> TopHitsAggregation -> ShowS)
-> (TopHitsAggregation -> String)
-> ([TopHitsAggregation] -> ShowS)
-> Show TopHitsAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TopHitsAggregation -> ShowS
showsPrec :: Int -> TopHitsAggregation -> ShowS
$cshow :: TopHitsAggregation -> String
show :: TopHitsAggregation -> String
$cshowList :: [TopHitsAggregation] -> ShowS
showList :: [TopHitsAggregation] -> ShowS
Show)

taFromLens :: Lens' TopHitsAggregation (Maybe From)
taFromLens :: Lens' TopHitsAggregation (Maybe From)
taFromLens = (TopHitsAggregation -> Maybe From)
-> (TopHitsAggregation -> Maybe From -> TopHitsAggregation)
-> Lens' TopHitsAggregation (Maybe From)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TopHitsAggregation -> Maybe From
taFrom (\TopHitsAggregation
x Maybe From
y -> TopHitsAggregation
x {taFrom = y})

taSizeLens :: Lens' TopHitsAggregation (Maybe Size)
taSizeLens :: Lens' TopHitsAggregation (Maybe Size)
taSizeLens = (TopHitsAggregation -> Maybe Size)
-> (TopHitsAggregation -> Maybe Size -> TopHitsAggregation)
-> Lens' TopHitsAggregation (Maybe Size)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TopHitsAggregation -> Maybe Size
taSize (\TopHitsAggregation
x Maybe Size
y -> TopHitsAggregation
x {taSize = y})

taSortLens :: Lens' TopHitsAggregation (Maybe Sort)
taSortLens :: Lens' TopHitsAggregation (Maybe Sort)
taSortLens = (TopHitsAggregation -> Maybe Sort)
-> (TopHitsAggregation -> Maybe Sort -> TopHitsAggregation)
-> Lens' TopHitsAggregation (Maybe Sort)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TopHitsAggregation -> Maybe Sort
taSort (\TopHitsAggregation
x Maybe Sort
y -> TopHitsAggregation
x {taSort = y})

data MissingAggregation = MissingAggregation
  { MissingAggregation -> Text
maField :: Text
  }
  deriving stock (MissingAggregation -> MissingAggregation -> Bool
(MissingAggregation -> MissingAggregation -> Bool)
-> (MissingAggregation -> MissingAggregation -> Bool)
-> Eq MissingAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MissingAggregation -> MissingAggregation -> Bool
== :: MissingAggregation -> MissingAggregation -> Bool
$c/= :: MissingAggregation -> MissingAggregation -> Bool
/= :: MissingAggregation -> MissingAggregation -> Bool
Eq, Int -> MissingAggregation -> ShowS
[MissingAggregation] -> ShowS
MissingAggregation -> String
(Int -> MissingAggregation -> ShowS)
-> (MissingAggregation -> String)
-> ([MissingAggregation] -> ShowS)
-> Show MissingAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MissingAggregation -> ShowS
showsPrec :: Int -> MissingAggregation -> ShowS
$cshow :: MissingAggregation -> String
show :: MissingAggregation -> String
$cshowList :: [MissingAggregation] -> ShowS
showList :: [MissingAggregation] -> ShowS
Show)

maFieldLens :: Lens' MissingAggregation Text
maFieldLens :: Lens' MissingAggregation Text
maFieldLens = (MissingAggregation -> Text)
-> (MissingAggregation -> Text -> MissingAggregation)
-> Lens' MissingAggregation Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens MissingAggregation -> Text
maField (\MissingAggregation
x Text
y -> MissingAggregation
x {maField = y})

data TermsAggregation = TermsAggregation
  { TermsAggregation -> Either Text Text
term :: Either Text Text,
    TermsAggregation -> Maybe TermInclusion
termInclude :: Maybe TermInclusion,
    TermsAggregation -> Maybe TermInclusion
termExclude :: Maybe TermInclusion,
    TermsAggregation -> Maybe TermOrder
termOrder :: Maybe TermOrder,
    TermsAggregation -> Maybe Int
termMinDocCount :: Maybe Int,
    TermsAggregation -> Maybe Int
termSize :: Maybe Int,
    TermsAggregation -> Maybe Int
termShardSize :: Maybe Int,
    TermsAggregation -> Maybe CollectionMode
termCollectMode :: Maybe CollectionMode,
    TermsAggregation -> Maybe ExecutionHint
termExecutionHint :: Maybe ExecutionHint,
    TermsAggregation -> Maybe Aggregations
termAggs :: Maybe Aggregations
  }
  deriving stock (TermsAggregation -> TermsAggregation -> Bool
(TermsAggregation -> TermsAggregation -> Bool)
-> (TermsAggregation -> TermsAggregation -> Bool)
-> Eq TermsAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TermsAggregation -> TermsAggregation -> Bool
== :: TermsAggregation -> TermsAggregation -> Bool
$c/= :: TermsAggregation -> TermsAggregation -> Bool
/= :: TermsAggregation -> TermsAggregation -> Bool
Eq, Int -> TermsAggregation -> ShowS
[TermsAggregation] -> ShowS
TermsAggregation -> String
(Int -> TermsAggregation -> ShowS)
-> (TermsAggregation -> String)
-> ([TermsAggregation] -> ShowS)
-> Show TermsAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TermsAggregation -> ShowS
showsPrec :: Int -> TermsAggregation -> ShowS
$cshow :: TermsAggregation -> String
show :: TermsAggregation -> String
$cshowList :: [TermsAggregation] -> ShowS
showList :: [TermsAggregation] -> ShowS
Show)

termLens :: Lens' TermsAggregation (Either Text Text)
termLens :: Lens' TermsAggregation (Either Text Text)
termLens = (TermsAggregation -> Either Text Text)
-> (TermsAggregation -> Either Text Text -> TermsAggregation)
-> Lens' TermsAggregation (Either Text Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Either Text Text
term (\TermsAggregation
x Either Text Text
y -> TermsAggregation
x {term = y})

termIncludeLens :: Lens' TermsAggregation (Maybe TermInclusion)
termIncludeLens :: Lens' TermsAggregation (Maybe TermInclusion)
termIncludeLens = (TermsAggregation -> Maybe TermInclusion)
-> (TermsAggregation -> Maybe TermInclusion -> TermsAggregation)
-> Lens' TermsAggregation (Maybe TermInclusion)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe TermInclusion
termInclude (\TermsAggregation
x Maybe TermInclusion
y -> TermsAggregation
x {termInclude = y})

termExcludeLens :: Lens' TermsAggregation (Maybe TermInclusion)
termExcludeLens :: Lens' TermsAggregation (Maybe TermInclusion)
termExcludeLens = (TermsAggregation -> Maybe TermInclusion)
-> (TermsAggregation -> Maybe TermInclusion -> TermsAggregation)
-> Lens' TermsAggregation (Maybe TermInclusion)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe TermInclusion
termExclude (\TermsAggregation
x Maybe TermInclusion
y -> TermsAggregation
x {termExclude = y})

termOrderLens :: Lens' TermsAggregation (Maybe TermOrder)
termOrderLens :: Lens' TermsAggregation (Maybe TermOrder)
termOrderLens = (TermsAggregation -> Maybe TermOrder)
-> (TermsAggregation -> Maybe TermOrder -> TermsAggregation)
-> Lens' TermsAggregation (Maybe TermOrder)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe TermOrder
termOrder (\TermsAggregation
x Maybe TermOrder
y -> TermsAggregation
x {termOrder = y})

termMinDocCountLens :: Lens' TermsAggregation (Maybe Int)
termMinDocCountLens :: Lens' TermsAggregation (Maybe Int)
termMinDocCountLens = (TermsAggregation -> Maybe Int)
-> (TermsAggregation -> Maybe Int -> TermsAggregation)
-> Lens' TermsAggregation (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe Int
termMinDocCount (\TermsAggregation
x Maybe Int
y -> TermsAggregation
x {termMinDocCount = y})

termSizeLens :: Lens' TermsAggregation (Maybe Int)
termSizeLens :: Lens' TermsAggregation (Maybe Int)
termSizeLens = (TermsAggregation -> Maybe Int)
-> (TermsAggregation -> Maybe Int -> TermsAggregation)
-> Lens' TermsAggregation (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe Int
termSize (\TermsAggregation
x Maybe Int
y -> TermsAggregation
x {termSize = y})

termShardSizeLens :: Lens' TermsAggregation (Maybe Int)
termShardSizeLens :: Lens' TermsAggregation (Maybe Int)
termShardSizeLens = (TermsAggregation -> Maybe Int)
-> (TermsAggregation -> Maybe Int -> TermsAggregation)
-> Lens' TermsAggregation (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe Int
termShardSize (\TermsAggregation
x Maybe Int
y -> TermsAggregation
x {termShardSize = y})

termCollectModeLens :: Lens' TermsAggregation (Maybe CollectionMode)
termCollectModeLens :: Lens' TermsAggregation (Maybe CollectionMode)
termCollectModeLens = (TermsAggregation -> Maybe CollectionMode)
-> (TermsAggregation -> Maybe CollectionMode -> TermsAggregation)
-> Lens' TermsAggregation (Maybe CollectionMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe CollectionMode
termCollectMode (\TermsAggregation
x Maybe CollectionMode
y -> TermsAggregation
x {termCollectMode = y})

termExecutionHintLens :: Lens' TermsAggregation (Maybe ExecutionHint)
termExecutionHintLens :: Lens' TermsAggregation (Maybe ExecutionHint)
termExecutionHintLens = (TermsAggregation -> Maybe ExecutionHint)
-> (TermsAggregation -> Maybe ExecutionHint -> TermsAggregation)
-> Lens' TermsAggregation (Maybe ExecutionHint)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe ExecutionHint
termExecutionHint (\TermsAggregation
x Maybe ExecutionHint
y -> TermsAggregation
x {termExecutionHint = y})

termAggsLens :: Lens' TermsAggregation (Maybe Aggregations)
termAggsLens :: Lens' TermsAggregation (Maybe Aggregations)
termAggsLens = (TermsAggregation -> Maybe Aggregations)
-> (TermsAggregation -> Maybe Aggregations -> TermsAggregation)
-> Lens' TermsAggregation (Maybe Aggregations)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsAggregation -> Maybe Aggregations
termAggs (\TermsAggregation
x Maybe Aggregations
y -> TermsAggregation
x {termAggs = y})

data CardinalityAggregation = CardinalityAggregation
  { CardinalityAggregation -> FieldName
cardinalityField :: FieldName,
    CardinalityAggregation -> Maybe Int
precisionThreshold :: Maybe Int
  }
  deriving stock (CardinalityAggregation -> CardinalityAggregation -> Bool
(CardinalityAggregation -> CardinalityAggregation -> Bool)
-> (CardinalityAggregation -> CardinalityAggregation -> Bool)
-> Eq CardinalityAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CardinalityAggregation -> CardinalityAggregation -> Bool
== :: CardinalityAggregation -> CardinalityAggregation -> Bool
$c/= :: CardinalityAggregation -> CardinalityAggregation -> Bool
/= :: CardinalityAggregation -> CardinalityAggregation -> Bool
Eq, Int -> CardinalityAggregation -> ShowS
[CardinalityAggregation] -> ShowS
CardinalityAggregation -> String
(Int -> CardinalityAggregation -> ShowS)
-> (CardinalityAggregation -> String)
-> ([CardinalityAggregation] -> ShowS)
-> Show CardinalityAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CardinalityAggregation -> ShowS
showsPrec :: Int -> CardinalityAggregation -> ShowS
$cshow :: CardinalityAggregation -> String
show :: CardinalityAggregation -> String
$cshowList :: [CardinalityAggregation] -> ShowS
showList :: [CardinalityAggregation] -> ShowS
Show)

cardinalityFieldLens :: Lens' CardinalityAggregation FieldName
cardinalityFieldLens :: Lens' CardinalityAggregation FieldName
cardinalityFieldLens = (CardinalityAggregation -> FieldName)
-> (CardinalityAggregation -> FieldName -> CardinalityAggregation)
-> Lens' CardinalityAggregation FieldName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens CardinalityAggregation -> FieldName
cardinalityField (\CardinalityAggregation
x FieldName
y -> CardinalityAggregation
x {cardinalityField = y})

precisionThresholdLens :: Lens' CardinalityAggregation (Maybe Int)
precisionThresholdLens :: Lens' CardinalityAggregation (Maybe Int)
precisionThresholdLens = (CardinalityAggregation -> Maybe Int)
-> (CardinalityAggregation -> Maybe Int -> CardinalityAggregation)
-> Lens' CardinalityAggregation (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens CardinalityAggregation -> Maybe Int
precisionThreshold (\CardinalityAggregation
x Maybe Int
y -> CardinalityAggregation
x {precisionThreshold = y})

data DateHistogramAggregation = DateHistogramAggregation
  { DateHistogramAggregation -> FieldName
dateField :: FieldName,
    DateHistogramAggregation -> Interval
dateInterval :: Interval,
    DateHistogramAggregation -> Maybe Text
dateFormat :: Maybe Text,
    -- pre and post deprecated in 1.5
    DateHistogramAggregation -> Maybe Text
datePreZone :: Maybe Text,
    DateHistogramAggregation -> Maybe Text
datePostZone :: Maybe Text,
    DateHistogramAggregation -> Maybe Text
datePreOffset :: Maybe Text,
    DateHistogramAggregation -> Maybe Text
datePostOffset :: Maybe Text,
    DateHistogramAggregation -> Maybe Aggregations
dateAggs :: Maybe Aggregations
  }
  deriving stock (DateHistogramAggregation -> DateHistogramAggregation -> Bool
(DateHistogramAggregation -> DateHistogramAggregation -> Bool)
-> (DateHistogramAggregation -> DateHistogramAggregation -> Bool)
-> Eq DateHistogramAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateHistogramAggregation -> DateHistogramAggregation -> Bool
== :: DateHistogramAggregation -> DateHistogramAggregation -> Bool
$c/= :: DateHistogramAggregation -> DateHistogramAggregation -> Bool
/= :: DateHistogramAggregation -> DateHistogramAggregation -> Bool
Eq, Int -> DateHistogramAggregation -> ShowS
[DateHistogramAggregation] -> ShowS
DateHistogramAggregation -> String
(Int -> DateHistogramAggregation -> ShowS)
-> (DateHistogramAggregation -> String)
-> ([DateHistogramAggregation] -> ShowS)
-> Show DateHistogramAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateHistogramAggregation -> ShowS
showsPrec :: Int -> DateHistogramAggregation -> ShowS
$cshow :: DateHistogramAggregation -> String
show :: DateHistogramAggregation -> String
$cshowList :: [DateHistogramAggregation] -> ShowS
showList :: [DateHistogramAggregation] -> ShowS
Show)

dateFieldLens :: Lens' DateHistogramAggregation FieldName
dateFieldLens :: Lens' DateHistogramAggregation FieldName
dateFieldLens = (DateHistogramAggregation -> FieldName)
-> (DateHistogramAggregation
    -> FieldName -> DateHistogramAggregation)
-> Lens' DateHistogramAggregation FieldName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramAggregation -> FieldName
dateField (\DateHistogramAggregation
x FieldName
y -> DateHistogramAggregation
x {dateField = y})

dateIntervalLens :: Lens' DateHistogramAggregation Interval
dateIntervalLens :: Lens' DateHistogramAggregation Interval
dateIntervalLens = (DateHistogramAggregation -> Interval)
-> (DateHistogramAggregation
    -> Interval -> DateHistogramAggregation)
-> Lens' DateHistogramAggregation Interval
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramAggregation -> Interval
dateInterval (\DateHistogramAggregation
x Interval
y -> DateHistogramAggregation
x {dateInterval = y})

dateFormatLens :: Lens' DateHistogramAggregation (Maybe Text)
dateFormatLens :: Lens' DateHistogramAggregation (Maybe Text)
dateFormatLens = (DateHistogramAggregation -> Maybe Text)
-> (DateHistogramAggregation
    -> Maybe Text -> DateHistogramAggregation)
-> Lens' DateHistogramAggregation (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramAggregation -> Maybe Text
dateFormat (\DateHistogramAggregation
x Maybe Text
y -> DateHistogramAggregation
x {dateFormat = y})

datePreZoneLens :: Lens' DateHistogramAggregation (Maybe Text)
datePreZoneLens :: Lens' DateHistogramAggregation (Maybe Text)
datePreZoneLens = (DateHistogramAggregation -> Maybe Text)
-> (DateHistogramAggregation
    -> Maybe Text -> DateHistogramAggregation)
-> Lens' DateHistogramAggregation (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramAggregation -> Maybe Text
datePreZone (\DateHistogramAggregation
x Maybe Text
y -> DateHistogramAggregation
x {datePreZone = y})

datePostZoneLens :: Lens' DateHistogramAggregation (Maybe Text)
datePostZoneLens :: Lens' DateHistogramAggregation (Maybe Text)
datePostZoneLens = (DateHistogramAggregation -> Maybe Text)
-> (DateHistogramAggregation
    -> Maybe Text -> DateHistogramAggregation)
-> Lens' DateHistogramAggregation (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramAggregation -> Maybe Text
datePostZone (\DateHistogramAggregation
x Maybe Text
y -> DateHistogramAggregation
x {datePostZone = y})

datePreOffsetLens :: Lens' DateHistogramAggregation (Maybe Text)
datePreOffsetLens :: Lens' DateHistogramAggregation (Maybe Text)
datePreOffsetLens = (DateHistogramAggregation -> Maybe Text)
-> (DateHistogramAggregation
    -> Maybe Text -> DateHistogramAggregation)
-> Lens' DateHistogramAggregation (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramAggregation -> Maybe Text
datePreOffset (\DateHistogramAggregation
x Maybe Text
y -> DateHistogramAggregation
x {datePreOffset = y})

datePostOffsetLens :: Lens' DateHistogramAggregation (Maybe Text)
datePostOffsetLens :: Lens' DateHistogramAggregation (Maybe Text)
datePostOffsetLens = (DateHistogramAggregation -> Maybe Text)
-> (DateHistogramAggregation
    -> Maybe Text -> DateHistogramAggregation)
-> Lens' DateHistogramAggregation (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramAggregation -> Maybe Text
datePostOffset (\DateHistogramAggregation
x Maybe Text
y -> DateHistogramAggregation
x {datePostOffset = y})

dateAggsLens :: Lens' DateHistogramAggregation (Maybe Aggregations)
dateAggsLens :: Lens' DateHistogramAggregation (Maybe Aggregations)
dateAggsLens = (DateHistogramAggregation -> Maybe Aggregations)
-> (DateHistogramAggregation
    -> Maybe Aggregations -> DateHistogramAggregation)
-> Lens' DateHistogramAggregation (Maybe Aggregations)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramAggregation -> Maybe Aggregations
dateAggs (\DateHistogramAggregation
x Maybe Aggregations
y -> DateHistogramAggregation
x {dateAggs = y})

data DateRangeAggregation = DateRangeAggregation
  { DateRangeAggregation -> FieldName
draField :: FieldName,
    DateRangeAggregation -> Maybe Text
draFormat :: Maybe Text,
    DateRangeAggregation -> NonEmpty DateRangeAggRange
draRanges :: NonEmpty DateRangeAggRange
  }
  deriving stock (DateRangeAggregation -> DateRangeAggregation -> Bool
(DateRangeAggregation -> DateRangeAggregation -> Bool)
-> (DateRangeAggregation -> DateRangeAggregation -> Bool)
-> Eq DateRangeAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateRangeAggregation -> DateRangeAggregation -> Bool
== :: DateRangeAggregation -> DateRangeAggregation -> Bool
$c/= :: DateRangeAggregation -> DateRangeAggregation -> Bool
/= :: DateRangeAggregation -> DateRangeAggregation -> Bool
Eq, Int -> DateRangeAggregation -> ShowS
[DateRangeAggregation] -> ShowS
DateRangeAggregation -> String
(Int -> DateRangeAggregation -> ShowS)
-> (DateRangeAggregation -> String)
-> ([DateRangeAggregation] -> ShowS)
-> Show DateRangeAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateRangeAggregation -> ShowS
showsPrec :: Int -> DateRangeAggregation -> ShowS
$cshow :: DateRangeAggregation -> String
show :: DateRangeAggregation -> String
$cshowList :: [DateRangeAggregation] -> ShowS
showList :: [DateRangeAggregation] -> ShowS
Show)

instance ToJSON DateRangeAggregation where
  toJSON :: DateRangeAggregation -> Value
toJSON DateRangeAggregation {Maybe Text
NonEmpty DateRangeAggRange
FieldName
draField :: DateRangeAggregation -> FieldName
draFormat :: DateRangeAggregation -> Maybe Text
draRanges :: DateRangeAggregation -> NonEmpty DateRangeAggRange
draField :: FieldName
draFormat :: Maybe Text
draRanges :: NonEmpty DateRangeAggRange
..} =
    [(Key, Value)] -> Value
omitNulls
      [ Key
"field" Key -> FieldName -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= FieldName
draField,
        Key
"format" Key -> Maybe Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
draFormat,
        Key
"ranges" Key -> [DateRangeAggRange] -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= NonEmpty DateRangeAggRange -> [DateRangeAggRange]
forall a. NonEmpty a -> [a]
toList NonEmpty DateRangeAggRange
draRanges
      ]

draFieldLens :: Lens' DateRangeAggregation FieldName
draFieldLens :: Lens' DateRangeAggregation FieldName
draFieldLens = (DateRangeAggregation -> FieldName)
-> (DateRangeAggregation -> FieldName -> DateRangeAggregation)
-> Lens' DateRangeAggregation FieldName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeAggregation -> FieldName
draField (\DateRangeAggregation
x FieldName
y -> DateRangeAggregation
x {draField = y})

draFormatLens :: Lens' DateRangeAggregation (Maybe Text)
draFormatLens :: Lens' DateRangeAggregation (Maybe Text)
draFormatLens = (DateRangeAggregation -> Maybe Text)
-> (DateRangeAggregation -> Maybe Text -> DateRangeAggregation)
-> Lens' DateRangeAggregation (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeAggregation -> Maybe Text
draFormat (\DateRangeAggregation
x Maybe Text
y -> DateRangeAggregation
x {draFormat = y})

draRangesLens :: Lens' DateRangeAggregation (NonEmpty DateRangeAggRange)
draRangesLens :: Lens' DateRangeAggregation (NonEmpty DateRangeAggRange)
draRangesLens = (DateRangeAggregation -> NonEmpty DateRangeAggRange)
-> (DateRangeAggregation
    -> NonEmpty DateRangeAggRange -> DateRangeAggregation)
-> Lens' DateRangeAggregation (NonEmpty DateRangeAggRange)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeAggregation -> NonEmpty DateRangeAggRange
draRanges (\DateRangeAggregation
x NonEmpty DateRangeAggRange
y -> DateRangeAggregation
x {draRanges = y})

data DateRangeAggRange
  = DateRangeFrom DateMathExpr
  | DateRangeTo DateMathExpr
  | DateRangeFromAndTo DateMathExpr DateMathExpr
  deriving stock (DateRangeAggRange -> DateRangeAggRange -> Bool
(DateRangeAggRange -> DateRangeAggRange -> Bool)
-> (DateRangeAggRange -> DateRangeAggRange -> Bool)
-> Eq DateRangeAggRange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateRangeAggRange -> DateRangeAggRange -> Bool
== :: DateRangeAggRange -> DateRangeAggRange -> Bool
$c/= :: DateRangeAggRange -> DateRangeAggRange -> Bool
/= :: DateRangeAggRange -> DateRangeAggRange -> Bool
Eq, Int -> DateRangeAggRange -> ShowS
[DateRangeAggRange] -> ShowS
DateRangeAggRange -> String
(Int -> DateRangeAggRange -> ShowS)
-> (DateRangeAggRange -> String)
-> ([DateRangeAggRange] -> ShowS)
-> Show DateRangeAggRange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateRangeAggRange -> ShowS
showsPrec :: Int -> DateRangeAggRange -> ShowS
$cshow :: DateRangeAggRange -> String
show :: DateRangeAggRange -> String
$cshowList :: [DateRangeAggRange] -> ShowS
showList :: [DateRangeAggRange] -> ShowS
Show)

instance ToJSON DateRangeAggRange where
  toJSON :: DateRangeAggRange -> Value
toJSON (DateRangeFrom DateMathExpr
e) = [(Key, Value)] -> Value
object [Key
"from" Key -> DateMathExpr -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= DateMathExpr
e]
  toJSON (DateRangeTo DateMathExpr
e) = [(Key, Value)] -> Value
object [Key
"to" Key -> DateMathExpr -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= DateMathExpr
e]
  toJSON (DateRangeFromAndTo DateMathExpr
f DateMathExpr
t) = [(Key, Value)] -> Value
object [Key
"from" Key -> DateMathExpr -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= DateMathExpr
f, Key
"to" Key -> DateMathExpr -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= DateMathExpr
t]

-- | See <https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-valuecount-aggregation.html> for more information.
data ValueCountAggregation
  = FieldValueCount FieldName
  | ScriptValueCount Script
  deriving stock (ValueCountAggregation -> ValueCountAggregation -> Bool
(ValueCountAggregation -> ValueCountAggregation -> Bool)
-> (ValueCountAggregation -> ValueCountAggregation -> Bool)
-> Eq ValueCountAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ValueCountAggregation -> ValueCountAggregation -> Bool
== :: ValueCountAggregation -> ValueCountAggregation -> Bool
$c/= :: ValueCountAggregation -> ValueCountAggregation -> Bool
/= :: ValueCountAggregation -> ValueCountAggregation -> Bool
Eq, Int -> ValueCountAggregation -> ShowS
[ValueCountAggregation] -> ShowS
ValueCountAggregation -> String
(Int -> ValueCountAggregation -> ShowS)
-> (ValueCountAggregation -> String)
-> ([ValueCountAggregation] -> ShowS)
-> Show ValueCountAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ValueCountAggregation -> ShowS
showsPrec :: Int -> ValueCountAggregation -> ShowS
$cshow :: ValueCountAggregation -> String
show :: ValueCountAggregation -> String
$cshowList :: [ValueCountAggregation] -> ShowS
showList :: [ValueCountAggregation] -> ShowS
Show)

-- | Single-bucket filter aggregations. See <https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-filter-aggregation.html#search-aggregations-bucket-filter-aggregation> for more information.
data FilterAggregation = FilterAggregation
  { FilterAggregation -> Filter
faFilter :: Filter,
    FilterAggregation -> Maybe Aggregations
faAggs :: Maybe Aggregations
  }
  deriving stock (FilterAggregation -> FilterAggregation -> Bool
(FilterAggregation -> FilterAggregation -> Bool)
-> (FilterAggregation -> FilterAggregation -> Bool)
-> Eq FilterAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FilterAggregation -> FilterAggregation -> Bool
== :: FilterAggregation -> FilterAggregation -> Bool
$c/= :: FilterAggregation -> FilterAggregation -> Bool
/= :: FilterAggregation -> FilterAggregation -> Bool
Eq, Int -> FilterAggregation -> ShowS
[FilterAggregation] -> ShowS
FilterAggregation -> String
(Int -> FilterAggregation -> ShowS)
-> (FilterAggregation -> String)
-> ([FilterAggregation] -> ShowS)
-> Show FilterAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FilterAggregation -> ShowS
showsPrec :: Int -> FilterAggregation -> ShowS
$cshow :: FilterAggregation -> String
show :: FilterAggregation -> String
$cshowList :: [FilterAggregation] -> ShowS
showList :: [FilterAggregation] -> ShowS
Show)

faFilterLens :: Lens' FilterAggregation Filter
faFilterLens :: Lens' FilterAggregation Filter
faFilterLens = (FilterAggregation -> Filter)
-> (FilterAggregation -> Filter -> FilterAggregation)
-> Lens' FilterAggregation Filter
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FilterAggregation -> Filter
faFilter (\FilterAggregation
x Filter
y -> FilterAggregation
x {faFilter = y})

faAggsLens :: Lens' FilterAggregation (Maybe Aggregations)
faAggsLens :: Lens' FilterAggregation (Maybe Aggregations)
faAggsLens = (FilterAggregation -> Maybe Aggregations)
-> (FilterAggregation -> Maybe Aggregations -> FilterAggregation)
-> Lens' FilterAggregation (Maybe Aggregations)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FilterAggregation -> Maybe Aggregations
faAggs (\FilterAggregation
x Maybe Aggregations
y -> FilterAggregation
x {faAggs = y})

data StatisticsAggregation = StatisticsAggregation
  { StatisticsAggregation -> StatsType
statsType :: StatsType,
    StatisticsAggregation -> FieldName
statsField :: FieldName
  }
  deriving stock (StatisticsAggregation -> StatisticsAggregation -> Bool
(StatisticsAggregation -> StatisticsAggregation -> Bool)
-> (StatisticsAggregation -> StatisticsAggregation -> Bool)
-> Eq StatisticsAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatisticsAggregation -> StatisticsAggregation -> Bool
== :: StatisticsAggregation -> StatisticsAggregation -> Bool
$c/= :: StatisticsAggregation -> StatisticsAggregation -> Bool
/= :: StatisticsAggregation -> StatisticsAggregation -> Bool
Eq, Int -> StatisticsAggregation -> ShowS
[StatisticsAggregation] -> ShowS
StatisticsAggregation -> String
(Int -> StatisticsAggregation -> ShowS)
-> (StatisticsAggregation -> String)
-> ([StatisticsAggregation] -> ShowS)
-> Show StatisticsAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatisticsAggregation -> ShowS
showsPrec :: Int -> StatisticsAggregation -> ShowS
$cshow :: StatisticsAggregation -> String
show :: StatisticsAggregation -> String
$cshowList :: [StatisticsAggregation] -> ShowS
showList :: [StatisticsAggregation] -> ShowS
Show)

statsTypeLens :: Lens' StatisticsAggregation StatsType
statsTypeLens :: Lens' StatisticsAggregation StatsType
statsTypeLens = (StatisticsAggregation -> StatsType)
-> (StatisticsAggregation -> StatsType -> StatisticsAggregation)
-> Lens' StatisticsAggregation StatsType
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens StatisticsAggregation -> StatsType
statsType (\StatisticsAggregation
x StatsType
y -> StatisticsAggregation
x {statsType = y})

statsFieldLens :: Lens' StatisticsAggregation FieldName
statsFieldLens :: Lens' StatisticsAggregation FieldName
statsFieldLens = (StatisticsAggregation -> FieldName)
-> (StatisticsAggregation -> FieldName -> StatisticsAggregation)
-> Lens' StatisticsAggregation FieldName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens StatisticsAggregation -> FieldName
statsField (\StatisticsAggregation
x FieldName
y -> StatisticsAggregation
x {statsField = y})

data StatsType
  = Basic
  | Extended
  deriving stock (StatsType -> StatsType -> Bool
(StatsType -> StatsType -> Bool)
-> (StatsType -> StatsType -> Bool) -> Eq StatsType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatsType -> StatsType -> Bool
== :: StatsType -> StatsType -> Bool
$c/= :: StatsType -> StatsType -> Bool
/= :: StatsType -> StatsType -> Bool
Eq, Int -> StatsType -> ShowS
[StatsType] -> ShowS
StatsType -> String
(Int -> StatsType -> ShowS)
-> (StatsType -> String)
-> ([StatsType] -> ShowS)
-> Show StatsType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatsType -> ShowS
showsPrec :: Int -> StatsType -> ShowS
$cshow :: StatsType -> String
show :: StatsType -> String
$cshowList :: [StatsType] -> ShowS
showList :: [StatsType] -> ShowS
Show)

newtype SumAggregation = SumAggregation {SumAggregation -> FieldName
sumAggregationField :: FieldName}
  deriving stock (SumAggregation -> SumAggregation -> Bool
(SumAggregation -> SumAggregation -> Bool)
-> (SumAggregation -> SumAggregation -> Bool) -> Eq SumAggregation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SumAggregation -> SumAggregation -> Bool
== :: SumAggregation -> SumAggregation -> Bool
$c/= :: SumAggregation -> SumAggregation -> Bool
/= :: SumAggregation -> SumAggregation -> Bool
Eq, Int -> SumAggregation -> ShowS
[SumAggregation] -> ShowS
SumAggregation -> String
(Int -> SumAggregation -> ShowS)
-> (SumAggregation -> String)
-> ([SumAggregation] -> ShowS)
-> Show SumAggregation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SumAggregation -> ShowS
showsPrec :: Int -> SumAggregation -> ShowS
$cshow :: SumAggregation -> String
show :: SumAggregation -> String
$cshowList :: [SumAggregation] -> ShowS
showList :: [SumAggregation] -> ShowS
Show)

mkTermsAggregation :: Text -> TermsAggregation
mkTermsAggregation :: Text -> TermsAggregation
mkTermsAggregation Text
t =
  Either Text Text
-> Maybe TermInclusion
-> Maybe TermInclusion
-> Maybe TermOrder
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe CollectionMode
-> Maybe ExecutionHint
-> Maybe Aggregations
-> TermsAggregation
TermsAggregation
    (Text -> Either Text Text
forall a b. a -> Either a b
Left Text
t)
    Maybe TermInclusion
forall a. Maybe a
Nothing
    Maybe TermInclusion
forall a. Maybe a
Nothing
    Maybe TermOrder
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe Int
forall a. Maybe a
Nothing
    Maybe CollectionMode
forall a. Maybe a
Nothing
    Maybe ExecutionHint
forall a. Maybe a
Nothing
    Maybe Aggregations
forall a. Maybe a
Nothing

mkTermsScriptAggregation :: Text -> TermsAggregation
mkTermsScriptAggregation :: Text -> TermsAggregation
mkTermsScriptAggregation Text
t = Either Text Text
-> Maybe TermInclusion
-> Maybe TermInclusion
-> Maybe TermOrder
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe CollectionMode
-> Maybe ExecutionHint
-> Maybe Aggregations
-> TermsAggregation
TermsAggregation (Text -> Either Text Text
forall a b. b -> Either a b
Right Text
t) Maybe TermInclusion
forall a. Maybe a
Nothing Maybe TermInclusion
forall a. Maybe a
Nothing Maybe TermOrder
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe CollectionMode
forall a. Maybe a
Nothing Maybe ExecutionHint
forall a. Maybe a
Nothing Maybe Aggregations
forall a. Maybe a
Nothing

mkDateHistogram :: FieldName -> Interval -> DateHistogramAggregation
mkDateHistogram :: FieldName -> Interval -> DateHistogramAggregation
mkDateHistogram FieldName
t Interval
i = FieldName
-> Interval
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Aggregations
-> DateHistogramAggregation
DateHistogramAggregation FieldName
t Interval
i Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Aggregations
forall a. Maybe a
Nothing

mkCardinalityAggregation :: FieldName -> CardinalityAggregation
mkCardinalityAggregation :: FieldName -> CardinalityAggregation
mkCardinalityAggregation FieldName
t = FieldName -> Maybe Int -> CardinalityAggregation
CardinalityAggregation FieldName
t Maybe Int
forall a. Maybe a
Nothing

mkStatsAggregation :: FieldName -> StatisticsAggregation
mkStatsAggregation :: FieldName -> StatisticsAggregation
mkStatsAggregation = StatsType -> FieldName -> StatisticsAggregation
StatisticsAggregation StatsType
Basic

mkExtendedStatsAggregation :: FieldName -> StatisticsAggregation
mkExtendedStatsAggregation :: FieldName -> StatisticsAggregation
mkExtendedStatsAggregation = StatsType -> FieldName -> StatisticsAggregation
StatisticsAggregation StatsType
Extended

type AggregationResults = M.Map Key Value

class BucketAggregation a where
  key :: a -> BucketValue
  docCount :: a -> Int
  aggs :: a -> Maybe AggregationResults

data Bucket a = Bucket
  { forall a. Bucket a -> [a]
buckets :: [a]
  }
  deriving (ReadPrec [Bucket a]
ReadPrec (Bucket a)
Int -> ReadS (Bucket a)
ReadS [Bucket a]
(Int -> ReadS (Bucket a))
-> ReadS [Bucket a]
-> ReadPrec (Bucket a)
-> ReadPrec [Bucket a]
-> Read (Bucket a)
forall a. Read a => ReadPrec [Bucket a]
forall a. Read a => ReadPrec (Bucket a)
forall a. Read a => Int -> ReadS (Bucket a)
forall a. Read a => ReadS [Bucket a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Bucket a)
readsPrec :: Int -> ReadS (Bucket a)
$creadList :: forall a. Read a => ReadS [Bucket a]
readList :: ReadS [Bucket a]
$creadPrec :: forall a. Read a => ReadPrec (Bucket a)
readPrec :: ReadPrec (Bucket a)
$creadListPrec :: forall a. Read a => ReadPrec [Bucket a]
readListPrec :: ReadPrec [Bucket a]
Read, Int -> Bucket a -> ShowS
[Bucket a] -> ShowS
Bucket a -> String
(Int -> Bucket a -> ShowS)
-> (Bucket a -> String) -> ([Bucket a] -> ShowS) -> Show (Bucket a)
forall a. Show a => Int -> Bucket a -> ShowS
forall a. Show a => [Bucket a] -> ShowS
forall a. Show a => Bucket a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Bucket a -> ShowS
showsPrec :: Int -> Bucket a -> ShowS
$cshow :: forall a. Show a => Bucket a -> String
show :: Bucket a -> String
$cshowList :: forall a. Show a => [Bucket a] -> ShowS
showList :: [Bucket a] -> ShowS
Show)

instance (FromJSON a) => FromJSON (Bucket a) where
  parseJSON :: Value -> Parser (Bucket a)
parseJSON (Object Object
v) =
    [a] -> Bucket a
forall a. [a] -> Bucket a
Bucket
      ([a] -> Bucket a) -> Parser [a] -> Parser (Bucket a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser [a]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"buckets"
  parseJSON Value
_ = Parser (Bucket a)
forall a. Monoid a => a
mempty

bucketsLens :: Lens' (Bucket a) [a]
bucketsLens :: forall a. Lens' (Bucket a) [a]
bucketsLens = (Bucket a -> [a])
-> (Bucket a -> [a] -> Bucket a)
-> Lens (Bucket a) (Bucket a) [a] [a]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Bucket a -> [a]
forall a. Bucket a -> [a]
buckets (\Bucket a
x [a]
y -> Bucket a
x {buckets = y})

data BucketValue
  = TextValue Text
  | ScientificValue Scientific
  | BoolValue Bool
  deriving (ReadPrec [BucketValue]
ReadPrec BucketValue
Int -> ReadS BucketValue
ReadS [BucketValue]
(Int -> ReadS BucketValue)
-> ReadS [BucketValue]
-> ReadPrec BucketValue
-> ReadPrec [BucketValue]
-> Read BucketValue
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BucketValue
readsPrec :: Int -> ReadS BucketValue
$creadList :: ReadS [BucketValue]
readList :: ReadS [BucketValue]
$creadPrec :: ReadPrec BucketValue
readPrec :: ReadPrec BucketValue
$creadListPrec :: ReadPrec [BucketValue]
readListPrec :: ReadPrec [BucketValue]
Read, Int -> BucketValue -> ShowS
[BucketValue] -> ShowS
BucketValue -> String
(Int -> BucketValue -> ShowS)
-> (BucketValue -> String)
-> ([BucketValue] -> ShowS)
-> Show BucketValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BucketValue -> ShowS
showsPrec :: Int -> BucketValue -> ShowS
$cshow :: BucketValue -> String
show :: BucketValue -> String
$cshowList :: [BucketValue] -> ShowS
showList :: [BucketValue] -> ShowS
Show)

instance FromJSON BucketValue where
  parseJSON :: Value -> Parser BucketValue
parseJSON (String Text
t) = BucketValue -> Parser BucketValue
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (BucketValue -> Parser BucketValue)
-> BucketValue -> Parser BucketValue
forall a b. (a -> b) -> a -> b
$ Text -> BucketValue
TextValue Text
t
  parseJSON (Number Scientific
s) = BucketValue -> Parser BucketValue
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (BucketValue -> Parser BucketValue)
-> BucketValue -> Parser BucketValue
forall a b. (a -> b) -> a -> b
$ Scientific -> BucketValue
ScientificValue Scientific
s
  parseJSON (Bool Bool
b) = BucketValue -> Parser BucketValue
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (BucketValue -> Parser BucketValue)
-> BucketValue -> Parser BucketValue
forall a b. (a -> b) -> a -> b
$ Bool -> BucketValue
BoolValue Bool
b
  parseJSON Value
_ = Parser BucketValue
forall a. Monoid a => a
mempty

data TermInclusion
  = TermInclusion Text
  | TermPattern Text Text
  deriving stock (TermInclusion -> TermInclusion -> Bool
(TermInclusion -> TermInclusion -> Bool)
-> (TermInclusion -> TermInclusion -> Bool) -> Eq TermInclusion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TermInclusion -> TermInclusion -> Bool
== :: TermInclusion -> TermInclusion -> Bool
$c/= :: TermInclusion -> TermInclusion -> Bool
/= :: TermInclusion -> TermInclusion -> Bool
Eq, Int -> TermInclusion -> ShowS
[TermInclusion] -> ShowS
TermInclusion -> String
(Int -> TermInclusion -> ShowS)
-> (TermInclusion -> String)
-> ([TermInclusion] -> ShowS)
-> Show TermInclusion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TermInclusion -> ShowS
showsPrec :: Int -> TermInclusion -> ShowS
$cshow :: TermInclusion -> String
show :: TermInclusion -> String
$cshowList :: [TermInclusion] -> ShowS
showList :: [TermInclusion] -> ShowS
Show)

instance ToJSON TermInclusion where
  toJSON :: TermInclusion -> Value
toJSON (TermInclusion Text
x) = Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
x
  toJSON (TermPattern Text
pattern Text
flags) =
    [(Key, Value)] -> Value
omitNulls
      [ Key
"pattern" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
pattern,
        Key
"flags" Key -> Text -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
flags
      ]

data TermOrder = TermOrder
  { TermOrder -> Text
termSortField :: Text,
    TermOrder -> SortOrder
termSortOrder :: SortOrder
  }
  deriving stock (TermOrder -> TermOrder -> Bool
(TermOrder -> TermOrder -> Bool)
-> (TermOrder -> TermOrder -> Bool) -> Eq TermOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TermOrder -> TermOrder -> Bool
== :: TermOrder -> TermOrder -> Bool
$c/= :: TermOrder -> TermOrder -> Bool
/= :: TermOrder -> TermOrder -> Bool
Eq, Int -> TermOrder -> ShowS
[TermOrder] -> ShowS
TermOrder -> String
(Int -> TermOrder -> ShowS)
-> (TermOrder -> String)
-> ([TermOrder] -> ShowS)
-> Show TermOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TermOrder -> ShowS
showsPrec :: Int -> TermOrder -> ShowS
$cshow :: TermOrder -> String
show :: TermOrder -> String
$cshowList :: [TermOrder] -> ShowS
showList :: [TermOrder] -> ShowS
Show)

instance ToJSON TermOrder where
  toJSON :: TermOrder -> Value
toJSON (TermOrder Text
termSortField SortOrder
termSortOrder) =
    [(Key, Value)] -> Value
object [Text -> Key
fromText Text
termSortField Key -> SortOrder -> (Key, Value)
forall v. ToJSON v => Key -> v -> (Key, Value)
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= SortOrder
termSortOrder]

termSortFieldLens :: Lens' TermOrder Text
termSortFieldLens :: Lens' TermOrder Text
termSortFieldLens = (TermOrder -> Text)
-> (TermOrder -> Text -> TermOrder) -> Lens' TermOrder Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermOrder -> Text
termSortField (\TermOrder
x Text
y -> TermOrder
x {termSortField = y})

termSortOrderLens :: Lens' TermOrder SortOrder
termSortOrderLens :: Lens' TermOrder SortOrder
termSortOrderLens = (TermOrder -> SortOrder)
-> (TermOrder -> SortOrder -> TermOrder)
-> Lens' TermOrder SortOrder
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermOrder -> SortOrder
termSortOrder (\TermOrder
x SortOrder
y -> TermOrder
x {termSortOrder = y})

data CollectionMode
  = BreadthFirst
  | DepthFirst
  deriving stock (CollectionMode -> CollectionMode -> Bool
(CollectionMode -> CollectionMode -> Bool)
-> (CollectionMode -> CollectionMode -> Bool) -> Eq CollectionMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CollectionMode -> CollectionMode -> Bool
== :: CollectionMode -> CollectionMode -> Bool
$c/= :: CollectionMode -> CollectionMode -> Bool
/= :: CollectionMode -> CollectionMode -> Bool
Eq, Int -> CollectionMode -> ShowS
[CollectionMode] -> ShowS
CollectionMode -> String
(Int -> CollectionMode -> ShowS)
-> (CollectionMode -> String)
-> ([CollectionMode] -> ShowS)
-> Show CollectionMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CollectionMode -> ShowS
showsPrec :: Int -> CollectionMode -> ShowS
$cshow :: CollectionMode -> String
show :: CollectionMode -> String
$cshowList :: [CollectionMode] -> ShowS
showList :: [CollectionMode] -> ShowS
Show)

instance ToJSON CollectionMode where
  toJSON :: CollectionMode -> Value
toJSON CollectionMode
BreadthFirst = Value
"breadth_first"
  toJSON CollectionMode
DepthFirst = Value
"depth_first"

data ExecutionHint
  = GlobalOrdinals
  | Map
  deriving stock (ExecutionHint -> ExecutionHint -> Bool
(ExecutionHint -> ExecutionHint -> Bool)
-> (ExecutionHint -> ExecutionHint -> Bool) -> Eq ExecutionHint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExecutionHint -> ExecutionHint -> Bool
== :: ExecutionHint -> ExecutionHint -> Bool
$c/= :: ExecutionHint -> ExecutionHint -> Bool
/= :: ExecutionHint -> ExecutionHint -> Bool
Eq, Int -> ExecutionHint -> ShowS
[ExecutionHint] -> ShowS
ExecutionHint -> String
(Int -> ExecutionHint -> ShowS)
-> (ExecutionHint -> String)
-> ([ExecutionHint] -> ShowS)
-> Show ExecutionHint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExecutionHint -> ShowS
showsPrec :: Int -> ExecutionHint -> ShowS
$cshow :: ExecutionHint -> String
show :: ExecutionHint -> String
$cshowList :: [ExecutionHint] -> ShowS
showList :: [ExecutionHint] -> ShowS
Show)

instance ToJSON ExecutionHint where
  toJSON :: ExecutionHint -> Value
toJSON ExecutionHint
GlobalOrdinals = Value
"global_ordinals"
  toJSON ExecutionHint
Map = Value
"map"

-- | See <https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#date-math> for more information.
data DateMathExpr
  = DateMathExpr DateMathAnchor [DateMathModifier]
  deriving stock (DateMathExpr -> DateMathExpr -> Bool
(DateMathExpr -> DateMathExpr -> Bool)
-> (DateMathExpr -> DateMathExpr -> Bool) -> Eq DateMathExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateMathExpr -> DateMathExpr -> Bool
== :: DateMathExpr -> DateMathExpr -> Bool
$c/= :: DateMathExpr -> DateMathExpr -> Bool
/= :: DateMathExpr -> DateMathExpr -> Bool
Eq, Int -> DateMathExpr -> ShowS
[DateMathExpr] -> ShowS
DateMathExpr -> String
(Int -> DateMathExpr -> ShowS)
-> (DateMathExpr -> String)
-> ([DateMathExpr] -> ShowS)
-> Show DateMathExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateMathExpr -> ShowS
showsPrec :: Int -> DateMathExpr -> ShowS
$cshow :: DateMathExpr -> String
show :: DateMathExpr -> String
$cshowList :: [DateMathExpr] -> ShowS
showList :: [DateMathExpr] -> ShowS
Show)

instance ToJSON DateMathExpr where
  toJSON :: DateMathExpr -> Value
toJSON (DateMathExpr DateMathAnchor
a [DateMathModifier]
mods) = Text -> Value
String (DateMathAnchor -> Text
fmtA DateMathAnchor
a Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Text] -> Text
forall a. Monoid a => [a] -> a
mconcat (DateMathModifier -> Text
fmtMod (DateMathModifier -> Text) -> [DateMathModifier] -> [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DateMathModifier]
mods))
    where
      fmtA :: DateMathAnchor -> Text
fmtA DateMathAnchor
DMNow = Text
"now"
      fmtA (DMDate Day
date) = (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Day -> String
showGregorian Day
date) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"||"
      fmtMod :: DateMathModifier -> Text
fmtMod (AddTime Int
n DateMathUnit
u) = Text
"+" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall a. Show a => a -> Text
showText Int
n Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> DateMathUnit -> Text
forall {a}. IsString a => DateMathUnit -> a
fmtU DateMathUnit
u
      fmtMod (SubtractTime Int
n DateMathUnit
u) = Text
"-" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall a. Show a => a -> Text
showText Int
n Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> DateMathUnit -> Text
forall {a}. IsString a => DateMathUnit -> a
fmtU DateMathUnit
u
      fmtMod (RoundDownTo DateMathUnit
u) = Text
"/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> DateMathUnit -> Text
forall {a}. IsString a => DateMathUnit -> a
fmtU DateMathUnit
u
      fmtU :: DateMathUnit -> a
fmtU DateMathUnit
DMYear = a
"y"
      fmtU DateMathUnit
DMMonth = a
"M"
      fmtU DateMathUnit
DMWeek = a
"w"
      fmtU DateMathUnit
DMDay = a
"d"
      fmtU DateMathUnit
DMHour = a
"h"
      fmtU DateMathUnit
DMMinute = a
"m"
      fmtU DateMathUnit
DMSecond = a
"s"

-- | Starting point for a date range. This along with the 'DateMathModifiers' gets you the date ES will start from.
data DateMathAnchor
  = DMNow
  | DMDate Day
  deriving stock (DateMathAnchor -> DateMathAnchor -> Bool
(DateMathAnchor -> DateMathAnchor -> Bool)
-> (DateMathAnchor -> DateMathAnchor -> Bool) -> Eq DateMathAnchor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateMathAnchor -> DateMathAnchor -> Bool
== :: DateMathAnchor -> DateMathAnchor -> Bool
$c/= :: DateMathAnchor -> DateMathAnchor -> Bool
/= :: DateMathAnchor -> DateMathAnchor -> Bool
Eq, Int -> DateMathAnchor -> ShowS
[DateMathAnchor] -> ShowS
DateMathAnchor -> String
(Int -> DateMathAnchor -> ShowS)
-> (DateMathAnchor -> String)
-> ([DateMathAnchor] -> ShowS)
-> Show DateMathAnchor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateMathAnchor -> ShowS
showsPrec :: Int -> DateMathAnchor -> ShowS
$cshow :: DateMathAnchor -> String
show :: DateMathAnchor -> String
$cshowList :: [DateMathAnchor] -> ShowS
showList :: [DateMathAnchor] -> ShowS
Show)

data DateMathModifier
  = AddTime Int DateMathUnit
  | SubtractTime Int DateMathUnit
  | RoundDownTo DateMathUnit
  deriving stock (DateMathModifier -> DateMathModifier -> Bool
(DateMathModifier -> DateMathModifier -> Bool)
-> (DateMathModifier -> DateMathModifier -> Bool)
-> Eq DateMathModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateMathModifier -> DateMathModifier -> Bool
== :: DateMathModifier -> DateMathModifier -> Bool
$c/= :: DateMathModifier -> DateMathModifier -> Bool
/= :: DateMathModifier -> DateMathModifier -> Bool
Eq, Int -> DateMathModifier -> ShowS
[DateMathModifier] -> ShowS
DateMathModifier -> String
(Int -> DateMathModifier -> ShowS)
-> (DateMathModifier -> String)
-> ([DateMathModifier] -> ShowS)
-> Show DateMathModifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateMathModifier -> ShowS
showsPrec :: Int -> DateMathModifier -> ShowS
$cshow :: DateMathModifier -> String
show :: DateMathModifier -> String
$cshowList :: [DateMathModifier] -> ShowS
showList :: [DateMathModifier] -> ShowS
Show)

data DateMathUnit
  = DMYear
  | DMMonth
  | DMWeek
  | DMDay
  | DMHour
  | DMMinute
  | DMSecond
  deriving stock (DateMathUnit -> DateMathUnit -> Bool
(DateMathUnit -> DateMathUnit -> Bool)
-> (DateMathUnit -> DateMathUnit -> Bool) -> Eq DateMathUnit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateMathUnit -> DateMathUnit -> Bool
== :: DateMathUnit -> DateMathUnit -> Bool
$c/= :: DateMathUnit -> DateMathUnit -> Bool
/= :: DateMathUnit -> DateMathUnit -> Bool
Eq, Int -> DateMathUnit -> ShowS
[DateMathUnit] -> ShowS
DateMathUnit -> String
(Int -> DateMathUnit -> ShowS)
-> (DateMathUnit -> String)
-> ([DateMathUnit] -> ShowS)
-> Show DateMathUnit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateMathUnit -> ShowS
showsPrec :: Int -> DateMathUnit -> ShowS
$cshow :: DateMathUnit -> String
show :: DateMathUnit -> String
$cshowList :: [DateMathUnit] -> ShowS
showList :: [DateMathUnit] -> ShowS
Show)

data TermsResult = TermsResult
  { TermsResult -> BucketValue
termKey :: BucketValue,
    TermsResult -> Int
termsDocCount :: Int,
    TermsResult -> Maybe AggregationResults
termsAggs :: Maybe AggregationResults
  }
  deriving (ReadPrec [TermsResult]
ReadPrec TermsResult
Int -> ReadS TermsResult
ReadS [TermsResult]
(Int -> ReadS TermsResult)
-> ReadS [TermsResult]
-> ReadPrec TermsResult
-> ReadPrec [TermsResult]
-> Read TermsResult
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TermsResult
readsPrec :: Int -> ReadS TermsResult
$creadList :: ReadS [TermsResult]
readList :: ReadS [TermsResult]
$creadPrec :: ReadPrec TermsResult
readPrec :: ReadPrec TermsResult
$creadListPrec :: ReadPrec [TermsResult]
readListPrec :: ReadPrec [TermsResult]
Read, Int -> TermsResult -> ShowS
[TermsResult] -> ShowS
TermsResult -> String
(Int -> TermsResult -> ShowS)
-> (TermsResult -> String)
-> ([TermsResult] -> ShowS)
-> Show TermsResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TermsResult -> ShowS
showsPrec :: Int -> TermsResult -> ShowS
$cshow :: TermsResult -> String
show :: TermsResult -> String
$cshowList :: [TermsResult] -> ShowS
showList :: [TermsResult] -> ShowS
Show)

instance FromJSON TermsResult where
  parseJSON :: Value -> Parser TermsResult
parseJSON (Object Object
v) =
    BucketValue -> Int -> Maybe AggregationResults -> TermsResult
TermsResult
      (BucketValue -> Int -> Maybe AggregationResults -> TermsResult)
-> Parser BucketValue
-> Parser (Int -> Maybe AggregationResults -> TermsResult)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser BucketValue
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key"
      Parser (Int -> Maybe AggregationResults -> TermsResult)
-> Parser Int -> Parser (Maybe AggregationResults -> TermsResult)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"doc_count"
      Parser (Maybe AggregationResults -> TermsResult)
-> Parser (Maybe AggregationResults) -> Parser TermsResult
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Maybe AggregationResults -> Parser (Maybe AggregationResults)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe AggregationResults -> Parser (Maybe AggregationResults))
-> Maybe AggregationResults -> Parser (Maybe AggregationResults)
forall a b. (a -> b) -> a -> b
$ Object -> [Key] -> Maybe AggregationResults
getNamedSubAgg Object
v [Key
"key", Key
"doc_count"])
  parseJSON Value
_ = Parser TermsResult
forall a. Monoid a => a
mempty

instance BucketAggregation TermsResult where
  key :: TermsResult -> BucketValue
key = TermsResult -> BucketValue
termKey
  docCount :: TermsResult -> Int
docCount = TermsResult -> Int
termsDocCount
  aggs :: TermsResult -> Maybe AggregationResults
aggs = TermsResult -> Maybe AggregationResults
termsAggs

termKeyLens :: Lens' TermsResult BucketValue
termKeyLens :: Lens' TermsResult BucketValue
termKeyLens = (TermsResult -> BucketValue)
-> (TermsResult -> BucketValue -> TermsResult)
-> Lens' TermsResult BucketValue
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsResult -> BucketValue
termKey (\TermsResult
x BucketValue
y -> TermsResult
x {termKey = y})

termsDocCountLens :: Lens' TermsResult Int
termsDocCountLens :: Lens' TermsResult Int
termsDocCountLens = (TermsResult -> Int)
-> (TermsResult -> Int -> TermsResult) -> Lens' TermsResult Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsResult -> Int
termsDocCount (\TermsResult
x Int
y -> TermsResult
x {termsDocCount = y})

termsAggsLens :: Lens' TermsResult (Maybe AggregationResults)
termsAggsLens :: Lens' TermsResult (Maybe AggregationResults)
termsAggsLens = (TermsResult -> Maybe AggregationResults)
-> (TermsResult -> Maybe AggregationResults -> TermsResult)
-> Lens' TermsResult (Maybe AggregationResults)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TermsResult -> Maybe AggregationResults
termsAggs (\TermsResult
x Maybe AggregationResults
y -> TermsResult
x {termsAggs = y})

data DateHistogramResult = DateHistogramResult
  { DateHistogramResult -> Int
dateKey :: Int,
    DateHistogramResult -> Maybe Text
dateKeyStr :: Maybe Text,
    DateHistogramResult -> Int
dateDocCount :: Int,
    DateHistogramResult -> Maybe AggregationResults
dateHistogramAggs :: Maybe AggregationResults
  }
  deriving (Int -> DateHistogramResult -> ShowS
[DateHistogramResult] -> ShowS
DateHistogramResult -> String
(Int -> DateHistogramResult -> ShowS)
-> (DateHistogramResult -> String)
-> ([DateHistogramResult] -> ShowS)
-> Show DateHistogramResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateHistogramResult -> ShowS
showsPrec :: Int -> DateHistogramResult -> ShowS
$cshow :: DateHistogramResult -> String
show :: DateHistogramResult -> String
$cshowList :: [DateHistogramResult] -> ShowS
showList :: [DateHistogramResult] -> ShowS
Show)

instance FromJSON DateHistogramResult where
  parseJSON :: Value -> Parser DateHistogramResult
parseJSON (Object Object
v) =
    Int
-> Maybe Text
-> Int
-> Maybe AggregationResults
-> DateHistogramResult
DateHistogramResult
      (Int
 -> Maybe Text
 -> Int
 -> Maybe AggregationResults
 -> DateHistogramResult)
-> Parser Int
-> Parser
     (Maybe Text
      -> Int -> Maybe AggregationResults -> DateHistogramResult)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key"
      Parser
  (Maybe Text
   -> Int -> Maybe AggregationResults -> DateHistogramResult)
-> Parser (Maybe Text)
-> Parser (Int -> Maybe AggregationResults -> DateHistogramResult)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"key_as_string"
      Parser (Int -> Maybe AggregationResults -> DateHistogramResult)
-> Parser Int
-> Parser (Maybe AggregationResults -> DateHistogramResult)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"doc_count"
      Parser (Maybe AggregationResults -> DateHistogramResult)
-> Parser (Maybe AggregationResults) -> Parser DateHistogramResult
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( Maybe AggregationResults -> Parser (Maybe AggregationResults)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe AggregationResults -> Parser (Maybe AggregationResults))
-> Maybe AggregationResults -> Parser (Maybe AggregationResults)
forall a b. (a -> b) -> a -> b
$
              Object -> [Key] -> Maybe AggregationResults
getNamedSubAgg
                Object
v
                [ Key
"key",
                  Key
"doc_count",
                  Key
"key_as_string"
                ]
          )
  parseJSON Value
_ = Parser DateHistogramResult
forall a. Monoid a => a
mempty

instance BucketAggregation DateHistogramResult where
  key :: DateHistogramResult -> BucketValue
key = Text -> BucketValue
TextValue (Text -> BucketValue)
-> (DateHistogramResult -> Text)
-> DateHistogramResult
-> BucketValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text
forall a. Show a => a -> Text
showText (Int -> Text)
-> (DateHistogramResult -> Int) -> DateHistogramResult -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DateHistogramResult -> Int
dateKey
  docCount :: DateHistogramResult -> Int
docCount = DateHistogramResult -> Int
dateDocCount
  aggs :: DateHistogramResult -> Maybe AggregationResults
aggs = DateHistogramResult -> Maybe AggregationResults
dateHistogramAggs

dateKeyLens :: Lens' DateHistogramResult Int
dateKeyLens :: Lens' DateHistogramResult Int
dateKeyLens = (DateHistogramResult -> Int)
-> (DateHistogramResult -> Int -> DateHistogramResult)
-> Lens' DateHistogramResult Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramResult -> Int
dateKey (\DateHistogramResult
x Int
y -> DateHistogramResult
x {dateKey = y})

dateKeyStrLens :: Lens' DateHistogramResult (Maybe Text)
dateKeyStrLens :: Lens' DateHistogramResult (Maybe Text)
dateKeyStrLens = (DateHistogramResult -> Maybe Text)
-> (DateHistogramResult -> Maybe Text -> DateHistogramResult)
-> Lens' DateHistogramResult (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramResult -> Maybe Text
dateKeyStr (\DateHistogramResult
x Maybe Text
y -> DateHistogramResult
x {dateKeyStr = y})

dateDocCountLens :: Lens' DateHistogramResult Int
dateDocCountLens :: Lens' DateHistogramResult Int
dateDocCountLens = (DateHistogramResult -> Int)
-> (DateHistogramResult -> Int -> DateHistogramResult)
-> Lens' DateHistogramResult Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramResult -> Int
dateDocCount (\DateHistogramResult
x Int
y -> DateHistogramResult
x {dateDocCount = y})

dateHistogramAggsLens :: Lens' DateHistogramResult (Maybe AggregationResults)
dateHistogramAggsLens :: Lens' DateHistogramResult (Maybe AggregationResults)
dateHistogramAggsLens = (DateHistogramResult -> Maybe AggregationResults)
-> (DateHistogramResult
    -> Maybe AggregationResults -> DateHistogramResult)
-> Lens' DateHistogramResult (Maybe AggregationResults)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateHistogramResult -> Maybe AggregationResults
dateHistogramAggs (\DateHistogramResult
x Maybe AggregationResults
y -> DateHistogramResult
x {dateHistogramAggs = y})

data DateRangeResult = DateRangeResult
  { DateRangeResult -> Text
dateRangeKey :: Text,
    DateRangeResult -> Maybe UTCTime
dateRangeFrom :: Maybe UTCTime,
    DateRangeResult -> Maybe Text
dateRangeFromAsString :: Maybe Text,
    DateRangeResult -> Maybe UTCTime
dateRangeTo :: Maybe UTCTime,
    DateRangeResult -> Maybe Text
dateRangeToAsString :: Maybe Text,
    DateRangeResult -> Int
dateRangeDocCount :: Int,
    DateRangeResult -> Maybe AggregationResults
dateRangeAggs :: Maybe AggregationResults
  }
  deriving stock (DateRangeResult -> DateRangeResult -> Bool
(DateRangeResult -> DateRangeResult -> Bool)
-> (DateRangeResult -> DateRangeResult -> Bool)
-> Eq DateRangeResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateRangeResult -> DateRangeResult -> Bool
== :: DateRangeResult -> DateRangeResult -> Bool
$c/= :: DateRangeResult -> DateRangeResult -> Bool
/= :: DateRangeResult -> DateRangeResult -> Bool
Eq, Int -> DateRangeResult -> ShowS
[DateRangeResult] -> ShowS
DateRangeResult -> String
(Int -> DateRangeResult -> ShowS)
-> (DateRangeResult -> String)
-> ([DateRangeResult] -> ShowS)
-> Show DateRangeResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateRangeResult -> ShowS
showsPrec :: Int -> DateRangeResult -> ShowS
$cshow :: DateRangeResult -> String
show :: DateRangeResult -> String
$cshowList :: [DateRangeResult] -> ShowS
showList :: [DateRangeResult] -> ShowS
Show)

instance FromJSON DateRangeResult where
  parseJSON :: Value -> Parser DateRangeResult
parseJSON = String
-> (Object -> Parser DateRangeResult)
-> Value
-> Parser DateRangeResult
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"DateRangeResult" Object -> Parser DateRangeResult
parse
    where
      parse :: Object -> Parser DateRangeResult
parse Object
v =
        Text
-> Maybe UTCTime
-> Maybe Text
-> Maybe UTCTime
-> Maybe Text
-> Int
-> Maybe AggregationResults
-> DateRangeResult
DateRangeResult
          (Text
 -> Maybe UTCTime
 -> Maybe Text
 -> Maybe UTCTime
 -> Maybe Text
 -> Int
 -> Maybe AggregationResults
 -> DateRangeResult)
-> Parser Text
-> Parser
     (Maybe UTCTime
      -> Maybe Text
      -> Maybe UTCTime
      -> Maybe Text
      -> Int
      -> Maybe AggregationResults
      -> DateRangeResult)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key"
          Parser
  (Maybe UTCTime
   -> Maybe Text
   -> Maybe UTCTime
   -> Maybe Text
   -> Int
   -> Maybe AggregationResults
   -> DateRangeResult)
-> Parser (Maybe UTCTime)
-> Parser
     (Maybe Text
      -> Maybe UTCTime
      -> Maybe Text
      -> Int
      -> Maybe AggregationResults
      -> DateRangeResult)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((POSIXMS -> UTCTime) -> Maybe POSIXMS -> Maybe UTCTime
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap POSIXMS -> UTCTime
posixMS (Maybe POSIXMS -> Maybe UTCTime)
-> Parser (Maybe POSIXMS) -> Parser (Maybe UTCTime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser (Maybe POSIXMS)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"from")
          Parser
  (Maybe Text
   -> Maybe UTCTime
   -> Maybe Text
   -> Int
   -> Maybe AggregationResults
   -> DateRangeResult)
-> Parser (Maybe Text)
-> Parser
     (Maybe UTCTime
      -> Maybe Text
      -> Int
      -> Maybe AggregationResults
      -> DateRangeResult)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"from_as_string"
          Parser
  (Maybe UTCTime
   -> Maybe Text
   -> Int
   -> Maybe AggregationResults
   -> DateRangeResult)
-> Parser (Maybe UTCTime)
-> Parser
     (Maybe Text -> Int -> Maybe AggregationResults -> DateRangeResult)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((POSIXMS -> UTCTime) -> Maybe POSIXMS -> Maybe UTCTime
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap POSIXMS -> UTCTime
posixMS (Maybe POSIXMS -> Maybe UTCTime)
-> Parser (Maybe POSIXMS) -> Parser (Maybe UTCTime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser (Maybe POSIXMS)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"to")
          Parser
  (Maybe Text -> Int -> Maybe AggregationResults -> DateRangeResult)
-> Parser (Maybe Text)
-> Parser (Int -> Maybe AggregationResults -> DateRangeResult)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"to_as_string"
          Parser (Int -> Maybe AggregationResults -> DateRangeResult)
-> Parser Int
-> Parser (Maybe AggregationResults -> DateRangeResult)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"doc_count"
          Parser (Maybe AggregationResults -> DateRangeResult)
-> Parser (Maybe AggregationResults) -> Parser DateRangeResult
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( Maybe AggregationResults -> Parser (Maybe AggregationResults)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe AggregationResults -> Parser (Maybe AggregationResults))
-> Maybe AggregationResults -> Parser (Maybe AggregationResults)
forall a b. (a -> b) -> a -> b
$
                  Object -> [Key] -> Maybe AggregationResults
getNamedSubAgg
                    Object
v
                    [ Key
"key",
                      Key
"from",
                      Key
"from_as_string",
                      Key
"to",
                      Key
"to_as_string",
                      Key
"doc_count"
                    ]
              )

instance BucketAggregation DateRangeResult where
  key :: DateRangeResult -> BucketValue
key = Text -> BucketValue
TextValue (Text -> BucketValue)
-> (DateRangeResult -> Text) -> DateRangeResult -> BucketValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DateRangeResult -> Text
dateRangeKey
  docCount :: DateRangeResult -> Int
docCount = DateRangeResult -> Int
dateRangeDocCount
  aggs :: DateRangeResult -> Maybe AggregationResults
aggs = DateRangeResult -> Maybe AggregationResults
dateRangeAggs

dateRangeKeyLens :: Lens' DateRangeResult Text
dateRangeKeyLens :: Lens' DateRangeResult Text
dateRangeKeyLens = (DateRangeResult -> Text)
-> (DateRangeResult -> Text -> DateRangeResult)
-> Lens' DateRangeResult Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeResult -> Text
dateRangeKey (\DateRangeResult
x Text
y -> DateRangeResult
x {dateRangeKey = y})

dateRangeFromLens :: Lens' DateRangeResult (Maybe UTCTime)
dateRangeFromLens :: Lens' DateRangeResult (Maybe UTCTime)
dateRangeFromLens = (DateRangeResult -> Maybe UTCTime)
-> (DateRangeResult -> Maybe UTCTime -> DateRangeResult)
-> Lens' DateRangeResult (Maybe UTCTime)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeResult -> Maybe UTCTime
dateRangeFrom (\DateRangeResult
x Maybe UTCTime
y -> DateRangeResult
x {dateRangeFrom = y})

dateRangeFromAsStringLens :: Lens' DateRangeResult (Maybe Text)
dateRangeFromAsStringLens :: Lens' DateRangeResult (Maybe Text)
dateRangeFromAsStringLens = (DateRangeResult -> Maybe Text)
-> (DateRangeResult -> Maybe Text -> DateRangeResult)
-> Lens' DateRangeResult (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeResult -> Maybe Text
dateRangeFromAsString (\DateRangeResult
x Maybe Text
y -> DateRangeResult
x {dateRangeFromAsString = y})

dateRangeToLens :: Lens' DateRangeResult (Maybe UTCTime)
dateRangeToLens :: Lens' DateRangeResult (Maybe UTCTime)
dateRangeToLens = (DateRangeResult -> Maybe UTCTime)
-> (DateRangeResult -> Maybe UTCTime -> DateRangeResult)
-> Lens' DateRangeResult (Maybe UTCTime)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeResult -> Maybe UTCTime
dateRangeTo (\DateRangeResult
x Maybe UTCTime
y -> DateRangeResult
x {dateRangeTo = y})

dateRangeToAsStringLens :: Lens' DateRangeResult (Maybe Text)
dateRangeToAsStringLens :: Lens' DateRangeResult (Maybe Text)
dateRangeToAsStringLens = (DateRangeResult -> Maybe Text)
-> (DateRangeResult -> Maybe Text -> DateRangeResult)
-> Lens' DateRangeResult (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeResult -> Maybe Text
dateRangeToAsString (\DateRangeResult
x Maybe Text
y -> DateRangeResult
x {dateRangeToAsString = y})

dateRangeDocCountLens :: Lens' DateRangeResult Int
dateRangeDocCountLens :: Lens' DateRangeResult Int
dateRangeDocCountLens = (DateRangeResult -> Int)
-> (DateRangeResult -> Int -> DateRangeResult)
-> Lens' DateRangeResult Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeResult -> Int
dateRangeDocCount (\DateRangeResult
x Int
y -> DateRangeResult
x {dateRangeDocCount = y})

dateRangeAggsLens :: Lens' DateRangeResult (Maybe AggregationResults)
dateRangeAggsLens :: Lens' DateRangeResult (Maybe AggregationResults)
dateRangeAggsLens = (DateRangeResult -> Maybe AggregationResults)
-> (DateRangeResult -> Maybe AggregationResults -> DateRangeResult)
-> Lens' DateRangeResult (Maybe AggregationResults)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens DateRangeResult -> Maybe AggregationResults
dateRangeAggs (\DateRangeResult
x Maybe AggregationResults
y -> DateRangeResult
x {dateRangeAggs = y})

toTerms :: Key -> AggregationResults -> Maybe (Bucket TermsResult)
toTerms :: Key -> AggregationResults -> Maybe (Bucket TermsResult)
toTerms = Key -> AggregationResults -> Maybe (Bucket TermsResult)
forall a. FromJSON a => Key -> AggregationResults -> Maybe a
toAggResult

toDateHistogram :: Key -> AggregationResults -> Maybe (Bucket DateHistogramResult)
toDateHistogram :: Key -> AggregationResults -> Maybe (Bucket DateHistogramResult)
toDateHistogram = Key -> AggregationResults -> Maybe (Bucket DateHistogramResult)
forall a. FromJSON a => Key -> AggregationResults -> Maybe a
toAggResult

toMissing :: Key -> AggregationResults -> Maybe MissingResult
toMissing :: Key -> AggregationResults -> Maybe MissingResult
toMissing = Key -> AggregationResults -> Maybe MissingResult
forall a. FromJSON a => Key -> AggregationResults -> Maybe a
toAggResult

toTopHits :: (FromJSON a) => Key -> AggregationResults -> Maybe (TopHitResult a)
toTopHits :: forall a.
FromJSON a =>
Key -> AggregationResults -> Maybe (TopHitResult a)
toTopHits = Key -> AggregationResults -> Maybe (TopHitResult a)
forall a. FromJSON a => Key -> AggregationResults -> Maybe a
toAggResult

toAggResult :: (FromJSON a) => Key -> AggregationResults -> Maybe a
toAggResult :: forall a. FromJSON a => Key -> AggregationResults -> Maybe a
toAggResult Key
t AggregationResults
a = Key -> AggregationResults -> Maybe Value
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Key
t AggregationResults
a Maybe Value -> (Value -> Maybe a) -> Maybe a
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Maybe a
deserialize
  where
    deserialize :: Value -> Maybe a
deserialize = (Value -> Parser a) -> Value -> Maybe a
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser a
forall a. FromJSON a => Value -> Parser a
parseJSON

-- Try to get an AggregationResults when we don't know the
-- field name. We filter out the known keys to try to minimize the noise.
getNamedSubAgg :: Object -> [Key] -> Maybe AggregationResults
getNamedSubAgg :: Object -> [Key] -> Maybe AggregationResults
getNamedSubAgg Object
o [Key]
knownKeys = Maybe AggregationResults
maggRes
  where
    unknownKeys :: Object
unknownKeys = (Key -> Value -> Bool) -> Object -> Object
forall v. (Key -> v -> Bool) -> KeyMap v -> KeyMap v
X.filterWithKey (\Key
k Value
_ -> Key
k Key -> [Key] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Key]
knownKeys) Object
o
    maggRes :: Maybe AggregationResults
maggRes
      | Object -> Bool
forall v. KeyMap v -> Bool
X.null Object
unknownKeys = Maybe AggregationResults
forall a. Maybe a
Nothing
      | Bool
otherwise = AggregationResults -> Maybe AggregationResults
forall a. a -> Maybe a
Just (AggregationResults -> Maybe AggregationResults)
-> ([(Key, Value)] -> AggregationResults)
-> [(Key, Value)]
-> Maybe AggregationResults
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Key, Value)] -> AggregationResults
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(Key, Value)] -> Maybe AggregationResults)
-> [(Key, Value)] -> Maybe AggregationResults
forall a b. (a -> b) -> a -> b
$ Object -> [(Key, Value)]
forall v. KeyMap v -> [(Key, v)]
X.toList Object
unknownKeys

data MissingResult = MissingResult
  { MissingResult -> Int
missingDocCount :: Int
  }
  deriving (Int -> MissingResult -> ShowS
[MissingResult] -> ShowS
MissingResult -> String
(Int -> MissingResult -> ShowS)
-> (MissingResult -> String)
-> ([MissingResult] -> ShowS)
-> Show MissingResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MissingResult -> ShowS
showsPrec :: Int -> MissingResult -> ShowS
$cshow :: MissingResult -> String
show :: MissingResult -> String
$cshowList :: [MissingResult] -> ShowS
showList :: [MissingResult] -> ShowS
Show)

instance FromJSON MissingResult where
  parseJSON :: Value -> Parser MissingResult
parseJSON = String
-> (Object -> Parser MissingResult)
-> Value
-> Parser MissingResult
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MissingResult" Object -> Parser MissingResult
parse
    where
      parse :: Object -> Parser MissingResult
parse Object
v = Int -> MissingResult
MissingResult (Int -> MissingResult) -> Parser Int -> Parser MissingResult
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"doc_count"

data TopHitResult a = TopHitResult
  { forall a. TopHitResult a -> SearchHits a
tarHits :: (SearchHits a)
  }
  deriving stock (TopHitResult a -> TopHitResult a -> Bool
(TopHitResult a -> TopHitResult a -> Bool)
-> (TopHitResult a -> TopHitResult a -> Bool)
-> Eq (TopHitResult a)
forall a. Eq a => TopHitResult a -> TopHitResult a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => TopHitResult a -> TopHitResult a -> Bool
== :: TopHitResult a -> TopHitResult a -> Bool
$c/= :: forall a. Eq a => TopHitResult a -> TopHitResult a -> Bool
/= :: TopHitResult a -> TopHitResult a -> Bool
Eq, Int -> TopHitResult a -> ShowS
[TopHitResult a] -> ShowS
TopHitResult a -> String
(Int -> TopHitResult a -> ShowS)
-> (TopHitResult a -> String)
-> ([TopHitResult a] -> ShowS)
-> Show (TopHitResult a)
forall a. Show a => Int -> TopHitResult a -> ShowS
forall a. Show a => [TopHitResult a] -> ShowS
forall a. Show a => TopHitResult a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> TopHitResult a -> ShowS
showsPrec :: Int -> TopHitResult a -> ShowS
$cshow :: forall a. Show a => TopHitResult a -> String
show :: TopHitResult a -> String
$cshowList :: forall a. Show a => [TopHitResult a] -> ShowS
showList :: [TopHitResult a] -> ShowS
Show)

instance (FromJSON a) => FromJSON (TopHitResult a) where
  parseJSON :: Value -> Parser (TopHitResult a)
parseJSON (Object Object
v) =
    SearchHits a -> TopHitResult a
forall a. SearchHits a -> TopHitResult a
TopHitResult
      (SearchHits a -> TopHitResult a)
-> Parser (SearchHits a) -> Parser (TopHitResult a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser (SearchHits a)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"hits"
  parseJSON Value
_ = String -> Parser (TopHitResult a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Failure in FromJSON (TopHitResult a)"

data HitsTotalRelation = HTR_EQ | HTR_GTE deriving stock (HitsTotalRelation -> HitsTotalRelation -> Bool
(HitsTotalRelation -> HitsTotalRelation -> Bool)
-> (HitsTotalRelation -> HitsTotalRelation -> Bool)
-> Eq HitsTotalRelation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HitsTotalRelation -> HitsTotalRelation -> Bool
== :: HitsTotalRelation -> HitsTotalRelation -> Bool
$c/= :: HitsTotalRelation -> HitsTotalRelation -> Bool
/= :: HitsTotalRelation -> HitsTotalRelation -> Bool
Eq, Int -> HitsTotalRelation -> ShowS
[HitsTotalRelation] -> ShowS
HitsTotalRelation -> String
(Int -> HitsTotalRelation -> ShowS)
-> (HitsTotalRelation -> String)
-> ([HitsTotalRelation] -> ShowS)
-> Show HitsTotalRelation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HitsTotalRelation -> ShowS
showsPrec :: Int -> HitsTotalRelation -> ShowS
$cshow :: HitsTotalRelation -> String
show :: HitsTotalRelation -> String
$cshowList :: [HitsTotalRelation] -> ShowS
showList :: [HitsTotalRelation] -> ShowS
Show)

instance FromJSON HitsTotalRelation where
  parseJSON :: Value -> Parser HitsTotalRelation
parseJSON (String Text
"eq") = HitsTotalRelation -> Parser HitsTotalRelation
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure HitsTotalRelation
HTR_EQ
  parseJSON (String Text
"gte") = HitsTotalRelation -> Parser HitsTotalRelation
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure HitsTotalRelation
HTR_GTE
  parseJSON Value
_ = Parser HitsTotalRelation
forall a. Parser a
forall (f :: * -> *) a. Alternative f => f a
empty

data HitsTotal = HitsTotal
  { HitsTotal -> Int
value :: Int,
    HitsTotal -> HitsTotalRelation
relation :: HitsTotalRelation
  }
  deriving stock (HitsTotal -> HitsTotal -> Bool
(HitsTotal -> HitsTotal -> Bool)
-> (HitsTotal -> HitsTotal -> Bool) -> Eq HitsTotal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HitsTotal -> HitsTotal -> Bool
== :: HitsTotal -> HitsTotal -> Bool
$c/= :: HitsTotal -> HitsTotal -> Bool
/= :: HitsTotal -> HitsTotal -> Bool
Eq, Int -> HitsTotal -> ShowS
[HitsTotal] -> ShowS
HitsTotal -> String
(Int -> HitsTotal -> ShowS)
-> (HitsTotal -> String)
-> ([HitsTotal] -> ShowS)
-> Show HitsTotal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HitsTotal -> ShowS
showsPrec :: Int -> HitsTotal -> ShowS
$cshow :: HitsTotal -> String
show :: HitsTotal -> String
$cshowList :: [HitsTotal] -> ShowS
showList :: [HitsTotal] -> ShowS
Show)

instance FromJSON HitsTotal where
  parseJSON :: Value -> Parser HitsTotal
parseJSON (Object Object
v) =
    Int -> HitsTotalRelation -> HitsTotal
HitsTotal
      (Int -> HitsTotalRelation -> HitsTotal)
-> Parser Int -> Parser (HitsTotalRelation -> HitsTotal)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
      Parser (HitsTotalRelation -> HitsTotal)
-> Parser HitsTotalRelation -> Parser HitsTotal
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser HitsTotalRelation
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"relation"
  parseJSON Value
_ = Parser HitsTotal
forall a. Parser a
forall (f :: * -> *) a. Alternative f => f a
empty

instance Semigroup HitsTotal where
  (HitsTotal Int
ta HitsTotalRelation
HTR_EQ) <> :: HitsTotal -> HitsTotal -> HitsTotal
<> (HitsTotal Int
tb HitsTotalRelation
HTR_EQ) = Int -> HitsTotalRelation -> HitsTotal
HitsTotal (Int
ta Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
tb) HitsTotalRelation
HTR_EQ
  (HitsTotal Int
ta HitsTotalRelation
HTR_GTE) <> (HitsTotal Int
tb HitsTotalRelation
_) = Int -> HitsTotalRelation -> HitsTotal
HitsTotal (Int
ta Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
tb) HitsTotalRelation
HTR_GTE
  (HitsTotal Int
ta HitsTotalRelation
_) <> (HitsTotal Int
tb HitsTotalRelation
HTR_GTE) = Int -> HitsTotalRelation -> HitsTotal
HitsTotal (Int
ta Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
tb) HitsTotalRelation
HTR_GTE

hitsTotalValueLens :: Lens' HitsTotal Int
hitsTotalValueLens :: Lens' HitsTotal Int
hitsTotalValueLens = (HitsTotal -> Int)
-> (HitsTotal -> Int -> HitsTotal) -> Lens' HitsTotal Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens HitsTotal -> Int
value (\HitsTotal
x Int
y -> HitsTotal
x {value = y})

hitsTotalRelationLens :: Lens' HitsTotal HitsTotalRelation
hitsTotalRelationLens :: Lens' HitsTotal HitsTotalRelation
hitsTotalRelationLens = (HitsTotal -> HitsTotalRelation)
-> (HitsTotal -> HitsTotalRelation -> HitsTotal)
-> Lens' HitsTotal HitsTotalRelation
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens HitsTotal -> HitsTotalRelation
relation (\HitsTotal
x HitsTotalRelation
y -> HitsTotal
x {relation = y})

data SearchHits a = SearchHits
  { forall a. SearchHits a -> HitsTotal
hitsTotal :: HitsTotal,
    forall a. SearchHits a -> Score
maxScore :: Score,
    forall a. SearchHits a -> [Hit a]
hits :: [Hit a]
  }
  deriving stock (SearchHits a -> SearchHits a -> Bool
(SearchHits a -> SearchHits a -> Bool)
-> (SearchHits a -> SearchHits a -> Bool) -> Eq (SearchHits a)
forall a. Eq a => SearchHits a -> SearchHits a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => SearchHits a -> SearchHits a -> Bool
== :: SearchHits a -> SearchHits a -> Bool
$c/= :: forall a. Eq a => SearchHits a -> SearchHits a -> Bool
/= :: SearchHits a -> SearchHits a -> Bool
Eq, Int -> SearchHits a -> ShowS
[SearchHits a] -> ShowS
SearchHits a -> String
(Int -> SearchHits a -> ShowS)
-> (SearchHits a -> String)
-> ([SearchHits a] -> ShowS)
-> Show (SearchHits a)
forall a. Show a => Int -> SearchHits a -> ShowS
forall a. Show a => [SearchHits a] -> ShowS
forall a. Show a => SearchHits a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> SearchHits a -> ShowS
showsPrec :: Int -> SearchHits a -> ShowS
$cshow :: forall a. Show a => SearchHits a -> String
show :: SearchHits a -> String
$cshowList :: forall a. Show a => [SearchHits a] -> ShowS
showList :: [SearchHits a] -> ShowS
Show)

instance (FromJSON a) => FromJSON (SearchHits a) where
  parseJSON :: Value -> Parser (SearchHits a)
parseJSON (Object Object
v) =
    HitsTotal -> Score -> [Hit a] -> SearchHits a
forall a. HitsTotal -> Score -> [Hit a] -> SearchHits a
SearchHits
      (HitsTotal -> Score -> [Hit a] -> SearchHits a)
-> Parser HitsTotal -> Parser (Score -> [Hit a] -> SearchHits a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser HitsTotal
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total"
      Parser (Score -> [Hit a] -> SearchHits a)
-> Parser Score -> Parser ([Hit a] -> SearchHits a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Score
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_score"
      Parser ([Hit a] -> SearchHits a)
-> Parser [Hit a] -> Parser (SearchHits a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [Hit a]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"hits"
  parseJSON Value
_ = Parser (SearchHits a)
forall a. Parser a
forall (f :: * -> *) a. Alternative f => f a
empty

instance Semigroup (SearchHits a) where
  (SearchHits HitsTotal
ta Score
ma [Hit a]
ha) <> :: SearchHits a -> SearchHits a -> SearchHits a
<> (SearchHits HitsTotal
tb Score
mb [Hit a]
hb) =
    HitsTotal -> Score -> [Hit a] -> SearchHits a
forall a. HitsTotal -> Score -> [Hit a] -> SearchHits a
SearchHits (HitsTotal
ta HitsTotal -> HitsTotal -> HitsTotal
forall a. Semigroup a => a -> a -> a
<> HitsTotal
tb) (Score -> Score -> Score
forall a. Ord a => a -> a -> a
max Score
ma Score
mb) ([Hit a]
ha [Hit a] -> [Hit a] -> [Hit a]
forall a. Semigroup a => a -> a -> a
<> [Hit a]
hb)

instance Monoid (SearchHits a) where
  mempty :: SearchHits a
mempty = HitsTotal -> Score -> [Hit a] -> SearchHits a
forall a. HitsTotal -> Score -> [Hit a] -> SearchHits a
SearchHits (Int -> HitsTotalRelation -> HitsTotal
HitsTotal Int
0 HitsTotalRelation
HTR_EQ) Score
forall a. Maybe a
Nothing [Hit a]
forall a. Monoid a => a
mempty
  mappend :: SearchHits a -> SearchHits a -> SearchHits a
mappend = SearchHits a -> SearchHits a -> SearchHits a
forall a. Semigroup a => a -> a -> a
(<>)

searchHitsHitsTotalLens :: Lens' (SearchHits a) HitsTotal
searchHitsHitsTotalLens :: forall a. Lens' (SearchHits a) HitsTotal
searchHitsHitsTotalLens = (SearchHits a -> HitsTotal)
-> (SearchHits a -> HitsTotal -> SearchHits a)
-> Lens (SearchHits a) (SearchHits a) HitsTotal HitsTotal
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens SearchHits a -> HitsTotal
forall a. SearchHits a -> HitsTotal
hitsTotal (\SearchHits a
x HitsTotal
y -> SearchHits a
x {hitsTotal = y})

searchHitsMaxScoreLens :: Lens' (SearchHits a) Score
searchHitsMaxScoreLens :: forall a. Lens' (SearchHits a) Score
searchHitsMaxScoreLens = (SearchHits a -> Score)
-> (SearchHits a -> Score -> SearchHits a)
-> Lens (SearchHits a) (SearchHits a) Score Score
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens SearchHits a -> Score
forall a. SearchHits a -> Score
maxScore (\SearchHits a
x Score
y -> SearchHits a
x {maxScore = y})

searchHitsHitsLens :: Lens' (SearchHits a) [Hit a]
searchHitsHitsLens :: forall a. Lens' (SearchHits a) [Hit a]
searchHitsHitsLens = (SearchHits a -> [Hit a])
-> (SearchHits a -> [Hit a] -> SearchHits a)
-> Lens (SearchHits a) (SearchHits a) [Hit a] [Hit a]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens SearchHits a -> [Hit a]
forall a. SearchHits a -> [Hit a]
hits (\SearchHits a
x [Hit a]
y -> SearchHits a
x {hits = y})

type SearchAfterKey = [Aeson.Value]

data Hit a = Hit
  { forall a. Hit a -> IndexName
hitIndex :: IndexName,
    forall a. Hit a -> DocId
hitDocId :: DocId,
    forall a. Hit a -> Score
hitScore :: Score,
    forall a. Hit a -> Maybe a
hitSource :: Maybe a,
    forall a. Hit a -> Maybe SearchAfterKey
hitSort :: Maybe SearchAfterKey,
    forall a. Hit a -> Maybe HitFields
hitFields :: Maybe HitFields,
    forall a. Hit a -> Maybe HitHighlight
hitHighlight :: Maybe HitHighlight,
    forall a. Hit a -> Maybe (KeyMap (TopHitResult Value))
hitInnerHits :: Maybe (X.KeyMap (TopHitResult Value))
  }
  deriving stock (Hit a -> Hit a -> Bool
(Hit a -> Hit a -> Bool) -> (Hit a -> Hit a -> Bool) -> Eq (Hit a)
forall a. Eq a => Hit a -> Hit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Hit a -> Hit a -> Bool
== :: Hit a -> Hit a -> Bool
$c/= :: forall a. Eq a => Hit a -> Hit a -> Bool
/= :: Hit a -> Hit a -> Bool
Eq, Int -> Hit a -> ShowS
[Hit a] -> ShowS
Hit a -> String
(Int -> Hit a -> ShowS)
-> (Hit a -> String) -> ([Hit a] -> ShowS) -> Show (Hit a)
forall a. Show a => Int -> Hit a -> ShowS
forall a. Show a => [Hit a] -> ShowS
forall a. Show a => Hit a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Hit a -> ShowS
showsPrec :: Int -> Hit a -> ShowS
$cshow :: forall a. Show a => Hit a -> String
show :: Hit a -> String
$cshowList :: forall a. Show a => [Hit a] -> ShowS
showList :: [Hit a] -> ShowS
Show)

instance (FromJSON a) => FromJSON (Hit a) where
  parseJSON :: Value -> Parser (Hit a)
parseJSON (Object Object
v) =
    IndexName
-> DocId
-> Score
-> Maybe a
-> Maybe SearchAfterKey
-> Maybe HitFields
-> Maybe HitHighlight
-> Maybe (KeyMap (TopHitResult Value))
-> Hit a
forall a.
IndexName
-> DocId
-> Score
-> Maybe a
-> Maybe SearchAfterKey
-> Maybe HitFields
-> Maybe HitHighlight
-> Maybe (KeyMap (TopHitResult Value))
-> Hit a
Hit
      (IndexName
 -> DocId
 -> Score
 -> Maybe a
 -> Maybe SearchAfterKey
 -> Maybe HitFields
 -> Maybe HitHighlight
 -> Maybe (KeyMap (TopHitResult Value))
 -> Hit a)
-> Parser IndexName
-> Parser
     (DocId
      -> Score
      -> Maybe a
      -> Maybe SearchAfterKey
      -> Maybe HitFields
      -> Maybe HitHighlight
      -> Maybe (KeyMap (TopHitResult Value))
      -> Hit a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser IndexName
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"_index"
      Parser
  (DocId
   -> Score
   -> Maybe a
   -> Maybe SearchAfterKey
   -> Maybe HitFields
   -> Maybe HitHighlight
   -> Maybe (KeyMap (TopHitResult Value))
   -> Hit a)
-> Parser DocId
-> Parser
     (Score
      -> Maybe a
      -> Maybe SearchAfterKey
      -> Maybe HitFields
      -> Maybe HitHighlight
      -> Maybe (KeyMap (TopHitResult Value))
      -> Hit a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser DocId
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"_id"
      Parser
  (Score
   -> Maybe a
   -> Maybe SearchAfterKey
   -> Maybe HitFields
   -> Maybe HitHighlight
   -> Maybe (KeyMap (TopHitResult Value))
   -> Hit a)
-> Parser Score
-> Parser
     (Maybe a
      -> Maybe SearchAfterKey
      -> Maybe HitFields
      -> Maybe HitHighlight
      -> Maybe (KeyMap (TopHitResult Value))
      -> Hit a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Score
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"_score"
      Parser
  (Maybe a
   -> Maybe SearchAfterKey
   -> Maybe HitFields
   -> Maybe HitHighlight
   -> Maybe (KeyMap (TopHitResult Value))
   -> Hit a)
-> Parser (Maybe a)
-> Parser
     (Maybe SearchAfterKey
      -> Maybe HitFields
      -> Maybe HitHighlight
      -> Maybe (KeyMap (TopHitResult Value))
      -> Hit a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe a)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_source"
      Parser
  (Maybe SearchAfterKey
   -> Maybe HitFields
   -> Maybe HitHighlight
   -> Maybe (KeyMap (TopHitResult Value))
   -> Hit a)
-> Parser (Maybe SearchAfterKey)
-> Parser
     (Maybe HitFields
      -> Maybe HitHighlight
      -> Maybe (KeyMap (TopHitResult Value))
      -> Hit a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe SearchAfterKey)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"sort"
      Parser
  (Maybe HitFields
   -> Maybe HitHighlight
   -> Maybe (KeyMap (TopHitResult Value))
   -> Hit a)
-> Parser (Maybe HitFields)
-> Parser
     (Maybe HitHighlight
      -> Maybe (KeyMap (TopHitResult Value)) -> Hit a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe HitFields)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields"
      Parser
  (Maybe HitHighlight
   -> Maybe (KeyMap (TopHitResult Value)) -> Hit a)
-> Parser (Maybe HitHighlight)
-> Parser (Maybe (KeyMap (TopHitResult Value)) -> Hit a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe HitHighlight)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"highlight"
      Parser (Maybe (KeyMap (TopHitResult Value)) -> Hit a)
-> Parser (Maybe (KeyMap (TopHitResult Value))) -> Parser (Hit a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe (KeyMap (TopHitResult Value)))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inner_hits"
  parseJSON Value
_ = Parser (Hit a)
forall a. Parser a
forall (f :: * -> *) a. Alternative f => f a
empty

hitIndexLens :: Lens' (Hit a) IndexName
hitIndexLens :: forall a. Lens' (Hit a) IndexName
hitIndexLens = (Hit a -> IndexName)
-> (Hit a -> IndexName -> Hit a)
-> Lens (Hit a) (Hit a) IndexName IndexName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Hit a -> IndexName
forall a. Hit a -> IndexName
hitIndex (\Hit a
x IndexName
y -> Hit a
x {hitIndex = y})

hitDocIdLens :: Lens' (Hit a) DocId
hitDocIdLens :: forall a. Lens' (Hit a) DocId
hitDocIdLens = (Hit a -> DocId)
-> (Hit a -> DocId -> Hit a) -> Lens (Hit a) (Hit a) DocId DocId
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Hit a -> DocId
forall a. Hit a -> DocId
hitDocId (\Hit a
x DocId
y -> Hit a
x {hitDocId = y})

hitScoreLens :: Lens' (Hit a) Score
hitScoreLens :: forall a. Lens' (Hit a) Score
hitScoreLens = (Hit a -> Score)
-> (Hit a -> Score -> Hit a) -> Lens (Hit a) (Hit a) Score Score
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Hit a -> Score
forall a. Hit a -> Score
hitScore (\Hit a
x Score
y -> Hit a
x {hitScore = y})

hitSourceLens :: Lens' (Hit a) (Maybe a)
hitSourceLens :: forall a. Lens' (Hit a) (Maybe a)
hitSourceLens = (Hit a -> Maybe a)
-> (Hit a -> Maybe a -> Hit a)
-> Lens (Hit a) (Hit a) (Maybe a) (Maybe a)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Hit a -> Maybe a
forall a. Hit a -> Maybe a
hitSource (\Hit a
x Maybe a
y -> Hit a
x {hitSource = y})

hitSortLens :: Lens' (Hit a) (Maybe SearchAfterKey)
hitSortLens :: forall a. Lens' (Hit a) (Maybe SearchAfterKey)
hitSortLens = (Hit a -> Maybe SearchAfterKey)
-> (Hit a -> Maybe SearchAfterKey -> Hit a)
-> Lens
     (Hit a) (Hit a) (Maybe SearchAfterKey) (Maybe SearchAfterKey)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Hit a -> Maybe SearchAfterKey
forall a. Hit a -> Maybe SearchAfterKey
hitSort (\Hit a
x Maybe SearchAfterKey
y -> Hit a
x {hitSort = y})

hitFieldsLens :: Lens' (Hit a) (Maybe HitFields)
hitFieldsLens :: forall a. Lens' (Hit a) (Maybe HitFields)
hitFieldsLens = (Hit a -> Maybe HitFields)
-> (Hit a -> Maybe HitFields -> Hit a)
-> Lens (Hit a) (Hit a) (Maybe HitFields) (Maybe HitFields)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Hit a -> Maybe HitFields
forall a. Hit a -> Maybe HitFields
hitFields (\Hit a
x Maybe HitFields
y -> Hit a
x {hitFields = y})

hitHighlightLens :: Lens' (Hit a) (Maybe HitHighlight)
hitHighlightLens :: forall a. Lens' (Hit a) (Maybe HitHighlight)
hitHighlightLens = (Hit a -> Maybe HitHighlight)
-> (Hit a -> Maybe HitHighlight -> Hit a)
-> Lens (Hit a) (Hit a) (Maybe HitHighlight) (Maybe HitHighlight)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Hit a -> Maybe HitHighlight
forall a. Hit a -> Maybe HitHighlight
hitHighlight (\Hit a
x Maybe HitHighlight
y -> Hit a
x {hitHighlight = y})

hitInnerHitsLens :: Lens' (Hit a) (Maybe (X.KeyMap (TopHitResult Value)))
hitInnerHitsLens :: forall a. Lens' (Hit a) (Maybe (KeyMap (TopHitResult Value)))
hitInnerHitsLens = (Hit a -> Maybe (KeyMap (TopHitResult Value)))
-> (Hit a -> Maybe (KeyMap (TopHitResult Value)) -> Hit a)
-> Lens
     (Hit a)
     (Hit a)
     (Maybe (KeyMap (TopHitResult Value)))
     (Maybe (KeyMap (TopHitResult Value)))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Hit a -> Maybe (KeyMap (TopHitResult Value))
forall a. Hit a -> Maybe (KeyMap (TopHitResult Value))
hitInnerHits (\Hit a
x Maybe (KeyMap (TopHitResult Value))
y -> Hit a
x {hitInnerHits = y})