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

module Database.Bloodhound.Internal.Aggregation where

import Bloodhound.Import
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.Client
import Database.Bloodhound.Internal.Highlight (HitHighlight)
import Database.Bloodhound.Internal.Newtypes
import Database.Bloodhound.Internal.Query
import Database.Bloodhound.Internal.Sort

type Aggregations = M.Map Key Aggregation

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

mkAggregations :: Key -> Aggregation -> Aggregations
mkAggregations :: Key -> Aggregation -> Aggregations
mkAggregations Key
name Aggregation
aggregation = 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 (Aggregation -> Aggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Aggregation -> Aggregation -> Bool
$c/= :: Aggregation -> Aggregation -> Bool
== :: Aggregation -> Aggregation -> Bool
$c== :: Aggregation -> Aggregation -> Bool
Eq, Int -> Aggregation -> ShowS
[Aggregation] -> ShowS
Aggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Aggregation] -> ShowS
$cshowList :: [Aggregation] -> ShowS
show :: Aggregation -> String
$cshow :: Aggregation -> String
showsPrec :: Int -> Aggregation -> ShowS
$cshowsPrec :: Int -> 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"
          forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls
            [ forall {kv} {v} {v}.
(KeyValue kv, ToJSON v, ToJSON v) =>
Either v v -> kv
toJSON' Either Text Text
term,
              Key
"include" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe TermInclusion
include,
              Key
"exclude" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe TermInclusion
exclude,
              Key
"order" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe TermOrder
order,
              Key
"min_doc_count" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Int
minDocCount,
              Key
"size" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Int
size,
              Key
"shard_size" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Int
shardSize,
              Key
"collect_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe CollectionMode
collectMode,
              Key
"execution_hint" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe ExecutionHint
executionHint
            ],
        Key
"aggs" forall kv v. (KeyValue 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" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= v
y; Right v
y -> Key
"script" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= v
y
  toJSON (CardinalityAgg (CardinalityAggregation FieldName
field Maybe Int
precisionThreshold)) =
    [(Key, Value)] -> Value
object
      [ Key
"cardinality"
          forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls
            [ Key
"field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FieldName
field,
              Key
"precisionThreshold" forall kv v. (KeyValue 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"
            forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls
              [ Key
"field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FieldName
field,
                Key
"interval" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Interval
interval,
                Key
"format" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
format,
                Key
"pre_zone" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
preZone,
                Key
"post_zone" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
postZone,
                Key
"pre_offset" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
preOffset,
                Key
"post_offset" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
postOffset
              ],
          Key
"aggs" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Aggregations
dateHistoAggs
        ]
  toJSON (ValueCountAgg ValueCountAggregation
a) = [(Key, Value)] -> Value
object [Key
"value_count" forall kv v. (KeyValue 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" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
n]
        (ScriptValueCount Script
s) ->
          [(Key, Value)] -> Value
object [Key
"script" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Script
s]
  toJSON (FilterAgg (FilterAggregation Filter
filt Maybe Aggregations
ags)) =
    [(Key, Value)] -> Value
omitNulls
      [ Key
"filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Filter
filt,
        Key
"aggs" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Aggregations
ags
      ]
  toJSON (DateRangeAgg DateRangeAggregation
a) =
    [(Key, Value)] -> Value
object
      [ Key
"date_range" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= DateRangeAggregation
a
      ]
  toJSON (MissingAgg (MissingAggregation {Text
maField :: MissingAggregation -> Text
maField :: Text
..})) =
    [(Key, Value)] -> Value
object [Key
"missing" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
object [Key
"field" forall kv v. (KeyValue 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"
          forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls
            [ Key
"size" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Size
msize,
              Key
"from" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe From
mfrom,
              Key
"sort" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Sort
msort
            ]
      ]
  toJSON (StatsAgg (StatisticsAggregation StatsType
typ FieldName
field)) =
    [(Key, Value)] -> Value
object [Key
stType forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls [Key
"field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FieldName
field]]
    where
      stType :: Key
stType
        | StatsType
typ 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" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [(Key, Value)] -> Value
omitNulls [Key
"field" forall kv v. (KeyValue 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 (TopHitsAggregation -> TopHitsAggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TopHitsAggregation -> TopHitsAggregation -> Bool
$c/= :: TopHitsAggregation -> TopHitsAggregation -> Bool
== :: TopHitsAggregation -> TopHitsAggregation -> Bool
$c== :: TopHitsAggregation -> TopHitsAggregation -> Bool
Eq, Int -> TopHitsAggregation -> ShowS
[TopHitsAggregation] -> ShowS
TopHitsAggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TopHitsAggregation] -> ShowS
$cshowList :: [TopHitsAggregation] -> ShowS
show :: TopHitsAggregation -> String
$cshow :: TopHitsAggregation -> String
showsPrec :: Int -> TopHitsAggregation -> ShowS
$cshowsPrec :: Int -> TopHitsAggregation -> ShowS
Show)

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

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 (TermsAggregation -> TermsAggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TermsAggregation -> TermsAggregation -> Bool
$c/= :: TermsAggregation -> TermsAggregation -> Bool
== :: TermsAggregation -> TermsAggregation -> Bool
$c== :: TermsAggregation -> TermsAggregation -> Bool
Eq, Int -> TermsAggregation -> ShowS
[TermsAggregation] -> ShowS
TermsAggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TermsAggregation] -> ShowS
$cshowList :: [TermsAggregation] -> ShowS
show :: TermsAggregation -> String
$cshow :: TermsAggregation -> String
showsPrec :: Int -> TermsAggregation -> ShowS
$cshowsPrec :: Int -> TermsAggregation -> ShowS
Show)

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

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 (DateHistogramAggregation -> DateHistogramAggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DateHistogramAggregation -> DateHistogramAggregation -> Bool
$c/= :: DateHistogramAggregation -> DateHistogramAggregation -> Bool
== :: DateHistogramAggregation -> DateHistogramAggregation -> Bool
$c== :: DateHistogramAggregation -> DateHistogramAggregation -> Bool
Eq, Int -> DateHistogramAggregation -> ShowS
[DateHistogramAggregation] -> ShowS
DateHistogramAggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DateHistogramAggregation] -> ShowS
$cshowList :: [DateHistogramAggregation] -> ShowS
show :: DateHistogramAggregation -> String
$cshow :: DateHistogramAggregation -> String
showsPrec :: Int -> DateHistogramAggregation -> ShowS
$cshowsPrec :: Int -> DateHistogramAggregation -> ShowS
Show)

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

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

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

instance ToJSON DateRangeAggRange where
  toJSON :: DateRangeAggRange -> Value
toJSON (DateRangeFrom DateMathExpr
e) = [(Key, Value)] -> Value
object [Key
"from" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= DateMathExpr
e]
  toJSON (DateRangeTo DateMathExpr
e) = [(Key, Value)] -> Value
object [Key
"to" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= DateMathExpr
e]
  toJSON (DateRangeFromAndTo DateMathExpr
f DateMathExpr
t) = [(Key, Value)] -> Value
object [Key
"from" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= DateMathExpr
f, Key
"to" forall kv v. (KeyValue 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 (ValueCountAggregation -> ValueCountAggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ValueCountAggregation -> ValueCountAggregation -> Bool
$c/= :: ValueCountAggregation -> ValueCountAggregation -> Bool
== :: ValueCountAggregation -> ValueCountAggregation -> Bool
$c== :: ValueCountAggregation -> ValueCountAggregation -> Bool
Eq, Int -> ValueCountAggregation -> ShowS
[ValueCountAggregation] -> ShowS
ValueCountAggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ValueCountAggregation] -> ShowS
$cshowList :: [ValueCountAggregation] -> ShowS
show :: ValueCountAggregation -> String
$cshow :: ValueCountAggregation -> String
showsPrec :: Int -> ValueCountAggregation -> ShowS
$cshowsPrec :: Int -> 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 (FilterAggregation -> FilterAggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FilterAggregation -> FilterAggregation -> Bool
$c/= :: FilterAggregation -> FilterAggregation -> Bool
== :: FilterAggregation -> FilterAggregation -> Bool
$c== :: FilterAggregation -> FilterAggregation -> Bool
Eq, Int -> FilterAggregation -> ShowS
[FilterAggregation] -> ShowS
FilterAggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FilterAggregation] -> ShowS
$cshowList :: [FilterAggregation] -> ShowS
show :: FilterAggregation -> String
$cshow :: FilterAggregation -> String
showsPrec :: Int -> FilterAggregation -> ShowS
$cshowsPrec :: Int -> FilterAggregation -> ShowS
Show)

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

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

newtype SumAggregation = SumAggregation {SumAggregation -> FieldName
sumAggregationField :: FieldName}
  deriving (SumAggregation -> SumAggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SumAggregation -> SumAggregation -> Bool
$c/= :: SumAggregation -> SumAggregation -> Bool
== :: SumAggregation -> SumAggregation -> Bool
$c== :: SumAggregation -> SumAggregation -> Bool
Eq, Int -> SumAggregation -> ShowS
[SumAggregation] -> ShowS
SumAggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SumAggregation] -> ShowS
$cshowList :: [SumAggregation] -> ShowS
show :: SumAggregation -> String
$cshow :: SumAggregation -> String
showsPrec :: Int -> SumAggregation -> ShowS
$cshowsPrec :: Int -> 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
    (forall a b. a -> Either a b
Left Text
t)
    forall a. Maybe a
Nothing
    forall a. Maybe a
Nothing
    forall a. Maybe a
Nothing
    forall a. Maybe a
Nothing
    forall a. Maybe a
Nothing
    forall a. Maybe a
Nothing
    forall a. Maybe a
Nothing
    forall a. Maybe a
Nothing
    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 (forall a b. b -> Either a b
Right Text
t) forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing 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 forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing

mkCardinalityAggregation :: FieldName -> CardinalityAggregation
mkCardinalityAggregation :: FieldName -> CardinalityAggregation
mkCardinalityAggregation FieldName
t = FieldName -> Maybe Int -> CardinalityAggregation
CardinalityAggregation FieldName
t 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)
ReadS [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
readListPrec :: ReadPrec [Bucket a]
$creadListPrec :: forall a. Read a => ReadPrec [Bucket a]
readPrec :: ReadPrec (Bucket a)
$creadPrec :: forall a. Read a => ReadPrec (Bucket a)
readList :: ReadS [Bucket a]
$creadList :: forall a. Read a => ReadS [Bucket a]
readsPrec :: Int -> ReadS (Bucket a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Bucket a)
Read, Int -> Bucket a -> ShowS
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
showList :: [Bucket a] -> ShowS
$cshowList :: forall a. Show a => [Bucket a] -> ShowS
show :: Bucket a -> String
$cshow :: forall a. Show a => Bucket a -> String
showsPrec :: Int -> Bucket a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Bucket a -> ShowS
Show)

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

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

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

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

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

data TermOrder = TermOrder
  { TermOrder -> Text
termSortField :: Text,
    TermOrder -> SortOrder
termSortOrder :: SortOrder
  }
  deriving (TermOrder -> TermOrder -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TermOrder -> TermOrder -> Bool
$c/= :: TermOrder -> TermOrder -> Bool
== :: TermOrder -> TermOrder -> Bool
$c== :: TermOrder -> TermOrder -> Bool
Eq, Int -> TermOrder -> ShowS
[TermOrder] -> ShowS
TermOrder -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TermOrder] -> ShowS
$cshowList :: [TermOrder] -> ShowS
show :: TermOrder -> String
$cshow :: TermOrder -> String
showsPrec :: Int -> TermOrder -> ShowS
$cshowsPrec :: Int -> 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 forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= SortOrder
termSortOrder]

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

instance ToJSON DateMathExpr where
  toJSON :: DateMathExpr -> Value
toJSON (DateMathExpr DateMathAnchor
a [DateMathModifier]
mods) = Text -> Value
String (DateMathAnchor -> Text
fmtA DateMathAnchor
a forall a. Semigroup a => a -> a -> a
<> forall a. Monoid a => [a] -> a
mconcat (DateMathModifier -> Text
fmtMod 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 forall a b. (a -> b) -> a -> b
$ Day -> String
showGregorian Day
date) forall a. Semigroup a => a -> a -> a
<> Text
"||"
      fmtMod :: DateMathModifier -> Text
fmtMod (AddTime Int
n DateMathUnit
u) = Text
"+" forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> Text
showText Int
n forall a. Semigroup a => a -> a -> a
<> forall {a}. IsString a => DateMathUnit -> a
fmtU DateMathUnit
u
      fmtMod (SubtractTime Int
n DateMathUnit
u) = Text
"-" forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> Text
showText Int
n forall a. Semigroup a => a -> a -> a
<> forall {a}. IsString a => DateMathUnit -> a
fmtU DateMathUnit
u
      fmtMod (RoundDownTo DateMathUnit
u) = Text
"/" forall a. Semigroup a => a -> a -> a
<> 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 (DateMathAnchor -> DateMathAnchor -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DateMathAnchor -> DateMathAnchor -> Bool
$c/= :: DateMathAnchor -> DateMathAnchor -> Bool
== :: DateMathAnchor -> DateMathAnchor -> Bool
$c== :: DateMathAnchor -> DateMathAnchor -> Bool
Eq, Int -> DateMathAnchor -> ShowS
[DateMathAnchor] -> ShowS
DateMathAnchor -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DateMathAnchor] -> ShowS
$cshowList :: [DateMathAnchor] -> ShowS
show :: DateMathAnchor -> String
$cshow :: DateMathAnchor -> String
showsPrec :: Int -> DateMathAnchor -> ShowS
$cshowsPrec :: Int -> DateMathAnchor -> ShowS
Show)

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

data DateMathUnit
  = DMYear
  | DMMonth
  | DMWeek
  | DMDay
  | DMHour
  | DMMinute
  | DMSecond
  deriving (DateMathUnit -> DateMathUnit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DateMathUnit -> DateMathUnit -> Bool
$c/= :: DateMathUnit -> DateMathUnit -> Bool
== :: DateMathUnit -> DateMathUnit -> Bool
$c== :: DateMathUnit -> DateMathUnit -> Bool
Eq, Int -> DateMathUnit -> ShowS
[DateMathUnit] -> ShowS
DateMathUnit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DateMathUnit] -> ShowS
$cshowList :: [DateMathUnit] -> ShowS
show :: DateMathUnit -> String
$cshow :: DateMathUnit -> String
showsPrec :: Int -> DateMathUnit -> ShowS
$cshowsPrec :: Int -> 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]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TermsResult]
$creadListPrec :: ReadPrec [TermsResult]
readPrec :: ReadPrec TermsResult
$creadPrec :: ReadPrec TermsResult
readList :: ReadS [TermsResult]
$creadList :: ReadS [TermsResult]
readsPrec :: Int -> ReadS TermsResult
$creadsPrec :: Int -> ReadS TermsResult
Read, Int -> TermsResult -> ShowS
[TermsResult] -> ShowS
TermsResult -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TermsResult] -> ShowS
$cshowList :: [TermsResult] -> ShowS
show :: TermsResult -> String
$cshow :: TermsResult -> String
showsPrec :: Int -> TermsResult -> ShowS
$cshowsPrec :: Int -> TermsResult -> ShowS
Show)

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

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
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DateHistogramResult] -> ShowS
$cshowList :: [DateHistogramResult] -> ShowS
show :: DateHistogramResult -> String
$cshow :: DateHistogramResult -> String
showsPrec :: Int -> DateHistogramResult -> ShowS
$cshowsPrec :: Int -> DateHistogramResult -> ShowS
Show)

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

instance BucketAggregation DateHistogramResult where
  key :: DateHistogramResult -> BucketValue
key = Text -> BucketValue
TextValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> Text
showText 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

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 (DateRangeResult -> DateRangeResult -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DateRangeResult -> DateRangeResult -> Bool
$c/= :: DateRangeResult -> DateRangeResult -> Bool
== :: DateRangeResult -> DateRangeResult -> Bool
$c== :: DateRangeResult -> DateRangeResult -> Bool
Eq, Int -> DateRangeResult -> ShowS
[DateRangeResult] -> ShowS
DateRangeResult -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DateRangeResult] -> ShowS
$cshowList :: [DateRangeResult] -> ShowS
show :: DateRangeResult -> String
$cshow :: DateRangeResult -> String
showsPrec :: Int -> DateRangeResult -> ShowS
$cshowsPrec :: Int -> DateRangeResult -> ShowS
Show)

instance FromJSON DateRangeResult where
  parseJSON :: Value -> Parser DateRangeResult
parseJSON = 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
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap POSIXMS -> UTCTime
posixMS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"from")
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"from_as_string"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap POSIXMS -> UTCTime
posixMS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"to")
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"to_as_string"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"doc_count"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( forall (f :: * -> *) a. Applicative f => a -> f a
pure 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 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

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

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

toMissing :: Key -> AggregationResults -> Maybe MissingResult
toMissing :: Key -> AggregationResults -> Maybe MissingResult
toMissing = 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 = 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 = forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Key
t AggregationResults
a forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Maybe a
deserialize
  where
    deserialize :: Value -> Maybe a
deserialize = forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe 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 = forall v. (Key -> v -> Bool) -> KeyMap v -> KeyMap v
X.filterWithKey (\Key
k Value
_ -> Key
k forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Key]
knownKeys) Object
o
    maggRes :: Maybe AggregationResults
maggRes
      | forall v. KeyMap v -> Bool
X.null Object
unknownKeys = forall a. Maybe a
Nothing
      | Bool
otherwise = forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall a b. (a -> b) -> a -> b
$ 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
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MissingResult] -> ShowS
$cshowList :: [MissingResult] -> ShowS
show :: MissingResult -> String
$cshow :: MissingResult -> String
showsPrec :: Int -> MissingResult -> ShowS
$cshowsPrec :: Int -> MissingResult -> ShowS
Show)

instance FromJSON MissingResult where
  parseJSON :: Value -> Parser MissingResult
parseJSON = 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 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v 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 (TopHitResult a -> TopHitResult a -> Bool
forall a. Eq a => TopHitResult a -> TopHitResult a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TopHitResult a -> TopHitResult a -> Bool
$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
Eq, Int -> TopHitResult a -> ShowS
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
showList :: [TopHitResult a] -> ShowS
$cshowList :: forall a. Show a => [TopHitResult a] -> ShowS
show :: TopHitResult a -> String
$cshow :: forall a. Show a => TopHitResult a -> String
showsPrec :: Int -> TopHitResult a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> TopHitResult a -> ShowS
Show)

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

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

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

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

instance FromJSON HitsTotal where
  parseJSON :: Value -> Parser HitsTotal
parseJSON (Object Object
v) =
    Int -> HitsTotalRelation -> HitsTotal
HitsTotal
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"relation"
  parseJSON Value
_ = 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 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 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 forall a. Num a => a -> a -> a
+ Int
tb) HitsTotalRelation
HTR_GTE

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 (SearchHits a -> SearchHits a -> Bool
forall a. Eq a => SearchHits a -> SearchHits a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SearchHits a -> SearchHits a -> Bool
$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
Eq, Int -> SearchHits a -> ShowS
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
showList :: [SearchHits a] -> ShowS
$cshowList :: forall a. Show a => [SearchHits a] -> ShowS
show :: SearchHits a -> String
$cshow :: forall a. Show a => SearchHits a -> String
showsPrec :: Int -> SearchHits a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> SearchHits a -> ShowS
Show)

instance (FromJSON a) => FromJSON (SearchHits a) where
  parseJSON :: Value -> Parser (SearchHits a)
parseJSON (Object Object
v) =
    forall a. HitsTotal -> Score -> [Hit a] -> SearchHits a
SearchHits
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_score"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"hits"
  parseJSON Value
_ = 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) =
    forall a. HitsTotal -> Score -> [Hit a] -> SearchHits a
SearchHits (HitsTotal
ta forall a. Semigroup a => a -> a -> a
<> HitsTotal
tb) (forall a. Ord a => a -> a -> a
max Score
ma Score
mb) ([Hit a]
ha forall a. Semigroup a => a -> a -> a
<> [Hit a]
hb)

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

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 (Hit a -> Hit a -> Bool
forall a. Eq a => Hit a -> Hit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Hit a -> Hit a -> Bool
$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
Eq, Int -> Hit a -> ShowS
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
showList :: [Hit a] -> ShowS
$cshowList :: forall a. Show a => [Hit a] -> ShowS
show :: Hit a -> String
$cshow :: forall a. Show a => Hit a -> String
showsPrec :: Int -> Hit a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Hit a -> ShowS
Show)

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