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

module Database.Bloodhound.Internal.Query
  ( module X,
    module Database.Bloodhound.Internal.Query,
  )
where

import Bloodhound.Import
import qualified Data.Aeson.KeyMap as X
import qualified Data.HashMap.Strict as HM
import qualified Data.Text as T
import Database.Bloodhound.Common.Script as X
import Database.Bloodhound.Internal.Newtypes
import GHC.Generics

data Query
  = TermQuery Term (Maybe Boost)
  | TermsQuery Key (NonEmpty Text)
  | QueryMatchQuery MatchQuery
  | QueryMultiMatchQuery MultiMatchQuery
  | QueryBoolQuery BoolQuery
  | QueryBoostingQuery BoostingQuery
  | QueryCommonTermsQuery CommonTermsQuery
  | ConstantScoreQuery Query Boost
  | QueryFunctionScoreQuery FunctionScoreQuery
  | QueryDisMaxQuery DisMaxQuery
  | QueryFuzzyLikeThisQuery FuzzyLikeThisQuery
  | QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery
  | QueryFuzzyQuery FuzzyQuery
  | QueryHasChildQuery HasChildQuery
  | QueryHasParentQuery HasParentQuery
  | IdsQuery [DocId]
  | QueryIndicesQuery IndicesQuery
  | MatchAllQuery (Maybe Boost)
  | QueryMoreLikeThisQuery MoreLikeThisQuery
  | QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery
  | QueryNestedQuery NestedQuery
  | QueryPrefixQuery PrefixQuery
  | QueryQueryStringQuery QueryStringQuery
  | QuerySimpleQueryStringQuery SimpleQueryStringQuery
  | QueryRangeQuery RangeQuery
  | QueryRegexpQuery RegexpQuery
  | QueryExistsQuery FieldName
  | QueryMatchNoneQuery
  | QueryWildcardQuery WildcardQuery
  deriving (Query -> Query -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Query -> Query -> Bool
$c/= :: Query -> Query -> Bool
== :: Query -> Query -> Bool
$c== :: Query -> Query -> Bool
Eq, Int -> Query -> ShowS
[Query] -> ShowS
Query -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Query] -> ShowS
$cshowList :: [Query] -> ShowS
show :: Query -> String
$cshow :: Query -> String
showsPrec :: Int -> Query -> ShowS
$cshowsPrec :: Int -> Query -> ShowS
Show, forall x. Rep Query x -> Query
forall x. Query -> Rep Query x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Query x -> Query
$cfrom :: forall x. Query -> Rep Query x
Generic)

instance ToJSON Query where
  toJSON :: Query -> Value
toJSON (TermQuery (Term Key
termQueryField Text
termQueryValue) Maybe Boost
boost) =
    [Pair] -> Value
object
      [ Key
"term"
          forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Key
termQueryField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Pair]
merged]
      ]
    where
      base :: [Pair]
base = [Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
termQueryValue]
      boosted :: [Pair]
boosted = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.=)) Maybe Boost
boost
      merged :: [Pair]
merged = forall a. Monoid a => a -> a -> a
mappend [Pair]
base [Pair]
boosted
  toJSON (TermsQuery Key
fieldName NonEmpty Text
terms) =
    [Pair] -> Value
object [Key
"terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Pair]
conjoined]
    where
      conjoined :: [Pair]
conjoined = [Key
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= NonEmpty Text
terms]
  toJSON (IdsQuery [DocId]
docIds) =
    [Pair] -> Value
object [Key
"ids" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Pair]
conjoined]
    where
      conjoined :: [Pair]
conjoined = [Key
"values" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. ToJSON a => a -> Value
toJSON [DocId]
docIds]
  toJSON (QueryQueryStringQuery QueryStringQuery
qQueryStringQuery) =
    [Pair] -> Value
object [Key
"query_string" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= QueryStringQuery
qQueryStringQuery]
  toJSON (QueryMatchQuery MatchQuery
matchQuery) =
    [Pair] -> Value
object [Key
"match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MatchQuery
matchQuery]
  toJSON (QueryMultiMatchQuery MultiMatchQuery
multiMatchQuery) =
    forall a. ToJSON a => a -> Value
toJSON MultiMatchQuery
multiMatchQuery
  toJSON (QueryBoolQuery BoolQuery
boolQuery) =
    [Pair] -> Value
object [Key
"bool" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BoolQuery
boolQuery]
  toJSON (QueryBoostingQuery BoostingQuery
boostingQuery) =
    [Pair] -> Value
object [Key
"boosting" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BoostingQuery
boostingQuery]
  toJSON (QueryCommonTermsQuery CommonTermsQuery
commonTermsQuery) =
    [Pair] -> Value
object [Key
"common" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= CommonTermsQuery
commonTermsQuery]
  toJSON (ConstantScoreQuery Query
query Boost
boost) =
    [Pair] -> Value
object
      [ Key
"constant_score"
          forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
query,
              Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
            ]
      ]
  toJSON (QueryFunctionScoreQuery FunctionScoreQuery
functionScoreQuery) =
    [Pair] -> Value
object [Key
"function_score" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FunctionScoreQuery
functionScoreQuery]
  toJSON (QueryDisMaxQuery DisMaxQuery
disMaxQuery) =
    [Pair] -> Value
object [Key
"dis_max" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= DisMaxQuery
disMaxQuery]
  toJSON (QueryFuzzyLikeThisQuery FuzzyLikeThisQuery
fuzzyQuery) =
    [Pair] -> Value
object [Key
"fuzzy_like_this" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FuzzyLikeThisQuery
fuzzyQuery]
  toJSON (QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery
fuzzyFieldQuery) =
    [Pair] -> Value
object [Key
"fuzzy_like_this_field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FuzzyLikeFieldQuery
fuzzyFieldQuery]
  toJSON (QueryFuzzyQuery FuzzyQuery
fuzzyQuery) =
    [Pair] -> Value
object [Key
"fuzzy" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FuzzyQuery
fuzzyQuery]
  toJSON (QueryHasChildQuery HasChildQuery
childQuery) =
    [Pair] -> Value
object [Key
"has_child" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= HasChildQuery
childQuery]
  toJSON (QueryHasParentQuery HasParentQuery
parentQuery) =
    [Pair] -> Value
object [Key
"has_parent" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= HasParentQuery
parentQuery]
  toJSON (QueryIndicesQuery IndicesQuery
qIndicesQuery) =
    [Pair] -> Value
object [Key
"indices" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= IndicesQuery
qIndicesQuery]
  toJSON (MatchAllQuery Maybe Boost
boost) =
    [Pair] -> Value
object [Key
"match_all" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost]]
  toJSON (QueryMoreLikeThisQuery MoreLikeThisQuery
query) =
    [Pair] -> Value
object [Key
"more_like_this" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MoreLikeThisQuery
query]
  toJSON (QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery
query) =
    [Pair] -> Value
object [Key
"more_like_this_field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MoreLikeThisFieldQuery
query]
  toJSON (QueryNestedQuery NestedQuery
query) =
    [Pair] -> Value
object [Key
"nested" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= NestedQuery
query]
  toJSON (QueryPrefixQuery PrefixQuery
query) =
    [Pair] -> Value
object [Key
"prefix" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= PrefixQuery
query]
  toJSON (QueryRangeQuery RangeQuery
query) =
    [Pair] -> Value
object [Key
"range" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RangeQuery
query]
  toJSON (QueryRegexpQuery RegexpQuery
query) =
    [Pair] -> Value
object [Key
"regexp" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RegexpQuery
query]
  toJSON (QuerySimpleQueryStringQuery SimpleQueryStringQuery
query) =
    [Pair] -> Value
object [Key
"simple_query_string" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= SimpleQueryStringQuery
query]
  toJSON (QueryExistsQuery (FieldName Text
fieldName)) =
    [Pair] -> Value
object
      [ Key
"exists"
          forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [Key
"field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
fieldName]
      ]
  toJSON Query
QueryMatchNoneQuery =
    [Pair] -> Value
object [Key
"match_none" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object []]
  toJSON (QueryWildcardQuery WildcardQuery
query) =
    [Pair] -> Value
object [Key
"wildcard" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= WildcardQuery
query]

instance FromJSON Query where
  parseJSON :: Value -> Parser Query
parseJSON Value
v = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Query" Object -> Parser Query
parse Value
v
    where
      parse :: Object -> Parser Query
parse Object
o =
        Object -> Parser Query
termQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"term"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HashMap Key Value -> Parser Query
termsQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"terms"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object -> Parser Query
idsQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"ids"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> QueryStringQuery -> Parser Query
queryQueryStringQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"query_string"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> MatchQuery -> Parser Query
queryMatchQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"match"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Query
queryMultiMatchQuery
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BoolQuery -> Parser Query
queryBoolQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"bool"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BoostingQuery -> Parser Query
queryBoostingQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"boosting"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> CommonTermsQuery -> Parser Query
queryCommonTermsQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"common"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object -> Parser Query
constantScoreQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"constant_score"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FunctionScoreQuery -> Parser Query
queryFunctionScoreQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"function_score"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> DisMaxQuery -> Parser Query
queryDisMaxQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"dis_max"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FuzzyLikeThisQuery -> Parser Query
queryFuzzyLikeThisQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"fuzzy_like_this"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FuzzyLikeFieldQuery -> Parser Query
queryFuzzyLikeFieldQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"fuzzy_like_this_field"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FuzzyQuery -> Parser Query
queryFuzzyQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"fuzzy"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HasChildQuery -> Parser Query
queryHasChildQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"has_child"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HasParentQuery -> Parser Query
queryHasParentQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"has_parent"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> IndicesQuery -> Parser Query
queryIndicesQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"indices"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object -> Parser Query
matchAllQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"match_all"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> MoreLikeThisQuery -> Parser Query
queryMoreLikeThisQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"more_like_this"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> MoreLikeThisFieldQuery -> Parser Query
queryMoreLikeThisFieldQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"more_like_this_field"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NestedQuery -> Parser Query
queryNestedQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"nested"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> PrefixQuery -> Parser Query
queryPrefixQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"prefix"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RangeQuery -> Parser Query
queryRangeQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"range"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RegexpQuery -> Parser Query
queryRegexpQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"regexp"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SimpleQueryStringQuery -> Parser Query
querySimpleQueryStringQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"simple_query_string"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> WildcardQuery -> Parser Query
queryWildcardQuery
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"wildcard"
        where
          taggedWith :: (a -> Parser b) -> Key -> Parser b
taggedWith a -> Parser b
parser Key
k = a -> Parser b
parser forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
k
      termQuery :: Object -> Parser Query
termQuery = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \(FieldName Text
fn) Object
o ->
        Term -> Maybe Boost -> Query
TermQuery forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Key -> Text -> Term
Term (Text -> Key
fromText Text
fn) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value") forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
      termsQuery :: HashMap Key Value -> Parser Query
termsQuery HashMap Key Value
o = case forall k v. HashMap k v -> [(k, v)]
HM.toList HashMap Key Value
o of
        [(Key
fn, Value
vs)] -> do
          [Text]
vals <- forall a. FromJSON a => Value -> Parser a
parseJSON Value
vs
          case [Text]
vals of
            Text
x : [Text]
xs -> forall (m :: * -> *) a. Monad m => a -> m a
return (Key -> NonEmpty Text -> Query
TermsQuery Key
fn (Text
x forall a. a -> [a] -> NonEmpty a
:| [Text]
xs))
            [Text]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected non empty list of values"
        [Pair]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected object with 1 field-named key"
      idsQuery :: Object -> Parser Query
idsQuery Object
o = [DocId] -> Query
IdsQuery forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"values"
      queryQueryStringQuery :: QueryStringQuery -> Parser Query
queryQueryStringQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryStringQuery -> Query
QueryQueryStringQuery
      queryMatchQuery :: MatchQuery -> Parser Query
queryMatchQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. MatchQuery -> Query
QueryMatchQuery
      queryMultiMatchQuery :: Parser Query
queryMultiMatchQuery = MultiMatchQuery -> Query
QueryMultiMatchQuery forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
      queryBoolQuery :: BoolQuery -> Parser Query
queryBoolQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoolQuery -> Query
QueryBoolQuery
      queryBoostingQuery :: BoostingQuery -> Parser Query
queryBoostingQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoostingQuery -> Query
QueryBoostingQuery
      queryCommonTermsQuery :: CommonTermsQuery -> Parser Query
queryCommonTermsQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. CommonTermsQuery -> Query
QueryCommonTermsQuery
      constantScoreQuery :: Object -> Parser Query
constantScoreQuery Object
o = case forall v. Key -> KeyMap v -> Maybe v
X.lookup Key
"filter" Object
o of
        Just Value
x ->
          Query -> Boost -> Query
ConstantScoreQuery
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
x
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
        Maybe Value
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Does not appear to be a ConstantScoreQuery"
      queryFunctionScoreQuery :: FunctionScoreQuery -> Parser Query
queryFunctionScoreQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. FunctionScoreQuery -> Query
QueryFunctionScoreQuery
      queryDisMaxQuery :: DisMaxQuery -> Parser Query
queryDisMaxQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. DisMaxQuery -> Query
QueryDisMaxQuery
      queryFuzzyLikeThisQuery :: FuzzyLikeThisQuery -> Parser Query
queryFuzzyLikeThisQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuzzyLikeThisQuery -> Query
QueryFuzzyLikeThisQuery
      queryFuzzyLikeFieldQuery :: FuzzyLikeFieldQuery -> Parser Query
queryFuzzyLikeFieldQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuzzyLikeFieldQuery -> Query
QueryFuzzyLikeFieldQuery
      queryFuzzyQuery :: FuzzyQuery -> Parser Query
queryFuzzyQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuzzyQuery -> Query
QueryFuzzyQuery
      queryHasChildQuery :: HasChildQuery -> Parser Query
queryHasChildQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasChildQuery -> Query
QueryHasChildQuery
      queryHasParentQuery :: HasParentQuery -> Parser Query
queryHasParentQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasParentQuery -> Query
QueryHasParentQuery
      queryIndicesQuery :: IndicesQuery -> Parser Query
queryIndicesQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndicesQuery -> Query
QueryIndicesQuery
      matchAllQuery :: Object -> Parser Query
matchAllQuery Object
o = Maybe Boost -> Query
MatchAllQuery forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
      queryMoreLikeThisQuery :: MoreLikeThisQuery -> Parser Query
queryMoreLikeThisQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. MoreLikeThisQuery -> Query
QueryMoreLikeThisQuery
      queryMoreLikeThisFieldQuery :: MoreLikeThisFieldQuery -> Parser Query
queryMoreLikeThisFieldQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. MoreLikeThisFieldQuery -> Query
QueryMoreLikeThisFieldQuery
      queryNestedQuery :: NestedQuery -> Parser Query
queryNestedQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedQuery -> Query
QueryNestedQuery
      queryPrefixQuery :: PrefixQuery -> Parser Query
queryPrefixQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrefixQuery -> Query
QueryPrefixQuery
      queryRangeQuery :: RangeQuery -> Parser Query
queryRangeQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. RangeQuery -> Query
QueryRangeQuery
      queryRegexpQuery :: RegexpQuery -> Parser Query
queryRegexpQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. RegexpQuery -> Query
QueryRegexpQuery
      querySimpleQueryStringQuery :: SimpleQueryStringQuery -> Parser Query
querySimpleQueryStringQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. SimpleQueryStringQuery -> Query
QuerySimpleQueryStringQuery
      -- queryExistsQuery o = QueryExistsQuery <$> o .: "field"
      queryWildcardQuery :: WildcardQuery -> Parser Query
queryWildcardQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. WildcardQuery -> Query
QueryWildcardQuery

-- | As of Elastic 2.0, 'Filters' are just 'Queries' housed in a
--   Bool Query, and flagged in a different context.
newtype Filter = Filter {Filter -> Query
unFilter :: Query}
  deriving (Filter -> Filter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Filter -> Filter -> Bool
$c/= :: Filter -> Filter -> Bool
== :: Filter -> Filter -> Bool
$c== :: Filter -> Filter -> Bool
Eq, Int -> Filter -> ShowS
[Filter] -> ShowS
Filter -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Filter] -> ShowS
$cshowList :: [Filter] -> ShowS
show :: Filter -> String
$cshow :: Filter -> String
showsPrec :: Int -> Filter -> ShowS
$cshowsPrec :: Int -> Filter -> ShowS
Show)

instance ToJSON Filter where
  toJSON :: Filter -> Value
toJSON = forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. Filter -> Query
unFilter

instance FromJSON Filter where
  parseJSON :: Value -> Parser Filter
parseJSON Value
v = Query -> Filter
Filter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v

data RegexpQuery = RegexpQuery
  { RegexpQuery -> FieldName
regexpQueryField :: FieldName,
    RegexpQuery -> Regexp
regexpQuery :: Regexp,
    RegexpQuery -> RegexpFlags
regexpQueryFlags :: RegexpFlags,
    RegexpQuery -> Maybe Boost
regexpQueryBoost :: Maybe Boost
  }
  deriving (RegexpQuery -> RegexpQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegexpQuery -> RegexpQuery -> Bool
$c/= :: RegexpQuery -> RegexpQuery -> Bool
== :: RegexpQuery -> RegexpQuery -> Bool
$c== :: RegexpQuery -> RegexpQuery -> Bool
Eq, Int -> RegexpQuery -> ShowS
[RegexpQuery] -> ShowS
RegexpQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegexpQuery] -> ShowS
$cshowList :: [RegexpQuery] -> ShowS
show :: RegexpQuery -> String
$cshow :: RegexpQuery -> String
showsPrec :: Int -> RegexpQuery -> ShowS
$cshowsPrec :: Int -> RegexpQuery -> ShowS
Show, forall x. Rep RegexpQuery x -> RegexpQuery
forall x. RegexpQuery -> Rep RegexpQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegexpQuery x -> RegexpQuery
$cfrom :: forall x. RegexpQuery -> Rep RegexpQuery x
Generic)

instance ToJSON RegexpQuery where
  toJSON :: RegexpQuery -> Value
toJSON
    ( RegexpQuery
        (FieldName Text
rqQueryField)
        (Regexp Text
regexpQueryQuery)
        RegexpFlags
rqQueryFlags
        Maybe Boost
rqQueryBoost
      ) =
      [Pair] -> Value
object [Text -> Key
fromText Text
rqQueryField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
regexpQueryQuery,
            Key
"flags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RegexpFlags
rqQueryFlags,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
rqQueryBoost
          ]

instance FromJSON RegexpQuery where
  parseJSON :: Value -> Parser RegexpQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RegexpQuery" Object -> Parser RegexpQuery
parse
    where
      parse :: Object -> Parser RegexpQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName -> Regexp -> RegexpFlags -> Maybe Boost -> RegexpQuery
RegexpQuery FieldName
fn
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"flags"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"

data WildcardQuery = WildcardQuery
  { WildcardQuery -> FieldName
wildcardQueryField :: FieldName,
    WildcardQuery -> Key
wildcardQuery :: Key,
    WildcardQuery -> Maybe Boost
wildcardQueryBoost :: Maybe Boost
  }
  deriving (WildcardQuery -> WildcardQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WildcardQuery -> WildcardQuery -> Bool
$c/= :: WildcardQuery -> WildcardQuery -> Bool
== :: WildcardQuery -> WildcardQuery -> Bool
$c== :: WildcardQuery -> WildcardQuery -> Bool
Eq, Int -> WildcardQuery -> ShowS
[WildcardQuery] -> ShowS
WildcardQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WildcardQuery] -> ShowS
$cshowList :: [WildcardQuery] -> ShowS
show :: WildcardQuery -> String
$cshow :: WildcardQuery -> String
showsPrec :: Int -> WildcardQuery -> ShowS
$cshowsPrec :: Int -> WildcardQuery -> ShowS
Show, forall x. Rep WildcardQuery x -> WildcardQuery
forall x. WildcardQuery -> Rep WildcardQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep WildcardQuery x -> WildcardQuery
$cfrom :: forall x. WildcardQuery -> Rep WildcardQuery x
Generic)

instance ToJSON WildcardQuery where
  toJSON :: WildcardQuery -> Value
toJSON
    ( WildcardQuery
        (FieldName Text
wcQueryField)
        (Key
wcQueryQuery)
        Maybe Boost
wcQueryBoost
      ) =
      [Pair] -> Value
object [Text -> Key
fromText Text
wcQueryField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Key
wcQueryQuery,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
wcQueryBoost
          ]

instance FromJSON WildcardQuery where
  parseJSON :: Value -> Parser WildcardQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"WildcardQuery" Object -> Parser WildcardQuery
parse
    where
      parse :: Object -> Parser WildcardQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName -> Key -> Maybe Boost -> WildcardQuery
WildcardQuery FieldName
fn
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"

data RangeQuery = RangeQuery
  { RangeQuery -> FieldName
rangeQueryField :: FieldName,
    RangeQuery -> RangeValue
rangeQueryRange :: RangeValue,
    RangeQuery -> Boost
rangeQueryBoost :: Boost
  }
  deriving (RangeQuery -> RangeQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RangeQuery -> RangeQuery -> Bool
$c/= :: RangeQuery -> RangeQuery -> Bool
== :: RangeQuery -> RangeQuery -> Bool
$c== :: RangeQuery -> RangeQuery -> Bool
Eq, Int -> RangeQuery -> ShowS
[RangeQuery] -> ShowS
RangeQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RangeQuery] -> ShowS
$cshowList :: [RangeQuery] -> ShowS
show :: RangeQuery -> String
$cshow :: RangeQuery -> String
showsPrec :: Int -> RangeQuery -> ShowS
$cshowsPrec :: Int -> RangeQuery -> ShowS
Show, forall x. Rep RangeQuery x -> RangeQuery
forall x. RangeQuery -> Rep RangeQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RangeQuery x -> RangeQuery
$cfrom :: forall x. RangeQuery -> Rep RangeQuery x
Generic)

instance ToJSON RangeQuery where
  toJSON :: RangeQuery -> Value
toJSON (RangeQuery (FieldName Text
fieldName) RangeValue
range Boost
boost) =
    [Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Pair]
conjoined]
    where
      conjoined :: [Pair]
conjoined = (Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
boost) forall a. a -> [a] -> [a]
: RangeValue -> [Pair]
rangeValueToPair RangeValue
range

instance FromJSON RangeQuery where
  parseJSON :: Value -> Parser RangeQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RangeQuery" Object -> Parser RangeQuery
parse
    where
      parse :: Object -> Parser RangeQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName -> RangeValue -> Boost -> RangeQuery
RangeQuery FieldName
fn
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
o)
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"

mkRangeQuery :: FieldName -> RangeValue -> RangeQuery
mkRangeQuery :: FieldName -> RangeValue -> RangeQuery
mkRangeQuery FieldName
f RangeValue
r = FieldName -> RangeValue -> Boost -> RangeQuery
RangeQuery FieldName
f RangeValue
r (Double -> Boost
Boost Double
1.0)

data SimpleQueryStringQuery = SimpleQueryStringQuery
  { SimpleQueryStringQuery -> QueryString
simpleQueryStringQuery :: QueryString,
    SimpleQueryStringQuery -> Maybe FieldOrFields
simpleQueryStringField :: Maybe FieldOrFields,
    SimpleQueryStringQuery -> Maybe BooleanOperator
simpleQueryStringOperator :: Maybe BooleanOperator,
    SimpleQueryStringQuery -> Maybe Analyzer
simpleQueryStringAnalyzer :: Maybe Analyzer,
    SimpleQueryStringQuery -> Maybe (NonEmpty SimpleQueryFlag)
simpleQueryStringFlags :: Maybe (NonEmpty SimpleQueryFlag),
    SimpleQueryStringQuery -> Maybe LowercaseExpanded
simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded,
    SimpleQueryStringQuery -> Maybe Locale
simpleQueryStringLocale :: Maybe Locale
  }
  deriving (SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
$c/= :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
== :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
$c== :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
Eq, Int -> SimpleQueryStringQuery -> ShowS
[SimpleQueryStringQuery] -> ShowS
SimpleQueryStringQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimpleQueryStringQuery] -> ShowS
$cshowList :: [SimpleQueryStringQuery] -> ShowS
show :: SimpleQueryStringQuery -> String
$cshow :: SimpleQueryStringQuery -> String
showsPrec :: Int -> SimpleQueryStringQuery -> ShowS
$cshowsPrec :: Int -> SimpleQueryStringQuery -> ShowS
Show, forall x. Rep SimpleQueryStringQuery x -> SimpleQueryStringQuery
forall x. SimpleQueryStringQuery -> Rep SimpleQueryStringQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SimpleQueryStringQuery x -> SimpleQueryStringQuery
$cfrom :: forall x. SimpleQueryStringQuery -> Rep SimpleQueryStringQuery x
Generic)

instance ToJSON SimpleQueryStringQuery where
  toJSON :: SimpleQueryStringQuery -> Value
toJSON SimpleQueryStringQuery {Maybe (NonEmpty SimpleQueryFlag)
Maybe Locale
Maybe LowercaseExpanded
Maybe Analyzer
Maybe BooleanOperator
Maybe FieldOrFields
QueryString
simpleQueryStringLocale :: Maybe Locale
simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded
simpleQueryStringFlags :: Maybe (NonEmpty SimpleQueryFlag)
simpleQueryStringAnalyzer :: Maybe Analyzer
simpleQueryStringOperator :: Maybe BooleanOperator
simpleQueryStringField :: Maybe FieldOrFields
simpleQueryStringQuery :: QueryString
simpleQueryStringLocale :: SimpleQueryStringQuery -> Maybe Locale
simpleQueryStringLowercaseExpanded :: SimpleQueryStringQuery -> Maybe LowercaseExpanded
simpleQueryStringFlags :: SimpleQueryStringQuery -> Maybe (NonEmpty SimpleQueryFlag)
simpleQueryStringAnalyzer :: SimpleQueryStringQuery -> Maybe Analyzer
simpleQueryStringOperator :: SimpleQueryStringQuery -> Maybe BooleanOperator
simpleQueryStringField :: SimpleQueryStringQuery -> Maybe FieldOrFields
simpleQueryStringQuery :: SimpleQueryStringQuery -> QueryString
..} =
    [Pair] -> Value
omitNulls ([Pair]
base forall a. [a] -> [a] -> [a]
++ [Pair]
maybeAdd)
    where
      base :: [Pair]
base = [Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= QueryString
simpleQueryStringQuery]
      maybeAdd :: [Pair]
maybeAdd =
        [ Key
"fields" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe FieldOrFields
simpleQueryStringField,
          Key
"default_operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BooleanOperator
simpleQueryStringOperator,
          Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
simpleQueryStringAnalyzer,
          Key
"flags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe (NonEmpty SimpleQueryFlag)
simpleQueryStringFlags,
          Key
"lowercase_expanded_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe LowercaseExpanded
simpleQueryStringLowercaseExpanded,
          Key
"locale" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Locale
simpleQueryStringLocale
        ]

instance FromJSON SimpleQueryStringQuery where
  parseJSON :: Value -> Parser SimpleQueryStringQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SimpleQueryStringQuery" Object -> Parser SimpleQueryStringQuery
parse
    where
      parse :: Object -> Parser SimpleQueryStringQuery
parse Object
o =
        QueryString
-> Maybe FieldOrFields
-> Maybe BooleanOperator
-> Maybe Analyzer
-> Maybe (NonEmpty SimpleQueryFlag)
-> Maybe LowercaseExpanded
-> Maybe Locale
-> SimpleQueryStringQuery
SimpleQueryStringQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o 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
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"default_operator"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall {a}. Maybe [a] -> Maybe (NonEmpty a)
parseFlags forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"flags")
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lowercase_expanded_terms"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"locale"
      parseFlags :: Maybe [a] -> Maybe (NonEmpty a)
parseFlags (Just (a
x : [a]
xs)) = forall a. a -> Maybe a
Just (a
x forall a. a -> [a] -> NonEmpty a
:| [a]
xs)
      parseFlags Maybe [a]
_ = forall a. Maybe a
Nothing

data SimpleQueryFlag
  = SimpleQueryAll
  | SimpleQueryNone
  | SimpleQueryAnd
  | SimpleQueryOr
  | SimpleQueryPrefix
  | SimpleQueryPhrase
  | SimpleQueryPrecedence
  | SimpleQueryEscape
  | SimpleQueryWhitespace
  | SimpleQueryFuzzy
  | SimpleQueryNear
  | SimpleQuerySlop
  deriving (SimpleQueryFlag -> SimpleQueryFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
$c/= :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
== :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
$c== :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
Eq, Int -> SimpleQueryFlag -> ShowS
[SimpleQueryFlag] -> ShowS
SimpleQueryFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimpleQueryFlag] -> ShowS
$cshowList :: [SimpleQueryFlag] -> ShowS
show :: SimpleQueryFlag -> String
$cshow :: SimpleQueryFlag -> String
showsPrec :: Int -> SimpleQueryFlag -> ShowS
$cshowsPrec :: Int -> SimpleQueryFlag -> ShowS
Show, forall x. Rep SimpleQueryFlag x -> SimpleQueryFlag
forall x. SimpleQueryFlag -> Rep SimpleQueryFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SimpleQueryFlag x -> SimpleQueryFlag
$cfrom :: forall x. SimpleQueryFlag -> Rep SimpleQueryFlag x
Generic)

instance ToJSON SimpleQueryFlag where
  toJSON :: SimpleQueryFlag -> Value
toJSON SimpleQueryFlag
SimpleQueryAll = Value
"ALL"
  toJSON SimpleQueryFlag
SimpleQueryNone = Value
"NONE"
  toJSON SimpleQueryFlag
SimpleQueryAnd = Value
"AND"
  toJSON SimpleQueryFlag
SimpleQueryOr = Value
"OR"
  toJSON SimpleQueryFlag
SimpleQueryPrefix = Value
"PREFIX"
  toJSON SimpleQueryFlag
SimpleQueryPhrase = Value
"PHRASE"
  toJSON SimpleQueryFlag
SimpleQueryPrecedence = Value
"PRECEDENCE"
  toJSON SimpleQueryFlag
SimpleQueryEscape = Value
"ESCAPE"
  toJSON SimpleQueryFlag
SimpleQueryWhitespace = Value
"WHITESPACE"
  toJSON SimpleQueryFlag
SimpleQueryFuzzy = Value
"FUZZY"
  toJSON SimpleQueryFlag
SimpleQueryNear = Value
"NEAR"
  toJSON SimpleQueryFlag
SimpleQuerySlop = Value
"SLOP"

instance FromJSON SimpleQueryFlag where
  parseJSON :: Value -> Parser SimpleQueryFlag
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"SimpleQueryFlag" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f SimpleQueryFlag
parse
    where
      parse :: a -> f SimpleQueryFlag
parse a
"ALL" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryAll
      parse a
"NONE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryNone
      parse a
"AND" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryAnd
      parse a
"OR" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryOr
      parse a
"PREFIX" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPrefix
      parse a
"PHRASE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPhrase
      parse a
"PRECEDENCE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPrecedence
      parse a
"ESCAPE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryEscape
      parse a
"WHITESPACE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryWhitespace
      parse a
"FUZZY" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryFuzzy
      parse a
"NEAR" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryNear
      parse a
"SLOP" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQuerySlop
      parse a
f = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected SimpleQueryFlag: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
f)

-- use_dis_max and tie_breaker when fields are plural?
data QueryStringQuery = QueryStringQuery
  { QueryStringQuery -> QueryString
queryStringQuery :: QueryString,
    QueryStringQuery -> Maybe FieldName
queryStringDefaultField :: Maybe FieldName,
    QueryStringQuery -> Maybe BooleanOperator
queryStringOperator :: Maybe BooleanOperator,
    QueryStringQuery -> Maybe Analyzer
queryStringAnalyzer :: Maybe Analyzer,
    QueryStringQuery -> Maybe AllowLeadingWildcard
queryStringAllowLeadingWildcard :: Maybe AllowLeadingWildcard,
    QueryStringQuery -> Maybe LowercaseExpanded
queryStringLowercaseExpanded :: Maybe LowercaseExpanded,
    QueryStringQuery -> Maybe EnablePositionIncrements
queryStringEnablePositionIncrements :: Maybe EnablePositionIncrements,
    QueryStringQuery -> Maybe MaxExpansions
queryStringFuzzyMaxExpansions :: Maybe MaxExpansions,
    QueryStringQuery -> Maybe Fuzziness
queryStringFuzziness :: Maybe Fuzziness,
    QueryStringQuery -> Maybe PrefixLength
queryStringFuzzyPrefixLength :: Maybe PrefixLength,
    QueryStringQuery -> Maybe PhraseSlop
queryStringPhraseSlop :: Maybe PhraseSlop,
    QueryStringQuery -> Maybe Boost
queryStringBoost :: Maybe Boost,
    QueryStringQuery -> Maybe AnalyzeWildcard
queryStringAnalyzeWildcard :: Maybe AnalyzeWildcard,
    QueryStringQuery -> Maybe GeneratePhraseQueries
queryStringGeneratePhraseQueries :: Maybe GeneratePhraseQueries,
    QueryStringQuery -> Maybe MinimumMatch
queryStringMinimumShouldMatch :: Maybe MinimumMatch,
    QueryStringQuery -> Maybe Lenient
queryStringLenient :: Maybe Lenient,
    QueryStringQuery -> Maybe Locale
queryStringLocale :: Maybe Locale
  }
  deriving (QueryStringQuery -> QueryStringQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QueryStringQuery -> QueryStringQuery -> Bool
$c/= :: QueryStringQuery -> QueryStringQuery -> Bool
== :: QueryStringQuery -> QueryStringQuery -> Bool
$c== :: QueryStringQuery -> QueryStringQuery -> Bool
Eq, Int -> QueryStringQuery -> ShowS
[QueryStringQuery] -> ShowS
QueryStringQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QueryStringQuery] -> ShowS
$cshowList :: [QueryStringQuery] -> ShowS
show :: QueryStringQuery -> String
$cshow :: QueryStringQuery -> String
showsPrec :: Int -> QueryStringQuery -> ShowS
$cshowsPrec :: Int -> QueryStringQuery -> ShowS
Show, forall x. Rep QueryStringQuery x -> QueryStringQuery
forall x. QueryStringQuery -> Rep QueryStringQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep QueryStringQuery x -> QueryStringQuery
$cfrom :: forall x. QueryStringQuery -> Rep QueryStringQuery x
Generic)

instance ToJSON QueryStringQuery where
  toJSON :: QueryStringQuery -> Value
toJSON
    ( QueryStringQuery
        QueryString
qsQueryString
        Maybe FieldName
qsDefaultField
        Maybe BooleanOperator
qsOperator
        Maybe Analyzer
qsAnalyzer
        Maybe AllowLeadingWildcard
qsAllowWildcard
        Maybe LowercaseExpanded
qsLowercaseExpanded
        Maybe EnablePositionIncrements
qsEnablePositionIncrements
        Maybe MaxExpansions
qsFuzzyMaxExpansions
        Maybe Fuzziness
qsFuzziness
        Maybe PrefixLength
qsFuzzyPrefixLength
        Maybe PhraseSlop
qsPhraseSlop
        Maybe Boost
qsBoost
        Maybe AnalyzeWildcard
qsAnalyzeWildcard
        Maybe GeneratePhraseQueries
qsGeneratePhraseQueries
        Maybe MinimumMatch
qsMinimumShouldMatch
        Maybe Lenient
qsLenient
        Maybe Locale
qsLocale
      ) =
      [Pair] -> Value
omitNulls [Pair]
base
      where
        base :: [Pair]
base =
          [ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= QueryString
qsQueryString,
            Key
"default_field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe FieldName
qsDefaultField,
            Key
"default_operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BooleanOperator
qsOperator,
            Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
qsAnalyzer,
            Key
"allow_leading_wildcard" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe AllowLeadingWildcard
qsAllowWildcard,
            Key
"lowercase_expanded_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe LowercaseExpanded
qsLowercaseExpanded,
            Key
"enable_position_increments" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe EnablePositionIncrements
qsEnablePositionIncrements,
            Key
"fuzzy_max_expansions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxExpansions
qsFuzzyMaxExpansions,
            Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Fuzziness
qsFuzziness,
            Key
"fuzzy_prefix_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PrefixLength
qsFuzzyPrefixLength,
            Key
"phrase_slop" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PhraseSlop
qsPhraseSlop,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
qsBoost,
            Key
"analyze_wildcard" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe AnalyzeWildcard
qsAnalyzeWildcard,
            Key
"auto_generate_phrase_queries" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe GeneratePhraseQueries
qsGeneratePhraseQueries,
            Key
"minimum_should_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinimumMatch
qsMinimumShouldMatch,
            Key
"lenient" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lenient
qsLenient,
            Key
"locale" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Locale
qsLocale
          ]

instance FromJSON QueryStringQuery where
  parseJSON :: Value -> Parser QueryStringQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"QueryStringQuery" Object -> Parser QueryStringQuery
parse
    where
      parse :: Object -> Parser QueryStringQuery
parse Object
o =
        QueryString
-> Maybe FieldName
-> Maybe BooleanOperator
-> Maybe Analyzer
-> Maybe AllowLeadingWildcard
-> Maybe LowercaseExpanded
-> Maybe EnablePositionIncrements
-> Maybe MaxExpansions
-> Maybe Fuzziness
-> Maybe PrefixLength
-> Maybe PhraseSlop
-> Maybe Boost
-> Maybe AnalyzeWildcard
-> Maybe GeneratePhraseQueries
-> Maybe MinimumMatch
-> Maybe Lenient
-> Maybe Locale
-> QueryStringQuery
QueryStringQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"default_field"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"default_operator"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"allow_leading_wildcard"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lowercase_expanded_terms"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"enable_position_increments"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fuzzy_max_expansions"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fuzziness"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fuzzy_prefix_length"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"phrase_slop"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyze_wildcard"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"auto_generate_phrase_queries"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum_should_match"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lenient"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"locale"

mkQueryStringQuery :: QueryString -> QueryStringQuery
mkQueryStringQuery :: QueryString -> QueryStringQuery
mkQueryStringQuery QueryString
qs =
  QueryString
-> Maybe FieldName
-> Maybe BooleanOperator
-> Maybe Analyzer
-> Maybe AllowLeadingWildcard
-> Maybe LowercaseExpanded
-> Maybe EnablePositionIncrements
-> Maybe MaxExpansions
-> Maybe Fuzziness
-> Maybe PrefixLength
-> Maybe PhraseSlop
-> Maybe Boost
-> Maybe AnalyzeWildcard
-> Maybe GeneratePhraseQueries
-> Maybe MinimumMatch
-> Maybe Lenient
-> Maybe Locale
-> QueryStringQuery
QueryStringQuery
    QueryString
qs
    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
    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

data FieldOrFields
  = FofField FieldName
  | FofFields (NonEmpty FieldName)
  deriving (FieldOrFields -> FieldOrFields -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldOrFields -> FieldOrFields -> Bool
$c/= :: FieldOrFields -> FieldOrFields -> Bool
== :: FieldOrFields -> FieldOrFields -> Bool
$c== :: FieldOrFields -> FieldOrFields -> Bool
Eq, Int -> FieldOrFields -> ShowS
[FieldOrFields] -> ShowS
FieldOrFields -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldOrFields] -> ShowS
$cshowList :: [FieldOrFields] -> ShowS
show :: FieldOrFields -> String
$cshow :: FieldOrFields -> String
showsPrec :: Int -> FieldOrFields -> ShowS
$cshowsPrec :: Int -> FieldOrFields -> ShowS
Show, forall x. Rep FieldOrFields x -> FieldOrFields
forall x. FieldOrFields -> Rep FieldOrFields x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FieldOrFields x -> FieldOrFields
$cfrom :: forall x. FieldOrFields -> Rep FieldOrFields x
Generic)

instance ToJSON FieldOrFields where
  toJSON :: FieldOrFields -> Value
toJSON (FofField FieldName
fieldName) =
    forall a. ToJSON a => a -> Value
toJSON FieldName
fieldName
  toJSON (FofFields NonEmpty FieldName
fieldNames) =
    forall a. ToJSON a => a -> Value
toJSON NonEmpty FieldName
fieldNames

instance FromJSON FieldOrFields where
  parseJSON :: Value -> Parser FieldOrFields
parseJSON Value
v =
    FieldName -> FieldOrFields
FofField forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NonEmpty FieldName -> FieldOrFields
FofFields forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. FromJSON a => [Value] -> Parser (NonEmpty a)
parseNEJSON forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a. FromJSON a => Value -> Parser a
parseJSON Value
v)

data PrefixQuery = PrefixQuery
  { PrefixQuery -> FieldName
prefixQueryField :: FieldName,
    PrefixQuery -> Text
prefixQueryPrefixValue :: Text,
    PrefixQuery -> Maybe Boost
prefixQueryBoost :: Maybe Boost
  }
  deriving (PrefixQuery -> PrefixQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrefixQuery -> PrefixQuery -> Bool
$c/= :: PrefixQuery -> PrefixQuery -> Bool
== :: PrefixQuery -> PrefixQuery -> Bool
$c== :: PrefixQuery -> PrefixQuery -> Bool
Eq, Int -> PrefixQuery -> ShowS
[PrefixQuery] -> ShowS
PrefixQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrefixQuery] -> ShowS
$cshowList :: [PrefixQuery] -> ShowS
show :: PrefixQuery -> String
$cshow :: PrefixQuery -> String
showsPrec :: Int -> PrefixQuery -> ShowS
$cshowsPrec :: Int -> PrefixQuery -> ShowS
Show, forall x. Rep PrefixQuery x -> PrefixQuery
forall x. PrefixQuery -> Rep PrefixQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PrefixQuery x -> PrefixQuery
$cfrom :: forall x. PrefixQuery -> Rep PrefixQuery x
Generic)

instance ToJSON PrefixQuery where
  toJSON :: PrefixQuery -> Value
toJSON (PrefixQuery (FieldName Text
fieldName) Text
queryValue Maybe Boost
boost) =
    [Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
    where
      base :: [Pair]
base =
        [ Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
queryValue,
          Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost
        ]

instance FromJSON PrefixQuery where
  parseJSON :: Value -> Parser PrefixQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"PrefixQuery" Object -> Parser PrefixQuery
parse
    where
      parse :: Object -> Parser PrefixQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName -> Text -> Maybe Boost -> PrefixQuery
PrefixQuery FieldName
fn
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"

data NestedQuery = NestedQuery
  { NestedQuery -> QueryPath
nestedQueryPath :: QueryPath,
    NestedQuery -> ScoreType
nestedQueryScoreType :: ScoreType,
    NestedQuery -> Query
nestedQuery :: Query,
    NestedQuery -> Maybe InnerHits
nestedQueryInnerHits :: Maybe InnerHits
  }
  deriving (NestedQuery -> NestedQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NestedQuery -> NestedQuery -> Bool
$c/= :: NestedQuery -> NestedQuery -> Bool
== :: NestedQuery -> NestedQuery -> Bool
$c== :: NestedQuery -> NestedQuery -> Bool
Eq, Int -> NestedQuery -> ShowS
[NestedQuery] -> ShowS
NestedQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NestedQuery] -> ShowS
$cshowList :: [NestedQuery] -> ShowS
show :: NestedQuery -> String
$cshow :: NestedQuery -> String
showsPrec :: Int -> NestedQuery -> ShowS
$cshowsPrec :: Int -> NestedQuery -> ShowS
Show, forall x. Rep NestedQuery x -> NestedQuery
forall x. NestedQuery -> Rep NestedQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NestedQuery x -> NestedQuery
$cfrom :: forall x. NestedQuery -> Rep NestedQuery x
Generic)

instance ToJSON NestedQuery where
  toJSON :: NestedQuery -> Value
toJSON (NestedQuery QueryPath
nqPath ScoreType
nqScoreType Query
nqQuery Maybe InnerHits
nqInnerHits) =
    [Pair] -> Value
omitNulls
      [ Key
"path" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= QueryPath
nqPath,
        Key
"score_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= ScoreType
nqScoreType,
        Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
nqQuery,
        Key
"inner_hits" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe InnerHits
nqInnerHits
      ]

instance FromJSON NestedQuery where
  parseJSON :: Value -> Parser NestedQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"NestedQuery" Object -> Parser NestedQuery
parse
    where
      parse :: Object -> Parser NestedQuery
parse Object
o =
        QueryPath -> ScoreType -> Query -> Maybe InnerHits -> NestedQuery
NestedQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"score_mode"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inner_hits"

data MoreLikeThisFieldQuery = MoreLikeThisFieldQuery
  { MoreLikeThisFieldQuery -> Text
moreLikeThisFieldText :: Text,
    MoreLikeThisFieldQuery -> FieldName
moreLikeThisFieldFields :: FieldName,
    -- default 0.3 (30%)
    MoreLikeThisFieldQuery -> Maybe PercentMatch
moreLikeThisFieldPercentMatch :: Maybe PercentMatch,
    MoreLikeThisFieldQuery -> Maybe MinimumTermFrequency
moreLikeThisFieldMinimumTermFreq :: Maybe MinimumTermFrequency,
    MoreLikeThisFieldQuery -> Maybe MaxQueryTerms
moreLikeThisFieldMaxQueryTerms :: Maybe MaxQueryTerms,
    MoreLikeThisFieldQuery -> Maybe (NonEmpty StopWord)
moreLikeThisFieldStopWords :: Maybe (NonEmpty StopWord),
    MoreLikeThisFieldQuery -> Maybe MinDocFrequency
moreLikeThisFieldMinDocFrequency :: Maybe MinDocFrequency,
    MoreLikeThisFieldQuery -> Maybe MaxDocFrequency
moreLikeThisFieldMaxDocFrequency :: Maybe MaxDocFrequency,
    MoreLikeThisFieldQuery -> Maybe MinWordLength
moreLikeThisFieldMinWordLength :: Maybe MinWordLength,
    MoreLikeThisFieldQuery -> Maybe MaxWordLength
moreLikeThisFieldMaxWordLength :: Maybe MaxWordLength,
    MoreLikeThisFieldQuery -> Maybe BoostTerms
moreLikeThisFieldBoostTerms :: Maybe BoostTerms,
    MoreLikeThisFieldQuery -> Maybe Boost
moreLikeThisFieldBoost :: Maybe Boost,
    MoreLikeThisFieldQuery -> Maybe Analyzer
moreLikeThisFieldAnalyzer :: Maybe Analyzer
  }
  deriving (MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
$c/= :: MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
== :: MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
$c== :: MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
Eq, Int -> MoreLikeThisFieldQuery -> ShowS
[MoreLikeThisFieldQuery] -> ShowS
MoreLikeThisFieldQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MoreLikeThisFieldQuery] -> ShowS
$cshowList :: [MoreLikeThisFieldQuery] -> ShowS
show :: MoreLikeThisFieldQuery -> String
$cshow :: MoreLikeThisFieldQuery -> String
showsPrec :: Int -> MoreLikeThisFieldQuery -> ShowS
$cshowsPrec :: Int -> MoreLikeThisFieldQuery -> ShowS
Show, forall x. Rep MoreLikeThisFieldQuery x -> MoreLikeThisFieldQuery
forall x. MoreLikeThisFieldQuery -> Rep MoreLikeThisFieldQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MoreLikeThisFieldQuery x -> MoreLikeThisFieldQuery
$cfrom :: forall x. MoreLikeThisFieldQuery -> Rep MoreLikeThisFieldQuery x
Generic)

instance ToJSON MoreLikeThisFieldQuery where
  toJSON :: MoreLikeThisFieldQuery -> Value
toJSON
    ( MoreLikeThisFieldQuery
        Text
text
        (FieldName Text
fieldName)
        Maybe PercentMatch
percent
        Maybe MinimumTermFrequency
mtf
        Maybe MaxQueryTerms
mqt
        Maybe (NonEmpty StopWord)
stopwords
        Maybe MinDocFrequency
mindf
        Maybe MaxDocFrequency
maxdf
        Maybe MinWordLength
minwl
        Maybe MaxWordLength
maxwl
        Maybe BoostTerms
boostTerms
        Maybe Boost
boost
        Maybe Analyzer
analyzer
      ) =
      [Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"like_text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
text,
            Key
"percent_terms_to_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PercentMatch
percent,
            Key
"min_term_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinimumTermFrequency
mtf,
            Key
"max_query_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxQueryTerms
mqt,
            Key
"stop_words" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe (NonEmpty StopWord)
stopwords,
            Key
"min_doc_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinDocFrequency
mindf,
            Key
"max_doc_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxDocFrequency
maxdf,
            Key
"min_word_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinWordLength
minwl,
            Key
"max_word_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxWordLength
maxwl,
            Key
"boost_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BoostTerms
boostTerms,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
            Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer
          ]

instance FromJSON MoreLikeThisFieldQuery where
  parseJSON :: Value -> Parser MoreLikeThisFieldQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MoreLikeThisFieldQuery" Object -> Parser MoreLikeThisFieldQuery
parse
    where
      parse :: Object -> Parser MoreLikeThisFieldQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        Text
-> FieldName
-> Maybe PercentMatch
-> Maybe MinimumTermFrequency
-> Maybe MaxQueryTerms
-> Maybe (NonEmpty StopWord)
-> Maybe MinDocFrequency
-> Maybe MaxDocFrequency
-> Maybe MinWordLength
-> Maybe MaxWordLength
-> Maybe BoostTerms
-> Maybe Boost
-> Maybe Analyzer
-> MoreLikeThisFieldQuery
MoreLikeThisFieldQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure FieldName
fn
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"percent_terms_to_match"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_term_freq"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_query_terms"
          -- <*> (optionalNE =<< o .:? "stop_words")
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"stop_words"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_doc_freq"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_doc_freq"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_word_length"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_word_length"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost_terms"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"

-- optionalNE = maybe (pure Nothing) (fmap Just . parseNEJSON)

data MoreLikeThisQuery = MoreLikeThisQuery
  { MoreLikeThisQuery -> Text
moreLikeThisText :: Text,
    MoreLikeThisQuery -> Maybe (NonEmpty FieldName)
moreLikeThisFields :: Maybe (NonEmpty FieldName),
    -- default 0.3 (30%)
    MoreLikeThisQuery -> Maybe PercentMatch
moreLikeThisPercentMatch :: Maybe PercentMatch,
    MoreLikeThisQuery -> Maybe MinimumTermFrequency
moreLikeThisMinimumTermFreq :: Maybe MinimumTermFrequency,
    MoreLikeThisQuery -> Maybe MaxQueryTerms
moreLikeThisMaxQueryTerms :: Maybe MaxQueryTerms,
    MoreLikeThisQuery -> Maybe (NonEmpty StopWord)
moreLikeThisStopWords :: Maybe (NonEmpty StopWord),
    MoreLikeThisQuery -> Maybe MinDocFrequency
moreLikeThisMinDocFrequency :: Maybe MinDocFrequency,
    MoreLikeThisQuery -> Maybe MaxDocFrequency
moreLikeThisMaxDocFrequency :: Maybe MaxDocFrequency,
    MoreLikeThisQuery -> Maybe MinWordLength
moreLikeThisMinWordLength :: Maybe MinWordLength,
    MoreLikeThisQuery -> Maybe MaxWordLength
moreLikeThisMaxWordLength :: Maybe MaxWordLength,
    MoreLikeThisQuery -> Maybe BoostTerms
moreLikeThisBoostTerms :: Maybe BoostTerms,
    MoreLikeThisQuery -> Maybe Boost
moreLikeThisBoost :: Maybe Boost,
    MoreLikeThisQuery -> Maybe Analyzer
moreLikeThisAnalyzer :: Maybe Analyzer
  }
  deriving (MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
$c/= :: MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
== :: MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
$c== :: MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
Eq, Int -> MoreLikeThisQuery -> ShowS
[MoreLikeThisQuery] -> ShowS
MoreLikeThisQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MoreLikeThisQuery] -> ShowS
$cshowList :: [MoreLikeThisQuery] -> ShowS
show :: MoreLikeThisQuery -> String
$cshow :: MoreLikeThisQuery -> String
showsPrec :: Int -> MoreLikeThisQuery -> ShowS
$cshowsPrec :: Int -> MoreLikeThisQuery -> ShowS
Show, forall x. Rep MoreLikeThisQuery x -> MoreLikeThisQuery
forall x. MoreLikeThisQuery -> Rep MoreLikeThisQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MoreLikeThisQuery x -> MoreLikeThisQuery
$cfrom :: forall x. MoreLikeThisQuery -> Rep MoreLikeThisQuery x
Generic)

instance ToJSON MoreLikeThisQuery where
  toJSON :: MoreLikeThisQuery -> Value
toJSON
    ( MoreLikeThisQuery
        Text
text
        Maybe (NonEmpty FieldName)
fields
        Maybe PercentMatch
percent
        Maybe MinimumTermFrequency
mtf
        Maybe MaxQueryTerms
mqt
        Maybe (NonEmpty StopWord)
stopwords
        Maybe MinDocFrequency
mindf
        Maybe MaxDocFrequency
maxdf
        Maybe MinWordLength
minwl
        Maybe MaxWordLength
maxwl
        Maybe BoostTerms
boostTerms
        Maybe Boost
boost
        Maybe Analyzer
analyzer
      ) =
      [Pair] -> Value
omitNulls [Pair]
base
      where
        base :: [Pair]
base =
          [ Key
"like_text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
text,
            Key
"fields" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe (NonEmpty FieldName)
fields,
            Key
"percent_terms_to_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PercentMatch
percent,
            Key
"min_term_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinimumTermFrequency
mtf,
            Key
"max_query_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxQueryTerms
mqt,
            Key
"stop_words" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe (NonEmpty StopWord)
stopwords,
            Key
"min_doc_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinDocFrequency
mindf,
            Key
"max_doc_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxDocFrequency
maxdf,
            Key
"min_word_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinWordLength
minwl,
            Key
"max_word_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxWordLength
maxwl,
            Key
"boost_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BoostTerms
boostTerms,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
            Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer
          ]

instance FromJSON MoreLikeThisQuery where
  parseJSON :: Value -> Parser MoreLikeThisQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MoreLikeThisQuery" Object -> Parser MoreLikeThisQuery
parse
    where
      parse :: Object -> Parser MoreLikeThisQuery
parse Object
o =
        Text
-> Maybe (NonEmpty FieldName)
-> Maybe PercentMatch
-> Maybe MinimumTermFrequency
-> Maybe MaxQueryTerms
-> Maybe (NonEmpty StopWord)
-> Maybe MinDocFrequency
-> Maybe MaxDocFrequency
-> Maybe MinWordLength
-> Maybe MaxWordLength
-> Maybe BoostTerms
-> Maybe Boost
-> Maybe Analyzer
-> MoreLikeThisQuery
MoreLikeThisQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
          -- <*> (optionalNE =<< o .:? "fields")
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o 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
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"percent_terms_to_match"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_term_freq"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_query_terms"
          -- <*> (optionalNE =<< o .:? "stop_words")
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"stop_words"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_doc_freq"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_doc_freq"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_word_length"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_word_length"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost_terms"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"

-- optionalNE = maybe (pure Nothing) (fmap Just . parseNEJSON)

data IndicesQuery = IndicesQuery
  { IndicesQuery -> [IndexName]
indicesQueryIndices :: [IndexName],
    IndicesQuery -> Query
indicesQuery :: Query,
    -- default "all"
    IndicesQuery -> Maybe Query
indicesQueryNoMatch :: Maybe Query
  }
  deriving (IndicesQuery -> IndicesQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IndicesQuery -> IndicesQuery -> Bool
$c/= :: IndicesQuery -> IndicesQuery -> Bool
== :: IndicesQuery -> IndicesQuery -> Bool
$c== :: IndicesQuery -> IndicesQuery -> Bool
Eq, Int -> IndicesQuery -> ShowS
[IndicesQuery] -> ShowS
IndicesQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IndicesQuery] -> ShowS
$cshowList :: [IndicesQuery] -> ShowS
show :: IndicesQuery -> String
$cshow :: IndicesQuery -> String
showsPrec :: Int -> IndicesQuery -> ShowS
$cshowsPrec :: Int -> IndicesQuery -> ShowS
Show, forall x. Rep IndicesQuery x -> IndicesQuery
forall x. IndicesQuery -> Rep IndicesQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IndicesQuery x -> IndicesQuery
$cfrom :: forall x. IndicesQuery -> Rep IndicesQuery x
Generic)

instance ToJSON IndicesQuery where
  toJSON :: IndicesQuery -> Value
toJSON (IndicesQuery [IndexName]
indices Query
query Maybe Query
noMatch) =
    [Pair] -> Value
omitNulls
      [ Key
"indices" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [IndexName]
indices,
        Key
"no_match_query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Query
noMatch,
        Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
query
      ]

instance FromJSON IndicesQuery where
  parseJSON :: Value -> Parser IndicesQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"IndicesQuery" Object -> Parser IndicesQuery
parse
    where
      parse :: Object -> Parser IndicesQuery
parse Object
o =
        [IndexName] -> Query -> Maybe Query -> IndicesQuery
IndicesQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"indices" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"no_match_query"

data HasParentQuery = HasParentQuery
  { HasParentQuery -> RelationName
hasParentQueryType :: RelationName,
    HasParentQuery -> Query
hasParentQuery :: Query,
    HasParentQuery -> Maybe AggregateParentScore
hasParentQueryScore :: Maybe AggregateParentScore,
    HasParentQuery -> Maybe IgnoreUnmapped
hasParentIgnoreUnmapped :: Maybe IgnoreUnmapped
  }
  deriving (HasParentQuery -> HasParentQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HasParentQuery -> HasParentQuery -> Bool
$c/= :: HasParentQuery -> HasParentQuery -> Bool
== :: HasParentQuery -> HasParentQuery -> Bool
$c== :: HasParentQuery -> HasParentQuery -> Bool
Eq, Int -> HasParentQuery -> ShowS
[HasParentQuery] -> ShowS
HasParentQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HasParentQuery] -> ShowS
$cshowList :: [HasParentQuery] -> ShowS
show :: HasParentQuery -> String
$cshow :: HasParentQuery -> String
showsPrec :: Int -> HasParentQuery -> ShowS
$cshowsPrec :: Int -> HasParentQuery -> ShowS
Show, forall x. Rep HasParentQuery x -> HasParentQuery
forall x. HasParentQuery -> Rep HasParentQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HasParentQuery x -> HasParentQuery
$cfrom :: forall x. HasParentQuery -> Rep HasParentQuery x
Generic)

instance ToJSON HasParentQuery where
  toJSON :: HasParentQuery -> Value
toJSON (HasParentQuery RelationName
queryType Query
query Maybe AggregateParentScore
scoreType Maybe IgnoreUnmapped
ignoreUnmapped) =
    [Pair] -> Value
omitNulls
      [ Key
"parent_type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RelationName
queryType,
        Key
"score" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe AggregateParentScore
scoreType,
        Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
query,
        Key
"ignore_unmapped" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe IgnoreUnmapped
ignoreUnmapped
      ]

instance FromJSON HasParentQuery where
  parseJSON :: Value -> Parser HasParentQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HasParentQuery" Object -> Parser HasParentQuery
parse
    where
      parse :: Object -> Parser HasParentQuery
parse Object
o =
        RelationName
-> Query
-> Maybe AggregateParentScore
-> Maybe IgnoreUnmapped
-> HasParentQuery
HasParentQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"parent_type"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"score"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"ignore_unmapped"

data HasChildQuery = HasChildQuery
  { HasChildQuery -> RelationName
hasChildQueryType :: RelationName,
    HasChildQuery -> Query
hasChildQuery :: Query,
    HasChildQuery -> Maybe ScoreType
hasChildQueryScoreType :: Maybe ScoreType,
    HasChildQuery -> Maybe IgnoreUnmapped
hasChildIgnoreUnmappped :: Maybe IgnoreUnmapped,
    HasChildQuery -> Maybe MinChildren
hasChildMinChildren :: Maybe MinChildren,
    HasChildQuery -> Maybe MaxChildren
hasChildMaxChildren :: Maybe MaxChildren
  }
  deriving (HasChildQuery -> HasChildQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HasChildQuery -> HasChildQuery -> Bool
$c/= :: HasChildQuery -> HasChildQuery -> Bool
== :: HasChildQuery -> HasChildQuery -> Bool
$c== :: HasChildQuery -> HasChildQuery -> Bool
Eq, Int -> HasChildQuery -> ShowS
[HasChildQuery] -> ShowS
HasChildQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HasChildQuery] -> ShowS
$cshowList :: [HasChildQuery] -> ShowS
show :: HasChildQuery -> String
$cshow :: HasChildQuery -> String
showsPrec :: Int -> HasChildQuery -> ShowS
$cshowsPrec :: Int -> HasChildQuery -> ShowS
Show, forall x. Rep HasChildQuery x -> HasChildQuery
forall x. HasChildQuery -> Rep HasChildQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HasChildQuery x -> HasChildQuery
$cfrom :: forall x. HasChildQuery -> Rep HasChildQuery x
Generic)

instance ToJSON HasChildQuery where
  toJSON :: HasChildQuery -> Value
toJSON (HasChildQuery RelationName
queryType Query
query Maybe ScoreType
scoreType Maybe IgnoreUnmapped
ignoreUnmapped Maybe MinChildren
minChildren Maybe MaxChildren
maxChildren) =
    [Pair] -> Value
omitNulls
      [ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
query,
        Key
"score_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe ScoreType
scoreType,
        Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RelationName
queryType,
        Key
"min_children" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinChildren
minChildren,
        Key
"max_children" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxChildren
maxChildren,
        Key
"ignore_unmapped" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe IgnoreUnmapped
ignoreUnmapped
      ]

instance FromJSON HasChildQuery where
  parseJSON :: Value -> Parser HasChildQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HasChildQuery" Object -> Parser HasChildQuery
parse
    where
      parse :: Object -> Parser HasChildQuery
parse Object
o =
        RelationName
-> Query
-> Maybe ScoreType
-> Maybe IgnoreUnmapped
-> Maybe MinChildren
-> Maybe MaxChildren
-> HasChildQuery
HasChildQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"score_mode"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"ignore_unmapped"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_children"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_children"

data ScoreType
  = ScoreTypeMax
  | ScoreTypeSum
  | ScoreTypeAvg
  | ScoreTypeNone
  deriving (ScoreType -> ScoreType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScoreType -> ScoreType -> Bool
$c/= :: ScoreType -> ScoreType -> Bool
== :: ScoreType -> ScoreType -> Bool
$c== :: ScoreType -> ScoreType -> Bool
Eq, Int -> ScoreType -> ShowS
[ScoreType] -> ShowS
ScoreType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScoreType] -> ShowS
$cshowList :: [ScoreType] -> ShowS
show :: ScoreType -> String
$cshow :: ScoreType -> String
showsPrec :: Int -> ScoreType -> ShowS
$cshowsPrec :: Int -> ScoreType -> ShowS
Show, forall x. Rep ScoreType x -> ScoreType
forall x. ScoreType -> Rep ScoreType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ScoreType x -> ScoreType
$cfrom :: forall x. ScoreType -> Rep ScoreType x
Generic)

instance ToJSON ScoreType where
  toJSON :: ScoreType -> Value
toJSON ScoreType
ScoreTypeMax = Value
"max"
  toJSON ScoreType
ScoreTypeAvg = Value
"avg"
  toJSON ScoreType
ScoreTypeSum = Value
"sum"
  toJSON ScoreType
ScoreTypeNone = Value
"none"

instance FromJSON ScoreType where
  parseJSON :: Value -> Parser ScoreType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"ScoreType" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f ScoreType
parse
    where
      parse :: a -> f ScoreType
parse a
"max" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ScoreType
ScoreTypeMax
      parse a
"avg" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ScoreType
ScoreTypeAvg
      parse a
"sum" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ScoreType
ScoreTypeSum
      parse a
"none" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ScoreType
ScoreTypeNone
      parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected ScoreType: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)

data FuzzyQuery = FuzzyQuery
  { FuzzyQuery -> FieldName
fuzzyQueryField :: FieldName,
    FuzzyQuery -> Text
fuzzyQueryValue :: Text,
    FuzzyQuery -> PrefixLength
fuzzyQueryPrefixLength :: PrefixLength,
    FuzzyQuery -> MaxExpansions
fuzzyQueryMaxExpansions :: MaxExpansions,
    FuzzyQuery -> Fuzziness
fuzzyQueryFuzziness :: Fuzziness,
    FuzzyQuery -> Maybe Boost
fuzzyQueryBoost :: Maybe Boost
  }
  deriving (FuzzyQuery -> FuzzyQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FuzzyQuery -> FuzzyQuery -> Bool
$c/= :: FuzzyQuery -> FuzzyQuery -> Bool
== :: FuzzyQuery -> FuzzyQuery -> Bool
$c== :: FuzzyQuery -> FuzzyQuery -> Bool
Eq, Int -> FuzzyQuery -> ShowS
[FuzzyQuery] -> ShowS
FuzzyQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FuzzyQuery] -> ShowS
$cshowList :: [FuzzyQuery] -> ShowS
show :: FuzzyQuery -> String
$cshow :: FuzzyQuery -> String
showsPrec :: Int -> FuzzyQuery -> ShowS
$cshowsPrec :: Int -> FuzzyQuery -> ShowS
Show, forall x. Rep FuzzyQuery x -> FuzzyQuery
forall x. FuzzyQuery -> Rep FuzzyQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FuzzyQuery x -> FuzzyQuery
$cfrom :: forall x. FuzzyQuery -> Rep FuzzyQuery x
Generic)

instance ToJSON FuzzyQuery where
  toJSON :: FuzzyQuery -> Value
toJSON
    ( FuzzyQuery
        (FieldName Text
fieldName)
        Text
queryText
        PrefixLength
prefixLength
        MaxExpansions
maxEx
        Fuzziness
fuzziness
        Maybe Boost
boost
      ) =
      [Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
queryText,
            Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
            Key
"prefix_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
            Key
"max_expansions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MaxExpansions
maxEx
          ]

instance FromJSON FuzzyQuery where
  parseJSON :: Value -> Parser FuzzyQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyQuery" Object -> Parser FuzzyQuery
parse
    where
      parse :: Object -> Parser FuzzyQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName
-> Text
-> PrefixLength
-> MaxExpansions
-> Fuzziness
-> Maybe Boost
-> FuzzyQuery
FuzzyQuery FieldName
fn
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_expansions"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"

data FuzzyLikeFieldQuery = FuzzyLikeFieldQuery
  { FuzzyLikeFieldQuery -> FieldName
fuzzyLikeField :: FieldName,
    -- anaphora is good for the soul.
    FuzzyLikeFieldQuery -> Text
fuzzyLikeFieldText :: Text,
    FuzzyLikeFieldQuery -> MaxQueryTerms
fuzzyLikeFieldMaxQueryTerms :: MaxQueryTerms,
    FuzzyLikeFieldQuery -> IgnoreTermFrequency
fuzzyLikeFieldIgnoreTermFrequency :: IgnoreTermFrequency,
    FuzzyLikeFieldQuery -> Fuzziness
fuzzyLikeFieldFuzziness :: Fuzziness,
    FuzzyLikeFieldQuery -> PrefixLength
fuzzyLikeFieldPrefixLength :: PrefixLength,
    FuzzyLikeFieldQuery -> Boost
fuzzyLikeFieldBoost :: Boost,
    FuzzyLikeFieldQuery -> Maybe Analyzer
fuzzyLikeFieldAnalyzer :: Maybe Analyzer
  }
  deriving (FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
$c/= :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
== :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
$c== :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
Eq, Int -> FuzzyLikeFieldQuery -> ShowS
[FuzzyLikeFieldQuery] -> ShowS
FuzzyLikeFieldQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FuzzyLikeFieldQuery] -> ShowS
$cshowList :: [FuzzyLikeFieldQuery] -> ShowS
show :: FuzzyLikeFieldQuery -> String
$cshow :: FuzzyLikeFieldQuery -> String
showsPrec :: Int -> FuzzyLikeFieldQuery -> ShowS
$cshowsPrec :: Int -> FuzzyLikeFieldQuery -> ShowS
Show, forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
$cfrom :: forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
Generic)

instance ToJSON FuzzyLikeFieldQuery where
  toJSON :: FuzzyLikeFieldQuery -> Value
toJSON
    ( FuzzyLikeFieldQuery
        (FieldName Text
fieldName)
        Text
fieldText
        MaxQueryTerms
maxTerms
        IgnoreTermFrequency
ignoreFreq
        Fuzziness
fuzziness
        PrefixLength
prefixLength
        Boost
boost
        Maybe Analyzer
analyzer
      ) =
      [Pair] -> Value
object
        [ Text -> Key
fromText Text
fieldName
            forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls
              [ Key
"like_text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
fieldText,
                Key
"max_query_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MaxQueryTerms
maxTerms,
                Key
"ignore_tf" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= IgnoreTermFrequency
ignoreFreq,
                Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
                Key
"prefix_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
                Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
                Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
              ]
        ]

instance FromJSON FuzzyLikeFieldQuery where
  parseJSON :: Value -> Parser FuzzyLikeFieldQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyLikeFieldQuery" Object -> Parser FuzzyLikeFieldQuery
parse
    where
      parse :: Object -> Parser FuzzyLikeFieldQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName
-> Text
-> MaxQueryTerms
-> IgnoreTermFrequency
-> Fuzziness
-> PrefixLength
-> Boost
-> Maybe Analyzer
-> FuzzyLikeFieldQuery
FuzzyLikeFieldQuery FieldName
fn
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_query_terms"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ignore_tf"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"

data FuzzyLikeThisQuery = FuzzyLikeThisQuery
  { FuzzyLikeThisQuery -> [FieldName]
fuzzyLikeFields :: [FieldName],
    FuzzyLikeThisQuery -> Text
fuzzyLikeText :: Text,
    FuzzyLikeThisQuery -> MaxQueryTerms
fuzzyLikeMaxQueryTerms :: MaxQueryTerms,
    FuzzyLikeThisQuery -> IgnoreTermFrequency
fuzzyLikeIgnoreTermFrequency :: IgnoreTermFrequency,
    FuzzyLikeThisQuery -> Fuzziness
fuzzyLikeFuzziness :: Fuzziness,
    FuzzyLikeThisQuery -> PrefixLength
fuzzyLikePrefixLength :: PrefixLength,
    FuzzyLikeThisQuery -> Boost
fuzzyLikeBoost :: Boost,
    FuzzyLikeThisQuery -> Maybe Analyzer
fuzzyLikeAnalyzer :: Maybe Analyzer
  }
  deriving (FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
$c/= :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
== :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
$c== :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
Eq, Int -> FuzzyLikeThisQuery -> ShowS
[FuzzyLikeThisQuery] -> ShowS
FuzzyLikeThisQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FuzzyLikeThisQuery] -> ShowS
$cshowList :: [FuzzyLikeThisQuery] -> ShowS
show :: FuzzyLikeThisQuery -> String
$cshow :: FuzzyLikeThisQuery -> String
showsPrec :: Int -> FuzzyLikeThisQuery -> ShowS
$cshowsPrec :: Int -> FuzzyLikeThisQuery -> ShowS
Show, forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
$cfrom :: forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
Generic)

instance ToJSON FuzzyLikeThisQuery where
  toJSON :: FuzzyLikeThisQuery -> Value
toJSON
    ( FuzzyLikeThisQuery
        [FieldName]
fields
        Text
text
        MaxQueryTerms
maxTerms
        IgnoreTermFrequency
ignoreFreq
        Fuzziness
fuzziness
        PrefixLength
prefixLength
        Boost
boost
        Maybe Analyzer
analyzer
      ) =
      [Pair] -> Value
omitNulls [Pair]
base
      where
        base :: [Pair]
base =
          [ Key
"fields" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [FieldName]
fields,
            Key
"like_text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
text,
            Key
"max_query_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MaxQueryTerms
maxTerms,
            Key
"ignore_tf" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= IgnoreTermFrequency
ignoreFreq,
            Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
            Key
"prefix_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
            Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
          ]

instance FromJSON FuzzyLikeThisQuery where
  parseJSON :: Value -> Parser FuzzyLikeThisQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyLikeThisQuery" Object -> Parser FuzzyLikeThisQuery
parse
    where
      parse :: Object -> Parser FuzzyLikeThisQuery
parse Object
o =
        [FieldName]
-> Text
-> MaxQueryTerms
-> IgnoreTermFrequency
-> Fuzziness
-> PrefixLength
-> Boost
-> Maybe Analyzer
-> FuzzyLikeThisQuery
FuzzyLikeThisQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_query_terms"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ignore_tf"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"

data DisMaxQuery = DisMaxQuery
  { DisMaxQuery -> [Query]
disMaxQueries :: [Query],
    -- default 0.0
    DisMaxQuery -> Tiebreaker
disMaxTiebreaker :: Tiebreaker,
    DisMaxQuery -> Maybe Boost
disMaxBoost :: Maybe Boost
  }
  deriving (DisMaxQuery -> DisMaxQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DisMaxQuery -> DisMaxQuery -> Bool
$c/= :: DisMaxQuery -> DisMaxQuery -> Bool
== :: DisMaxQuery -> DisMaxQuery -> Bool
$c== :: DisMaxQuery -> DisMaxQuery -> Bool
Eq, Int -> DisMaxQuery -> ShowS
[DisMaxQuery] -> ShowS
DisMaxQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DisMaxQuery] -> ShowS
$cshowList :: [DisMaxQuery] -> ShowS
show :: DisMaxQuery -> String
$cshow :: DisMaxQuery -> String
showsPrec :: Int -> DisMaxQuery -> ShowS
$cshowsPrec :: Int -> DisMaxQuery -> ShowS
Show, forall x. Rep DisMaxQuery x -> DisMaxQuery
forall x. DisMaxQuery -> Rep DisMaxQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DisMaxQuery x -> DisMaxQuery
$cfrom :: forall x. DisMaxQuery -> Rep DisMaxQuery x
Generic)

instance ToJSON DisMaxQuery where
  toJSON :: DisMaxQuery -> Value
toJSON (DisMaxQuery [Query]
queries Tiebreaker
tiebreaker Maybe Boost
boost) =
    [Pair] -> Value
omitNulls [Pair]
base
    where
      base :: [Pair]
base =
        [ Key
"queries" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Query]
queries,
          Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
          Key
"tie_breaker" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Tiebreaker
tiebreaker
        ]

instance FromJSON DisMaxQuery where
  parseJSON :: Value -> Parser DisMaxQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"DisMaxQuery" Object -> Parser DisMaxQuery
parse
    where
      parse :: Object -> Parser DisMaxQuery
parse Object
o =
        [Query] -> Tiebreaker -> Maybe Boost -> DisMaxQuery
DisMaxQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"queries" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tie_breaker"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"

data MatchQuery = MatchQuery
  { MatchQuery -> FieldName
matchQueryField :: FieldName,
    MatchQuery -> QueryString
matchQueryQueryString :: QueryString,
    MatchQuery -> BooleanOperator
matchQueryOperator :: BooleanOperator,
    MatchQuery -> ZeroTermsQuery
matchQueryZeroTerms :: ZeroTermsQuery,
    MatchQuery -> Maybe CutoffFrequency
matchQueryCutoffFrequency :: Maybe CutoffFrequency,
    MatchQuery -> Maybe MatchQueryType
matchQueryMatchType :: Maybe MatchQueryType,
    MatchQuery -> Maybe Analyzer
matchQueryAnalyzer :: Maybe Analyzer,
    MatchQuery -> Maybe MaxExpansions
matchQueryMaxExpansions :: Maybe MaxExpansions,
    MatchQuery -> Maybe Lenient
matchQueryLenient :: Maybe Lenient,
    MatchQuery -> Maybe Boost
matchQueryBoost :: Maybe Boost,
    MatchQuery -> Maybe Text
matchQueryMinimumShouldMatch :: Maybe Text,
    MatchQuery -> Maybe Fuzziness
matchQueryFuzziness :: Maybe Fuzziness
  }
  deriving (MatchQuery -> MatchQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MatchQuery -> MatchQuery -> Bool
$c/= :: MatchQuery -> MatchQuery -> Bool
== :: MatchQuery -> MatchQuery -> Bool
$c== :: MatchQuery -> MatchQuery -> Bool
Eq, Int -> MatchQuery -> ShowS
[MatchQuery] -> ShowS
MatchQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MatchQuery] -> ShowS
$cshowList :: [MatchQuery] -> ShowS
show :: MatchQuery -> String
$cshow :: MatchQuery -> String
showsPrec :: Int -> MatchQuery -> ShowS
$cshowsPrec :: Int -> MatchQuery -> ShowS
Show, forall x. Rep MatchQuery x -> MatchQuery
forall x. MatchQuery -> Rep MatchQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MatchQuery x -> MatchQuery
$cfrom :: forall x. MatchQuery -> Rep MatchQuery x
Generic)

instance ToJSON MatchQuery where
  toJSON :: MatchQuery -> Value
toJSON
    ( MatchQuery
        (FieldName Text
fieldName)
        (QueryString Text
mqQueryString)
        BooleanOperator
booleanOperator
        ZeroTermsQuery
zeroTermsQuery
        Maybe CutoffFrequency
cutoffFrequency
        Maybe MatchQueryType
matchQueryType
        Maybe Analyzer
analyzer
        Maybe MaxExpansions
maxExpansions
        Maybe Lenient
lenient
        Maybe Boost
boost
        Maybe Text
minShouldMatch
        Maybe Fuzziness
mqFuzziness
      ) =
      [Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
mqQueryString,
            Key
"operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
booleanOperator,
            Key
"zero_terms_query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= ZeroTermsQuery
zeroTermsQuery,
            Key
"cutoff_frequency" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe CutoffFrequency
cutoffFrequency,
            Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MatchQueryType
matchQueryType,
            Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
            Key
"max_expansions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxExpansions
maxExpansions,
            Key
"lenient" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lenient
lenient,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
            Key
"minimum_should_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
minShouldMatch,
            Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Fuzziness
mqFuzziness
          ]

instance FromJSON MatchQuery where
  parseJSON :: Value -> Parser MatchQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MatchQuery" Object -> Parser MatchQuery
parse
    where
      parse :: Object -> Parser MatchQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName
-> QueryString
-> BooleanOperator
-> ZeroTermsQuery
-> Maybe CutoffFrequency
-> Maybe MatchQueryType
-> Maybe Analyzer
-> Maybe MaxExpansions
-> Maybe Lenient
-> Maybe Boost
-> Maybe Text
-> Maybe Fuzziness
-> MatchQuery
MatchQuery FieldName
fn
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"operator"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"zero_terms_query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"cutoff_frequency"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"type"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_expansions"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lenient"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum_should_match"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fuzziness"

-- | 'mkMatchQuery' is a convenience function that defaults the less common parameters,
--    enabling you to provide only the 'FieldName' and 'QueryString' to make a 'MatchQuery'
mkMatchQuery :: FieldName -> QueryString -> MatchQuery
mkMatchQuery :: FieldName -> QueryString -> MatchQuery
mkMatchQuery FieldName
field QueryString
query = FieldName
-> QueryString
-> BooleanOperator
-> ZeroTermsQuery
-> Maybe CutoffFrequency
-> Maybe MatchQueryType
-> Maybe Analyzer
-> Maybe MaxExpansions
-> Maybe Lenient
-> Maybe Boost
-> Maybe Text
-> Maybe Fuzziness
-> MatchQuery
MatchQuery FieldName
field QueryString
query BooleanOperator
Or ZeroTermsQuery
ZeroTermsNone 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

data MatchQueryType
  = MatchPhrase
  | MatchPhrasePrefix
  deriving (MatchQueryType -> MatchQueryType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MatchQueryType -> MatchQueryType -> Bool
$c/= :: MatchQueryType -> MatchQueryType -> Bool
== :: MatchQueryType -> MatchQueryType -> Bool
$c== :: MatchQueryType -> MatchQueryType -> Bool
Eq, Int -> MatchQueryType -> ShowS
[MatchQueryType] -> ShowS
MatchQueryType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MatchQueryType] -> ShowS
$cshowList :: [MatchQueryType] -> ShowS
show :: MatchQueryType -> String
$cshow :: MatchQueryType -> String
showsPrec :: Int -> MatchQueryType -> ShowS
$cshowsPrec :: Int -> MatchQueryType -> ShowS
Show, forall x. Rep MatchQueryType x -> MatchQueryType
forall x. MatchQueryType -> Rep MatchQueryType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MatchQueryType x -> MatchQueryType
$cfrom :: forall x. MatchQueryType -> Rep MatchQueryType x
Generic)

instance ToJSON MatchQueryType where
  toJSON :: MatchQueryType -> Value
toJSON MatchQueryType
MatchPhrase = Value
"phrase"
  toJSON MatchQueryType
MatchPhrasePrefix = Value
"phrase_prefix"

instance FromJSON MatchQueryType where
  parseJSON :: Value -> Parser MatchQueryType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"MatchQueryType" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f MatchQueryType
parse
    where
      parse :: a -> f MatchQueryType
parse a
"phrase" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MatchQueryType
MatchPhrase
      parse a
"phrase_prefix" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MatchQueryType
MatchPhrasePrefix
      parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected MatchQueryType: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)

data MultiMatchQuery = MultiMatchQuery
  { MultiMatchQuery -> [FieldName]
multiMatchQueryFields :: [FieldName],
    MultiMatchQuery -> QueryString
multiMatchQueryString :: QueryString,
    MultiMatchQuery -> BooleanOperator
multiMatchQueryOperator :: BooleanOperator,
    MultiMatchQuery -> ZeroTermsQuery
multiMatchQueryZeroTerms :: ZeroTermsQuery,
    MultiMatchQuery -> Maybe Tiebreaker
multiMatchQueryTiebreaker :: Maybe Tiebreaker,
    MultiMatchQuery -> Maybe MultiMatchQueryType
multiMatchQueryType :: Maybe MultiMatchQueryType,
    MultiMatchQuery -> Maybe CutoffFrequency
multiMatchQueryCutoffFrequency :: Maybe CutoffFrequency,
    MultiMatchQuery -> Maybe Analyzer
multiMatchQueryAnalyzer :: Maybe Analyzer,
    MultiMatchQuery -> Maybe MaxExpansions
multiMatchQueryMaxExpansions :: Maybe MaxExpansions,
    MultiMatchQuery -> Maybe Lenient
multiMatchQueryLenient :: Maybe Lenient
  }
  deriving (MultiMatchQuery -> MultiMatchQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MultiMatchQuery -> MultiMatchQuery -> Bool
$c/= :: MultiMatchQuery -> MultiMatchQuery -> Bool
== :: MultiMatchQuery -> MultiMatchQuery -> Bool
$c== :: MultiMatchQuery -> MultiMatchQuery -> Bool
Eq, Int -> MultiMatchQuery -> ShowS
[MultiMatchQuery] -> ShowS
MultiMatchQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MultiMatchQuery] -> ShowS
$cshowList :: [MultiMatchQuery] -> ShowS
show :: MultiMatchQuery -> String
$cshow :: MultiMatchQuery -> String
showsPrec :: Int -> MultiMatchQuery -> ShowS
$cshowsPrec :: Int -> MultiMatchQuery -> ShowS
Show, forall x. Rep MultiMatchQuery x -> MultiMatchQuery
forall x. MultiMatchQuery -> Rep MultiMatchQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MultiMatchQuery x -> MultiMatchQuery
$cfrom :: forall x. MultiMatchQuery -> Rep MultiMatchQuery x
Generic)

instance ToJSON MultiMatchQuery where
  toJSON :: MultiMatchQuery -> Value
toJSON
    ( MultiMatchQuery
        [FieldName]
fields
        (QueryString Text
query)
        BooleanOperator
boolOp
        ZeroTermsQuery
ztQ
        Maybe Tiebreaker
tb
        Maybe MultiMatchQueryType
mmqt
        Maybe CutoffFrequency
cf
        Maybe Analyzer
analyzer
        Maybe MaxExpansions
maxEx
        Maybe Lenient
lenient
      ) =
      [Pair] -> Value
object [Key
"multi_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"fields" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. ToJSON a => a -> Value
toJSON [FieldName]
fields,
            Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
query,
            Key
"operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
boolOp,
            Key
"zero_terms_query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= ZeroTermsQuery
ztQ,
            Key
"tie_breaker" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Tiebreaker
tb,
            Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MultiMatchQueryType
mmqt,
            Key
"cutoff_frequency" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe CutoffFrequency
cf,
            Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
            Key
"max_expansions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxExpansions
maxEx,
            Key
"lenient" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lenient
lenient
          ]

instance FromJSON MultiMatchQuery where
  parseJSON :: Value -> Parser MultiMatchQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MultiMatchQuery" Object -> Parser MultiMatchQuery
parse
    where
      parse :: Object -> Parser MultiMatchQuery
parse Object
raw = do
        Object
o <- Object
raw forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"multi_match"
        [FieldName]
-> QueryString
-> BooleanOperator
-> ZeroTermsQuery
-> Maybe Tiebreaker
-> Maybe MultiMatchQueryType
-> Maybe CutoffFrequency
-> Maybe Analyzer
-> Maybe MaxExpansions
-> Maybe Lenient
-> MultiMatchQuery
MultiMatchQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"operator"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"zero_terms_query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"tie_breaker"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"type"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"cutoff_frequency"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_expansions"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lenient"

-- | 'mkMultiMatchQuery' is a convenience function that defaults the less common parameters,
--    enabling you to provide only the list of 'FieldName's and 'QueryString' to
--    make a 'MultiMatchQuery'.
mkMultiMatchQuery :: [FieldName] -> QueryString -> MultiMatchQuery
mkMultiMatchQuery :: [FieldName] -> QueryString -> MultiMatchQuery
mkMultiMatchQuery [FieldName]
matchFields QueryString
query =
  [FieldName]
-> QueryString
-> BooleanOperator
-> ZeroTermsQuery
-> Maybe Tiebreaker
-> Maybe MultiMatchQueryType
-> Maybe CutoffFrequency
-> Maybe Analyzer
-> Maybe MaxExpansions
-> Maybe Lenient
-> MultiMatchQuery
MultiMatchQuery
    [FieldName]
matchFields
    QueryString
query
    BooleanOperator
Or
    ZeroTermsQuery
ZeroTermsNone
    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

data MultiMatchQueryType
  = MultiMatchBestFields
  | MultiMatchMostFields
  | MultiMatchCrossFields
  | MultiMatchPhrase
  | MultiMatchPhrasePrefix
  deriving (MultiMatchQueryType -> MultiMatchQueryType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
$c/= :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
== :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
$c== :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
Eq, Int -> MultiMatchQueryType -> ShowS
[MultiMatchQueryType] -> ShowS
MultiMatchQueryType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MultiMatchQueryType] -> ShowS
$cshowList :: [MultiMatchQueryType] -> ShowS
show :: MultiMatchQueryType -> String
$cshow :: MultiMatchQueryType -> String
showsPrec :: Int -> MultiMatchQueryType -> ShowS
$cshowsPrec :: Int -> MultiMatchQueryType -> ShowS
Show, forall x. Rep MultiMatchQueryType x -> MultiMatchQueryType
forall x. MultiMatchQueryType -> Rep MultiMatchQueryType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MultiMatchQueryType x -> MultiMatchQueryType
$cfrom :: forall x. MultiMatchQueryType -> Rep MultiMatchQueryType x
Generic)

instance ToJSON MultiMatchQueryType where
  toJSON :: MultiMatchQueryType -> Value
toJSON MultiMatchQueryType
MultiMatchBestFields = Value
"best_fields"
  toJSON MultiMatchQueryType
MultiMatchMostFields = Value
"most_fields"
  toJSON MultiMatchQueryType
MultiMatchCrossFields = Value
"cross_fields"
  toJSON MultiMatchQueryType
MultiMatchPhrase = Value
"phrase"
  toJSON MultiMatchQueryType
MultiMatchPhrasePrefix = Value
"phrase_prefix"

instance FromJSON MultiMatchQueryType where
  parseJSON :: Value -> Parser MultiMatchQueryType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"MultiMatchPhrasePrefix" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f MultiMatchQueryType
parse
    where
      parse :: a -> f MultiMatchQueryType
parse a
"best_fields" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchBestFields
      parse a
"most_fields" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchMostFields
      parse a
"cross_fields" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchCrossFields
      parse a
"phrase" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchPhrase
      parse a
"phrase_prefix" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchPhrasePrefix
      parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected MultiMatchPhrasePrefix: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)

data BoolQuery = BoolQuery
  { BoolQuery -> [Query]
boolQueryMustMatch :: [Query],
    BoolQuery -> [Filter]
boolQueryFilter :: [Filter],
    BoolQuery -> [Query]
boolQueryMustNotMatch :: [Query],
    BoolQuery -> [Query]
boolQueryShouldMatch :: [Query],
    BoolQuery -> Maybe MinimumMatch
boolQueryMinimumShouldMatch :: Maybe MinimumMatch,
    BoolQuery -> Maybe Boost
boolQueryBoost :: Maybe Boost,
    BoolQuery -> Maybe DisableCoord
boolQueryDisableCoord :: Maybe DisableCoord
  }
  deriving (BoolQuery -> BoolQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BoolQuery -> BoolQuery -> Bool
$c/= :: BoolQuery -> BoolQuery -> Bool
== :: BoolQuery -> BoolQuery -> Bool
$c== :: BoolQuery -> BoolQuery -> Bool
Eq, Int -> BoolQuery -> ShowS
[BoolQuery] -> ShowS
BoolQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BoolQuery] -> ShowS
$cshowList :: [BoolQuery] -> ShowS
show :: BoolQuery -> String
$cshow :: BoolQuery -> String
showsPrec :: Int -> BoolQuery -> ShowS
$cshowsPrec :: Int -> BoolQuery -> ShowS
Show, forall x. Rep BoolQuery x -> BoolQuery
forall x. BoolQuery -> Rep BoolQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BoolQuery x -> BoolQuery
$cfrom :: forall x. BoolQuery -> Rep BoolQuery x
Generic)

instance ToJSON BoolQuery where
  toJSON :: BoolQuery -> Value
toJSON (BoolQuery [Query]
mustM [Filter]
filterM' [Query]
notM [Query]
shouldM Maybe MinimumMatch
bqMin Maybe Boost
boost Maybe DisableCoord
disableCoord) =
    [Pair] -> Value
omitNulls [Pair]
base
    where
      base :: [Pair]
base =
        [ Key
"must" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Query]
mustM,
          Key
"filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Filter]
filterM',
          Key
"must_not" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Query]
notM,
          Key
"should" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Query]
shouldM,
          Key
"minimum_should_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinimumMatch
bqMin,
          Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
          Key
"disable_coord" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe DisableCoord
disableCoord
        ]

instance FromJSON BoolQuery where
  parseJSON :: Value -> Parser BoolQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BoolQuery" Object -> Parser BoolQuery
parse
    where
      parse :: Object -> Parser BoolQuery
parse Object
o =
        [Query]
-> [Filter]
-> [Query]
-> [Query]
-> Maybe MinimumMatch
-> Maybe Boost
-> Maybe DisableCoord
-> BoolQuery
BoolQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"must" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"filter" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"must_not" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"should" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum_should_match"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"disable_coord"

mkBoolQuery :: [Query] -> [Filter] -> [Query] -> [Query] -> BoolQuery
mkBoolQuery :: [Query] -> [Filter] -> [Query] -> [Query] -> BoolQuery
mkBoolQuery [Query]
must [Filter]
filt [Query]
mustNot [Query]
should =
  [Query]
-> [Filter]
-> [Query]
-> [Query]
-> Maybe MinimumMatch
-> Maybe Boost
-> Maybe DisableCoord
-> BoolQuery
BoolQuery [Query]
must [Filter]
filt [Query]
mustNot [Query]
should forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing

data BoostingQuery = BoostingQuery
  { BoostingQuery -> Query
positiveQuery :: Query,
    BoostingQuery -> Query
negativeQuery :: Query,
    BoostingQuery -> Boost
negativeBoost :: Boost
  }
  deriving (BoostingQuery -> BoostingQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BoostingQuery -> BoostingQuery -> Bool
$c/= :: BoostingQuery -> BoostingQuery -> Bool
== :: BoostingQuery -> BoostingQuery -> Bool
$c== :: BoostingQuery -> BoostingQuery -> Bool
Eq, Int -> BoostingQuery -> ShowS
[BoostingQuery] -> ShowS
BoostingQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BoostingQuery] -> ShowS
$cshowList :: [BoostingQuery] -> ShowS
show :: BoostingQuery -> String
$cshow :: BoostingQuery -> String
showsPrec :: Int -> BoostingQuery -> ShowS
$cshowsPrec :: Int -> BoostingQuery -> ShowS
Show, forall x. Rep BoostingQuery x -> BoostingQuery
forall x. BoostingQuery -> Rep BoostingQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BoostingQuery x -> BoostingQuery
$cfrom :: forall x. BoostingQuery -> Rep BoostingQuery x
Generic)

instance ToJSON BoostingQuery where
  toJSON :: BoostingQuery -> Value
toJSON (BoostingQuery Query
bqPositiveQuery Query
bqNegativeQuery Boost
bqNegativeBoost) =
    [Pair] -> Value
object
      [ Key
"positive" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
bqPositiveQuery,
        Key
"negative" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
bqNegativeQuery,
        Key
"negative_boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
bqNegativeBoost
      ]

instance FromJSON BoostingQuery where
  parseJSON :: Value -> Parser BoostingQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BoostingQuery" Object -> Parser BoostingQuery
parse
    where
      parse :: Object -> Parser BoostingQuery
parse Object
o =
        Query -> Query -> Boost -> BoostingQuery
BoostingQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"positive"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"negative"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"negative_boost"

data CommonTermsQuery = CommonTermsQuery
  { CommonTermsQuery -> FieldName
commonField :: FieldName,
    CommonTermsQuery -> QueryString
commonQuery :: QueryString,
    CommonTermsQuery -> CutoffFrequency
commonCutoffFrequency :: CutoffFrequency,
    CommonTermsQuery -> BooleanOperator
commonLowFreqOperator :: BooleanOperator,
    CommonTermsQuery -> BooleanOperator
commonHighFreqOperator :: BooleanOperator,
    CommonTermsQuery -> Maybe CommonMinimumMatch
commonMinimumShouldMatch :: Maybe CommonMinimumMatch,
    CommonTermsQuery -> Maybe Boost
commonBoost :: Maybe Boost,
    CommonTermsQuery -> Maybe Analyzer
commonAnalyzer :: Maybe Analyzer,
    CommonTermsQuery -> Maybe DisableCoord
commonDisableCoord :: Maybe DisableCoord
  }
  deriving (CommonTermsQuery -> CommonTermsQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommonTermsQuery -> CommonTermsQuery -> Bool
$c/= :: CommonTermsQuery -> CommonTermsQuery -> Bool
== :: CommonTermsQuery -> CommonTermsQuery -> Bool
$c== :: CommonTermsQuery -> CommonTermsQuery -> Bool
Eq, Int -> CommonTermsQuery -> ShowS
[CommonTermsQuery] -> ShowS
CommonTermsQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CommonTermsQuery] -> ShowS
$cshowList :: [CommonTermsQuery] -> ShowS
show :: CommonTermsQuery -> String
$cshow :: CommonTermsQuery -> String
showsPrec :: Int -> CommonTermsQuery -> ShowS
$cshowsPrec :: Int -> CommonTermsQuery -> ShowS
Show, forall x. Rep CommonTermsQuery x -> CommonTermsQuery
forall x. CommonTermsQuery -> Rep CommonTermsQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CommonTermsQuery x -> CommonTermsQuery
$cfrom :: forall x. CommonTermsQuery -> Rep CommonTermsQuery x
Generic)

instance ToJSON CommonTermsQuery where
  toJSON :: CommonTermsQuery -> Value
toJSON
    ( CommonTermsQuery
        (FieldName Text
fieldName)
        (QueryString Text
query)
        CutoffFrequency
cf
        BooleanOperator
lfo
        BooleanOperator
hfo
        Maybe CommonMinimumMatch
msm
        Maybe Boost
boost
        Maybe Analyzer
analyzer
        Maybe DisableCoord
disableCoord
      ) =
      [Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
query,
            Key
"cutoff_frequency" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= CutoffFrequency
cf,
            Key
"low_freq_operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
lfo,
            Key
"minimum_should_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe CommonMinimumMatch
msm,
            Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
            Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
            Key
"disable_coord" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe DisableCoord
disableCoord,
            Key
"high_freq_operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
hfo
          ]

instance FromJSON CommonTermsQuery where
  parseJSON :: Value -> Parser CommonTermsQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"CommonTermsQuery" Object -> Parser CommonTermsQuery
parse
    where
      parse :: Object -> Parser CommonTermsQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName
-> QueryString
-> CutoffFrequency
-> BooleanOperator
-> BooleanOperator
-> Maybe CommonMinimumMatch
-> Maybe Boost
-> Maybe Analyzer
-> Maybe DisableCoord
-> CommonTermsQuery
CommonTermsQuery FieldName
fn
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"cutoff_frequency"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"low_freq_operator"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"high_freq_operator"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum_should_match"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"disable_coord"

data CommonMinimumMatch
  = CommonMinimumMatchHighLow MinimumMatchHighLow
  | CommonMinimumMatch MinimumMatch
  deriving (CommonMinimumMatch -> CommonMinimumMatch -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommonMinimumMatch -> CommonMinimumMatch -> Bool
$c/= :: CommonMinimumMatch -> CommonMinimumMatch -> Bool
== :: CommonMinimumMatch -> CommonMinimumMatch -> Bool
$c== :: CommonMinimumMatch -> CommonMinimumMatch -> Bool
Eq, Int -> CommonMinimumMatch -> ShowS
[CommonMinimumMatch] -> ShowS
CommonMinimumMatch -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CommonMinimumMatch] -> ShowS
$cshowList :: [CommonMinimumMatch] -> ShowS
show :: CommonMinimumMatch -> String
$cshow :: CommonMinimumMatch -> String
showsPrec :: Int -> CommonMinimumMatch -> ShowS
$cshowsPrec :: Int -> CommonMinimumMatch -> ShowS
Show, forall x. Rep CommonMinimumMatch x -> CommonMinimumMatch
forall x. CommonMinimumMatch -> Rep CommonMinimumMatch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CommonMinimumMatch x -> CommonMinimumMatch
$cfrom :: forall x. CommonMinimumMatch -> Rep CommonMinimumMatch x
Generic)

instance ToJSON CommonMinimumMatch where
  toJSON :: CommonMinimumMatch -> Value
toJSON (CommonMinimumMatch MinimumMatch
mm) = forall a. ToJSON a => a -> Value
toJSON MinimumMatch
mm
  toJSON (CommonMinimumMatchHighLow (MinimumMatchHighLow MinimumMatch
lowF MinimumMatch
highF)) =
    [Pair] -> Value
object
      [ Key
"low_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MinimumMatch
lowF,
        Key
"high_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MinimumMatch
highF
      ]

instance FromJSON CommonMinimumMatch where
  parseJSON :: Value -> Parser CommonMinimumMatch
parseJSON Value
v =
    Value -> Parser CommonMinimumMatch
parseMinimum Value
v
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser CommonMinimumMatch
parseMinimumHighLow Value
v
    where
      parseMinimum :: Value -> Parser CommonMinimumMatch
parseMinimum = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MinimumMatch -> CommonMinimumMatch
CommonMinimumMatch forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromJSON a => Value -> Parser a
parseJSON
      parseMinimumHighLow :: Value -> Parser CommonMinimumMatch
parseMinimumHighLow =
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MinimumMatchHighLow -> CommonMinimumMatch
CommonMinimumMatchHighLow
          forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject
            String
"CommonMinimumMatchHighLow"
            ( \Object
o ->
                MinimumMatch -> MinimumMatch -> MinimumMatchHighLow
MinimumMatchHighLow
                  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"low_freq"
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"high_freq"
            )

data MinimumMatchHighLow = MinimumMatchHighLow
  { MinimumMatchHighLow -> MinimumMatch
lowFreq :: MinimumMatch,
    MinimumMatchHighLow -> MinimumMatch
highFreq :: MinimumMatch
  }
  deriving (MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
$c/= :: MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
== :: MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
$c== :: MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
Eq, Int -> MinimumMatchHighLow -> ShowS
[MinimumMatchHighLow] -> ShowS
MinimumMatchHighLow -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MinimumMatchHighLow] -> ShowS
$cshowList :: [MinimumMatchHighLow] -> ShowS
show :: MinimumMatchHighLow -> String
$cshow :: MinimumMatchHighLow -> String
showsPrec :: Int -> MinimumMatchHighLow -> ShowS
$cshowsPrec :: Int -> MinimumMatchHighLow -> ShowS
Show, forall x. Rep MinimumMatchHighLow x -> MinimumMatchHighLow
forall x. MinimumMatchHighLow -> Rep MinimumMatchHighLow x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MinimumMatchHighLow x -> MinimumMatchHighLow
$cfrom :: forall x. MinimumMatchHighLow -> Rep MinimumMatchHighLow x
Generic)

data ZeroTermsQuery
  = ZeroTermsNone
  | ZeroTermsAll
  deriving (ZeroTermsQuery -> ZeroTermsQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ZeroTermsQuery -> ZeroTermsQuery -> Bool
$c/= :: ZeroTermsQuery -> ZeroTermsQuery -> Bool
== :: ZeroTermsQuery -> ZeroTermsQuery -> Bool
$c== :: ZeroTermsQuery -> ZeroTermsQuery -> Bool
Eq, Int -> ZeroTermsQuery -> ShowS
[ZeroTermsQuery] -> ShowS
ZeroTermsQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ZeroTermsQuery] -> ShowS
$cshowList :: [ZeroTermsQuery] -> ShowS
show :: ZeroTermsQuery -> String
$cshow :: ZeroTermsQuery -> String
showsPrec :: Int -> ZeroTermsQuery -> ShowS
$cshowsPrec :: Int -> ZeroTermsQuery -> ShowS
Show, forall x. Rep ZeroTermsQuery x -> ZeroTermsQuery
forall x. ZeroTermsQuery -> Rep ZeroTermsQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ZeroTermsQuery x -> ZeroTermsQuery
$cfrom :: forall x. ZeroTermsQuery -> Rep ZeroTermsQuery x
Generic)

instance ToJSON ZeroTermsQuery where
  toJSON :: ZeroTermsQuery -> Value
toJSON ZeroTermsQuery
ZeroTermsNone = Text -> Value
String Text
"none"
  toJSON ZeroTermsQuery
ZeroTermsAll = Text -> Value
String Text
"all"

instance FromJSON ZeroTermsQuery where
  parseJSON :: Value -> Parser ZeroTermsQuery
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"ZeroTermsQuery" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f ZeroTermsQuery
parse
    where
      parse :: a -> f ZeroTermsQuery
parse a
"none" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ZeroTermsQuery
ZeroTermsNone
      parse a
"all" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ZeroTermsQuery
ZeroTermsAll
      parse a
q = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected ZeroTermsQuery: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
q)

data RangeExecution
  = RangeExecutionIndex
  | RangeExecutionFielddata
  deriving (RangeExecution -> RangeExecution -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RangeExecution -> RangeExecution -> Bool
$c/= :: RangeExecution -> RangeExecution -> Bool
== :: RangeExecution -> RangeExecution -> Bool
$c== :: RangeExecution -> RangeExecution -> Bool
Eq, Int -> RangeExecution -> ShowS
[RangeExecution] -> ShowS
RangeExecution -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RangeExecution] -> ShowS
$cshowList :: [RangeExecution] -> ShowS
show :: RangeExecution -> String
$cshow :: RangeExecution -> String
showsPrec :: Int -> RangeExecution -> ShowS
$cshowsPrec :: Int -> RangeExecution -> ShowS
Show, forall x. Rep RangeExecution x -> RangeExecution
forall x. RangeExecution -> Rep RangeExecution x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RangeExecution x -> RangeExecution
$cfrom :: forall x. RangeExecution -> Rep RangeExecution x
Generic)

-- index for smaller ranges, fielddata for longer ranges
instance ToJSON RangeExecution where
  toJSON :: RangeExecution -> Value
toJSON RangeExecution
RangeExecutionIndex = Value
"index"
  toJSON RangeExecution
RangeExecutionFielddata = Value
"fielddata"

instance FromJSON RangeExecution where
  parseJSON :: Value -> Parser RangeExecution
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"RangeExecution" forall {a} {f :: * -> *}.
(Eq a, IsString a, Applicative f, Show a) =>
a -> f RangeExecution
parse
    where
      parse :: a -> f RangeExecution
parse a
"index" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RangeExecution
RangeExecutionIndex
      parse a
"fielddata" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RangeExecution
RangeExecutionFielddata
      parse a
t = forall a. HasCallStack => String -> a
error (String
"Unrecognized RangeExecution " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)

newtype Regexp = Regexp Text deriving (Regexp -> Regexp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Regexp -> Regexp -> Bool
$c/= :: Regexp -> Regexp -> Bool
== :: Regexp -> Regexp -> Bool
$c== :: Regexp -> Regexp -> Bool
Eq, Int -> Regexp -> ShowS
[Regexp] -> ShowS
Regexp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Regexp] -> ShowS
$cshowList :: [Regexp] -> ShowS
show :: Regexp -> String
$cshow :: Regexp -> String
showsPrec :: Int -> Regexp -> ShowS
$cshowsPrec :: Int -> Regexp -> ShowS
Show, forall x. Rep Regexp x -> Regexp
forall x. Regexp -> Rep Regexp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Regexp x -> Regexp
$cfrom :: forall x. Regexp -> Rep Regexp x
Generic, Value -> Parser [Regexp]
Value -> Parser Regexp
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Regexp]
$cparseJSONList :: Value -> Parser [Regexp]
parseJSON :: Value -> Parser Regexp
$cparseJSON :: Value -> Parser Regexp
FromJSON)

data RegexpFlags
  = AllRegexpFlags
  | NoRegexpFlags
  | SomeRegexpFlags (NonEmpty RegexpFlag)
  deriving (RegexpFlags -> RegexpFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegexpFlags -> RegexpFlags -> Bool
$c/= :: RegexpFlags -> RegexpFlags -> Bool
== :: RegexpFlags -> RegexpFlags -> Bool
$c== :: RegexpFlags -> RegexpFlags -> Bool
Eq, Int -> RegexpFlags -> ShowS
[RegexpFlags] -> ShowS
RegexpFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegexpFlags] -> ShowS
$cshowList :: [RegexpFlags] -> ShowS
show :: RegexpFlags -> String
$cshow :: RegexpFlags -> String
showsPrec :: Int -> RegexpFlags -> ShowS
$cshowsPrec :: Int -> RegexpFlags -> ShowS
Show, forall x. Rep RegexpFlags x -> RegexpFlags
forall x. RegexpFlags -> Rep RegexpFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegexpFlags x -> RegexpFlags
$cfrom :: forall x. RegexpFlags -> Rep RegexpFlags x
Generic)

instance ToJSON RegexpFlags where
  toJSON :: RegexpFlags -> Value
toJSON RegexpFlags
AllRegexpFlags = Text -> Value
String Text
"ALL"
  toJSON RegexpFlags
NoRegexpFlags = Text -> Value
String Text
"NONE"
  toJSON (SomeRegexpFlags (RegexpFlag
h :| [RegexpFlag]
fs)) = Text -> Value
String forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Text
T.intercalate Text
"|" [Text]
flagStrs
    where
      flagStrs :: [Text]
flagStrs = forall a b. (a -> b) -> [a] -> [b]
map forall {a}. IsString a => RegexpFlag -> a
flagStr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => [a] -> [a]
nub forall a b. (a -> b) -> a -> b
$ RegexpFlag
h forall a. a -> [a] -> [a]
: [RegexpFlag]
fs
      flagStr :: RegexpFlag -> a
flagStr RegexpFlag
AnyString = a
"ANYSTRING"
      flagStr RegexpFlag
Automaton = a
"AUTOMATON"
      flagStr RegexpFlag
Complement = a
"COMPLEMENT"
      flagStr RegexpFlag
Empty = a
"EMPTY"
      flagStr RegexpFlag
Intersection = a
"INTERSECTION"
      flagStr RegexpFlag
Interval = a
"INTERVAL"

instance FromJSON RegexpFlags where
  parseJSON :: Value -> Parser RegexpFlags
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"RegexpFlags" Text -> Parser RegexpFlags
parse
    where
      parse :: Text -> Parser RegexpFlags
parse Text
"ALL" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlags
AllRegexpFlags
      parse Text
"NONE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlags
NoRegexpFlags
      parse Text
t = NonEmpty RegexpFlag -> RegexpFlags
SomeRegexpFlags forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => [Value] -> Parser (NonEmpty a)
parseNEJSON (Text -> Value
String forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Text -> [Text]
T.splitOn Text
"|" Text
t)

data RegexpFlag
  = AnyString
  | Automaton
  | Complement
  | Empty
  | Intersection
  | Interval
  deriving (RegexpFlag -> RegexpFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegexpFlag -> RegexpFlag -> Bool
$c/= :: RegexpFlag -> RegexpFlag -> Bool
== :: RegexpFlag -> RegexpFlag -> Bool
$c== :: RegexpFlag -> RegexpFlag -> Bool
Eq, Int -> RegexpFlag -> ShowS
[RegexpFlag] -> ShowS
RegexpFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegexpFlag] -> ShowS
$cshowList :: [RegexpFlag] -> ShowS
show :: RegexpFlag -> String
$cshow :: RegexpFlag -> String
showsPrec :: Int -> RegexpFlag -> ShowS
$cshowsPrec :: Int -> RegexpFlag -> ShowS
Show, forall x. Rep RegexpFlag x -> RegexpFlag
forall x. RegexpFlag -> Rep RegexpFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegexpFlag x -> RegexpFlag
$cfrom :: forall x. RegexpFlag -> Rep RegexpFlag x
Generic)

instance FromJSON RegexpFlag where
  parseJSON :: Value -> Parser RegexpFlag
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"RegexpFlag" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f RegexpFlag
parse
    where
      parse :: a -> f RegexpFlag
parse a
"ANYSTRING" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
AnyString
      parse a
"AUTOMATON" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Automaton
      parse a
"COMPLEMENT" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Complement
      parse a
"EMPTY" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Empty
      parse a
"INTERSECTION" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Intersection
      parse a
"INTERVAL" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Interval
      parse a
f = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unknown RegexpFlag: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
f)

newtype LessThan = LessThan Double deriving (LessThan -> LessThan -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LessThan -> LessThan -> Bool
$c/= :: LessThan -> LessThan -> Bool
== :: LessThan -> LessThan -> Bool
$c== :: LessThan -> LessThan -> Bool
Eq, Int -> LessThan -> ShowS
[LessThan] -> ShowS
LessThan -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LessThan] -> ShowS
$cshowList :: [LessThan] -> ShowS
show :: LessThan -> String
$cshow :: LessThan -> String
showsPrec :: Int -> LessThan -> ShowS
$cshowsPrec :: Int -> LessThan -> ShowS
Show, forall x. Rep LessThan x -> LessThan
forall x. LessThan -> Rep LessThan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LessThan x -> LessThan
$cfrom :: forall x. LessThan -> Rep LessThan x
Generic)

newtype LessThanEq = LessThanEq Double deriving (LessThanEq -> LessThanEq -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LessThanEq -> LessThanEq -> Bool
$c/= :: LessThanEq -> LessThanEq -> Bool
== :: LessThanEq -> LessThanEq -> Bool
$c== :: LessThanEq -> LessThanEq -> Bool
Eq, Int -> LessThanEq -> ShowS
[LessThanEq] -> ShowS
LessThanEq -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LessThanEq] -> ShowS
$cshowList :: [LessThanEq] -> ShowS
show :: LessThanEq -> String
$cshow :: LessThanEq -> String
showsPrec :: Int -> LessThanEq -> ShowS
$cshowsPrec :: Int -> LessThanEq -> ShowS
Show, forall x. Rep LessThanEq x -> LessThanEq
forall x. LessThanEq -> Rep LessThanEq x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LessThanEq x -> LessThanEq
$cfrom :: forall x. LessThanEq -> Rep LessThanEq x
Generic)

newtype GreaterThan = GreaterThan Double deriving (GreaterThan -> GreaterThan -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreaterThan -> GreaterThan -> Bool
$c/= :: GreaterThan -> GreaterThan -> Bool
== :: GreaterThan -> GreaterThan -> Bool
$c== :: GreaterThan -> GreaterThan -> Bool
Eq, Int -> GreaterThan -> ShowS
[GreaterThan] -> ShowS
GreaterThan -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreaterThan] -> ShowS
$cshowList :: [GreaterThan] -> ShowS
show :: GreaterThan -> String
$cshow :: GreaterThan -> String
showsPrec :: Int -> GreaterThan -> ShowS
$cshowsPrec :: Int -> GreaterThan -> ShowS
Show, forall x. Rep GreaterThan x -> GreaterThan
forall x. GreaterThan -> Rep GreaterThan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreaterThan x -> GreaterThan
$cfrom :: forall x. GreaterThan -> Rep GreaterThan x
Generic)

newtype GreaterThanEq = GreaterThanEq Double deriving (GreaterThanEq -> GreaterThanEq -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreaterThanEq -> GreaterThanEq -> Bool
$c/= :: GreaterThanEq -> GreaterThanEq -> Bool
== :: GreaterThanEq -> GreaterThanEq -> Bool
$c== :: GreaterThanEq -> GreaterThanEq -> Bool
Eq, Int -> GreaterThanEq -> ShowS
[GreaterThanEq] -> ShowS
GreaterThanEq -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreaterThanEq] -> ShowS
$cshowList :: [GreaterThanEq] -> ShowS
show :: GreaterThanEq -> String
$cshow :: GreaterThanEq -> String
showsPrec :: Int -> GreaterThanEq -> ShowS
$cshowsPrec :: Int -> GreaterThanEq -> ShowS
Show, forall x. Rep GreaterThanEq x -> GreaterThanEq
forall x. GreaterThanEq -> Rep GreaterThanEq x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreaterThanEq x -> GreaterThanEq
$cfrom :: forall x. GreaterThanEq -> Rep GreaterThanEq x
Generic)

newtype LessThanD = LessThanD UTCTime deriving (LessThanD -> LessThanD -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LessThanD -> LessThanD -> Bool
$c/= :: LessThanD -> LessThanD -> Bool
== :: LessThanD -> LessThanD -> Bool
$c== :: LessThanD -> LessThanD -> Bool
Eq, Int -> LessThanD -> ShowS
[LessThanD] -> ShowS
LessThanD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LessThanD] -> ShowS
$cshowList :: [LessThanD] -> ShowS
show :: LessThanD -> String
$cshow :: LessThanD -> String
showsPrec :: Int -> LessThanD -> ShowS
$cshowsPrec :: Int -> LessThanD -> ShowS
Show, forall x. Rep LessThanD x -> LessThanD
forall x. LessThanD -> Rep LessThanD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LessThanD x -> LessThanD
$cfrom :: forall x. LessThanD -> Rep LessThanD x
Generic)

newtype LessThanEqD = LessThanEqD UTCTime deriving (LessThanEqD -> LessThanEqD -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LessThanEqD -> LessThanEqD -> Bool
$c/= :: LessThanEqD -> LessThanEqD -> Bool
== :: LessThanEqD -> LessThanEqD -> Bool
$c== :: LessThanEqD -> LessThanEqD -> Bool
Eq, Int -> LessThanEqD -> ShowS
[LessThanEqD] -> ShowS
LessThanEqD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LessThanEqD] -> ShowS
$cshowList :: [LessThanEqD] -> ShowS
show :: LessThanEqD -> String
$cshow :: LessThanEqD -> String
showsPrec :: Int -> LessThanEqD -> ShowS
$cshowsPrec :: Int -> LessThanEqD -> ShowS
Show, forall x. Rep LessThanEqD x -> LessThanEqD
forall x. LessThanEqD -> Rep LessThanEqD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LessThanEqD x -> LessThanEqD
$cfrom :: forall x. LessThanEqD -> Rep LessThanEqD x
Generic)

newtype GreaterThanD = GreaterThanD UTCTime deriving (GreaterThanD -> GreaterThanD -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreaterThanD -> GreaterThanD -> Bool
$c/= :: GreaterThanD -> GreaterThanD -> Bool
== :: GreaterThanD -> GreaterThanD -> Bool
$c== :: GreaterThanD -> GreaterThanD -> Bool
Eq, Int -> GreaterThanD -> ShowS
[GreaterThanD] -> ShowS
GreaterThanD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreaterThanD] -> ShowS
$cshowList :: [GreaterThanD] -> ShowS
show :: GreaterThanD -> String
$cshow :: GreaterThanD -> String
showsPrec :: Int -> GreaterThanD -> ShowS
$cshowsPrec :: Int -> GreaterThanD -> ShowS
Show, forall x. Rep GreaterThanD x -> GreaterThanD
forall x. GreaterThanD -> Rep GreaterThanD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreaterThanD x -> GreaterThanD
$cfrom :: forall x. GreaterThanD -> Rep GreaterThanD x
Generic)

newtype GreaterThanEqD = GreaterThanEqD UTCTime deriving (GreaterThanEqD -> GreaterThanEqD -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreaterThanEqD -> GreaterThanEqD -> Bool
$c/= :: GreaterThanEqD -> GreaterThanEqD -> Bool
== :: GreaterThanEqD -> GreaterThanEqD -> Bool
$c== :: GreaterThanEqD -> GreaterThanEqD -> Bool
Eq, Int -> GreaterThanEqD -> ShowS
[GreaterThanEqD] -> ShowS
GreaterThanEqD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreaterThanEqD] -> ShowS
$cshowList :: [GreaterThanEqD] -> ShowS
show :: GreaterThanEqD -> String
$cshow :: GreaterThanEqD -> String
showsPrec :: Int -> GreaterThanEqD -> ShowS
$cshowsPrec :: Int -> GreaterThanEqD -> ShowS
Show, forall x. Rep GreaterThanEqD x -> GreaterThanEqD
forall x. GreaterThanEqD -> Rep GreaterThanEqD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreaterThanEqD x -> GreaterThanEqD
$cfrom :: forall x. GreaterThanEqD -> Rep GreaterThanEqD x
Generic)

data RangeValue
  = RangeDateLte LessThanEqD
  | RangeDateLt LessThanD
  | RangeDateGte GreaterThanEqD
  | RangeDateGt GreaterThanD
  | RangeDateGtLt GreaterThanD LessThanD
  | RangeDateGteLte GreaterThanEqD LessThanEqD
  | RangeDateGteLt GreaterThanEqD LessThanD
  | RangeDateGtLte GreaterThanD LessThanEqD
  | RangeDoubleLte LessThanEq
  | RangeDoubleLt LessThan
  | RangeDoubleGte GreaterThanEq
  | RangeDoubleGt GreaterThan
  | RangeDoubleGtLt GreaterThan LessThan
  | RangeDoubleGteLte GreaterThanEq LessThanEq
  | RangeDoubleGteLt GreaterThanEq LessThan
  | RangeDoubleGtLte GreaterThan LessThanEq
  deriving (RangeValue -> RangeValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RangeValue -> RangeValue -> Bool
$c/= :: RangeValue -> RangeValue -> Bool
== :: RangeValue -> RangeValue -> Bool
$c== :: RangeValue -> RangeValue -> Bool
Eq, Int -> RangeValue -> ShowS
[RangeValue] -> ShowS
RangeValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RangeValue] -> ShowS
$cshowList :: [RangeValue] -> ShowS
show :: RangeValue -> String
$cshow :: RangeValue -> String
showsPrec :: Int -> RangeValue -> ShowS
$cshowsPrec :: Int -> RangeValue -> ShowS
Show, forall x. Rep RangeValue x -> RangeValue
forall x. RangeValue -> Rep RangeValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RangeValue x -> RangeValue
$cfrom :: forall x. RangeValue -> Rep RangeValue x
Generic)

parseRangeValue ::
  ( FromJSON t4,
    FromJSON t3,
    FromJSON t2,
    FromJSON t1
  ) =>
  (t3 -> t5) ->
  (t1 -> t6) ->
  (t4 -> t7) ->
  (t2 -> t8) ->
  (t5 -> t6 -> b) ->
  (t7 -> t6 -> b) ->
  (t5 -> t8 -> b) ->
  (t7 -> t8 -> b) ->
  (t5 -> b) ->
  (t6 -> b) ->
  (t7 -> b) ->
  (t8 -> b) ->
  Parser b ->
  Object ->
  Parser b
parseRangeValue :: forall t4 t3 t2 t1 t5 t6 t7 t8 b.
(FromJSON t4, FromJSON t3, FromJSON t2, FromJSON t1) =>
(t3 -> t5)
-> (t1 -> t6)
-> (t4 -> t7)
-> (t2 -> t8)
-> (t5 -> t6 -> b)
-> (t7 -> t6 -> b)
-> (t5 -> t8 -> b)
-> (t7 -> t8 -> b)
-> (t5 -> b)
-> (t6 -> b)
-> (t7 -> b)
-> (t8 -> b)
-> Parser b
-> Object
-> Parser b
parseRangeValue
  t3 -> t5
mkGt
  t1 -> t6
mkLt
  t4 -> t7
mkGte
  t2 -> t8
mkLte
  t5 -> t6 -> b
fGtLt
  t7 -> t6 -> b
fGteLt
  t5 -> t8 -> b
fGtLte
  t7 -> t8 -> b
fGteLte
  t5 -> b
fGt
  t6 -> b
fLt
  t7 -> b
fGte
  t8 -> b
fLte
  Parser b
nada
  Object
o = do
    Maybe t1
lt <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lt"
    Maybe t2
lte <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lte"
    Maybe t3
gt <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"gt"
    Maybe t4
gte <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"gte"
    case (Maybe t1
lt, Maybe t2
lte, Maybe t3
gt, Maybe t4
gte) of
      (Just t1
a, Maybe t2
_, Just t3
b, Maybe t4
_) ->
        forall (m :: * -> *) a. Monad m => a -> m a
return (t5 -> t6 -> b
fGtLt (t3 -> t5
mkGt t3
b) (t1 -> t6
mkLt t1
a))
      (Just t1
a, Maybe t2
_, Maybe t3
_, Just t4
b) ->
        forall (m :: * -> *) a. Monad m => a -> m a
return (t7 -> t6 -> b
fGteLt (t4 -> t7
mkGte t4
b) (t1 -> t6
mkLt t1
a))
      (Maybe t1
_, Just t2
a, Just t3
b, Maybe t4
_) ->
        forall (m :: * -> *) a. Monad m => a -> m a
return (t5 -> t8 -> b
fGtLte (t3 -> t5
mkGt t3
b) (t2 -> t8
mkLte t2
a))
      (Maybe t1
_, Just t2
a, Maybe t3
_, Just t4
b) ->
        forall (m :: * -> *) a. Monad m => a -> m a
return (t7 -> t8 -> b
fGteLte (t4 -> t7
mkGte t4
b) (t2 -> t8
mkLte t2
a))
      (Maybe t1
_, Maybe t2
_, Just t3
a, Maybe t4
_) ->
        forall (m :: * -> *) a. Monad m => a -> m a
return (t5 -> b
fGt (t3 -> t5
mkGt t3
a))
      (Just t1
a, Maybe t2
_, Maybe t3
_, Maybe t4
_) ->
        forall (m :: * -> *) a. Monad m => a -> m a
return (t6 -> b
fLt (t1 -> t6
mkLt t1
a))
      (Maybe t1
_, Maybe t2
_, Maybe t3
_, Just t4
a) ->
        forall (m :: * -> *) a. Monad m => a -> m a
return (t7 -> b
fGte (t4 -> t7
mkGte t4
a))
      (Maybe t1
_, Just t2
a, Maybe t3
_, Maybe t4
_) ->
        forall (m :: * -> *) a. Monad m => a -> m a
return (t8 -> b
fLte (t2 -> t8
mkLte t2
a))
      (Maybe t1
Nothing, Maybe t2
Nothing, Maybe t3
Nothing, Maybe t4
Nothing) ->
        Parser b
nada

instance FromJSON RangeValue where
  parseJSON :: Value -> Parser RangeValue
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RangeValue" Object -> Parser RangeValue
parse
    where
      parse :: Object -> Parser RangeValue
parse Object
o =
        Object -> Parser RangeValue
parseDate Object
o
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object -> Parser RangeValue
parseDouble Object
o
      parseDate :: Object -> Parser RangeValue
parseDate Object
o =
        forall t4 t3 t2 t1 t5 t6 t7 t8 b.
(FromJSON t4, FromJSON t3, FromJSON t2, FromJSON t1) =>
(t3 -> t5)
-> (t1 -> t6)
-> (t4 -> t7)
-> (t2 -> t8)
-> (t5 -> t6 -> b)
-> (t7 -> t6 -> b)
-> (t5 -> t8 -> b)
-> (t7 -> t8 -> b)
-> (t5 -> b)
-> (t6 -> b)
-> (t7 -> b)
-> (t8 -> b)
-> Parser b
-> Object
-> Parser b
parseRangeValue
          UTCTime -> GreaterThanD
GreaterThanD
          UTCTime -> LessThanD
LessThanD
          UTCTime -> GreaterThanEqD
GreaterThanEqD
          UTCTime -> LessThanEqD
LessThanEqD
          GreaterThanD -> LessThanD -> RangeValue
RangeDateGtLt
          GreaterThanEqD -> LessThanD -> RangeValue
RangeDateGteLt
          GreaterThanD -> LessThanEqD -> RangeValue
RangeDateGtLte
          GreaterThanEqD -> LessThanEqD -> RangeValue
RangeDateGteLte
          GreaterThanD -> RangeValue
RangeDateGt
          LessThanD -> RangeValue
RangeDateLt
          GreaterThanEqD -> RangeValue
RangeDateGte
          LessThanEqD -> RangeValue
RangeDateLte
          forall (m :: * -> *) a. MonadPlus m => m a
mzero
          Object
o
      parseDouble :: Object -> Parser RangeValue
parseDouble Object
o =
        forall t4 t3 t2 t1 t5 t6 t7 t8 b.
(FromJSON t4, FromJSON t3, FromJSON t2, FromJSON t1) =>
(t3 -> t5)
-> (t1 -> t6)
-> (t4 -> t7)
-> (t2 -> t8)
-> (t5 -> t6 -> b)
-> (t7 -> t6 -> b)
-> (t5 -> t8 -> b)
-> (t7 -> t8 -> b)
-> (t5 -> b)
-> (t6 -> b)
-> (t7 -> b)
-> (t8 -> b)
-> Parser b
-> Object
-> Parser b
parseRangeValue
          Double -> GreaterThan
GreaterThan
          Double -> LessThan
LessThan
          Double -> GreaterThanEq
GreaterThanEq
          Double -> LessThanEq
LessThanEq
          GreaterThan -> LessThan -> RangeValue
RangeDoubleGtLt
          GreaterThanEq -> LessThan -> RangeValue
RangeDoubleGteLt
          GreaterThan -> LessThanEq -> RangeValue
RangeDoubleGtLte
          GreaterThanEq -> LessThanEq -> RangeValue
RangeDoubleGteLte
          GreaterThan -> RangeValue
RangeDoubleGt
          LessThan -> RangeValue
RangeDoubleLt
          GreaterThanEq -> RangeValue
RangeDoubleGte
          LessThanEq -> RangeValue
RangeDoubleLte
          forall (m :: * -> *) a. MonadPlus m => m a
mzero
          Object
o

rangeValueToPair :: RangeValue -> [Pair]
rangeValueToPair :: RangeValue -> [Pair]
rangeValueToPair RangeValue
rv = case RangeValue
rv of
  RangeDateLte (LessThanEqD UTCTime
t) -> [Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
t]
  RangeDateGte (GreaterThanEqD UTCTime
t) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
t]
  RangeDateLt (LessThanD UTCTime
t) -> [Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
t]
  RangeDateGt (GreaterThanD UTCTime
t) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
t]
  RangeDateGteLte (GreaterThanEqD UTCTime
l) (LessThanEqD UTCTime
g) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
l, Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
g]
  RangeDateGtLte (GreaterThanD UTCTime
l) (LessThanEqD UTCTime
g) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
l, Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
g]
  RangeDateGteLt (GreaterThanEqD UTCTime
l) (LessThanD UTCTime
g) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
l, Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
g]
  RangeDateGtLt (GreaterThanD UTCTime
l) (LessThanD UTCTime
g) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
l, Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
g]
  RangeDoubleLte (LessThanEq Double
t) -> [Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
t]
  RangeDoubleGte (GreaterThanEq Double
t) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
t]
  RangeDoubleLt (LessThan Double
t) -> [Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
t]
  RangeDoubleGt (GreaterThan Double
t) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
t]
  RangeDoubleGteLte (GreaterThanEq Double
l) (LessThanEq Double
g) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
l, Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
g]
  RangeDoubleGtLte (GreaterThan Double
l) (LessThanEq Double
g) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
l, Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
g]
  RangeDoubleGteLt (GreaterThanEq Double
l) (LessThan Double
g) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
l, Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
g]
  RangeDoubleGtLt (GreaterThan Double
l) (LessThan Double
g) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
l, Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
g]

data Term = Term
  { Term -> Key
termField :: Key,
    Term -> Text
termValue :: Text
  }
  deriving (Term -> Term -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Term -> Term -> Bool
$c/= :: Term -> Term -> Bool
== :: Term -> Term -> Bool
$c== :: Term -> Term -> Bool
Eq, Int -> Term -> ShowS
[Term] -> ShowS
Term -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Term] -> ShowS
$cshowList :: [Term] -> ShowS
show :: Term -> String
$cshow :: Term -> String
showsPrec :: Int -> Term -> ShowS
$cshowsPrec :: Int -> Term -> ShowS
Show, forall x. Rep Term x -> Term
forall x. Term -> Rep Term x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Term x -> Term
$cfrom :: forall x. Term -> Rep Term x
Generic)

instance ToJSON Term where
  toJSON :: Term -> Value
toJSON (Term Key
field Text
value) =
    [Pair] -> Value
object
      [ Key
"term"
          forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [Key
field forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
value]
      ]

instance FromJSON Term where
  parseJSON :: Value -> Parser Term
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Term" Object -> Parser Term
parse
    where
      parse :: Object -> Parser Term
parse Object
o = do
        HashMap Key Value
termObj <- Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"term"
        case forall k v. HashMap k v -> [(k, v)]
HM.toList HashMap Key Value
termObj of
          [(Key
fn, Value
v)] -> Key -> Text -> Term
Term Key
fn forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
          [Pair]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected object with 1 field-named key"

data BoolMatch
  = MustMatch Term Cache
  | MustNotMatch Term Cache
  | ShouldMatch [Term] Cache
  deriving (BoolMatch -> BoolMatch -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BoolMatch -> BoolMatch -> Bool
$c/= :: BoolMatch -> BoolMatch -> Bool
== :: BoolMatch -> BoolMatch -> Bool
$c== :: BoolMatch -> BoolMatch -> Bool
Eq, Int -> BoolMatch -> ShowS
[BoolMatch] -> ShowS
BoolMatch -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BoolMatch] -> ShowS
$cshowList :: [BoolMatch] -> ShowS
show :: BoolMatch -> String
$cshow :: BoolMatch -> String
showsPrec :: Int -> BoolMatch -> ShowS
$cshowsPrec :: Int -> BoolMatch -> ShowS
Show, forall x. Rep BoolMatch x -> BoolMatch
forall x. BoolMatch -> Rep BoolMatch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BoolMatch x -> BoolMatch
$cfrom :: forall x. BoolMatch -> Rep BoolMatch x
Generic)

instance ToJSON BoolMatch where
  toJSON :: BoolMatch -> Value
toJSON (MustMatch Term
term Bool
cache) =
    [Pair] -> Value
object
      [ Key
"must" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Term
term,
        Key
"_cache" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
cache
      ]
  toJSON (MustNotMatch Term
term Bool
cache) =
    [Pair] -> Value
object
      [ Key
"must_not" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Term
term,
        Key
"_cache" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
cache
      ]
  toJSON (ShouldMatch [Term]
terms Bool
cache) =
    [Pair] -> Value
object
      [ Key
"should" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. ToJSON a => a -> Value
toJSON [Term]
terms,
        Key
"_cache" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
cache
      ]

instance FromJSON BoolMatch where
  parseJSON :: Value -> Parser BoolMatch
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BoolMatch" Object -> Parser BoolMatch
parse
    where
      parse :: Object -> Parser BoolMatch
parse Object
o =
        Term -> Parser BoolMatch
mustMatch
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"must"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Term -> Parser BoolMatch
mustNotMatch
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"must_not"
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Term] -> Parser BoolMatch
shouldMatch
          forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"should"
        where
          taggedWith :: (a -> Parser b) -> Key -> Parser b
taggedWith a -> Parser b
parser Key
k = a -> Parser b
parser forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
k
          mustMatch :: Term -> Parser BoolMatch
mustMatch Term
t = Term -> Bool -> BoolMatch
MustMatch Term
t forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_cache" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
defaultCache
          mustNotMatch :: Term -> Parser BoolMatch
mustNotMatch Term
t = Term -> Bool -> BoolMatch
MustNotMatch Term
t forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_cache" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
defaultCache
          shouldMatch :: [Term] -> Parser BoolMatch
shouldMatch [Term]
t = [Term] -> Bool -> BoolMatch
ShouldMatch [Term]
t forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_cache" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
defaultCache

-- "memory" or "indexed"
data GeoFilterType
  = GeoFilterMemory
  | GeoFilterIndexed
  deriving (GeoFilterType -> GeoFilterType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeoFilterType -> GeoFilterType -> Bool
$c/= :: GeoFilterType -> GeoFilterType -> Bool
== :: GeoFilterType -> GeoFilterType -> Bool
$c== :: GeoFilterType -> GeoFilterType -> Bool
Eq, Int -> GeoFilterType -> ShowS
[GeoFilterType] -> ShowS
GeoFilterType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeoFilterType] -> ShowS
$cshowList :: [GeoFilterType] -> ShowS
show :: GeoFilterType -> String
$cshow :: GeoFilterType -> String
showsPrec :: Int -> GeoFilterType -> ShowS
$cshowsPrec :: Int -> GeoFilterType -> ShowS
Show, forall x. Rep GeoFilterType x -> GeoFilterType
forall x. GeoFilterType -> Rep GeoFilterType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GeoFilterType x -> GeoFilterType
$cfrom :: forall x. GeoFilterType -> Rep GeoFilterType x
Generic)

instance ToJSON GeoFilterType where
  toJSON :: GeoFilterType -> Value
toJSON GeoFilterType
GeoFilterMemory = Text -> Value
String Text
"memory"
  toJSON GeoFilterType
GeoFilterIndexed = Text -> Value
String Text
"indexed"

instance FromJSON GeoFilterType where
  parseJSON :: Value -> Parser GeoFilterType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"GeoFilterType" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f GeoFilterType
parse
    where
      parse :: a -> f GeoFilterType
parse a
"memory" = forall (f :: * -> *) a. Applicative f => a -> f a
pure GeoFilterType
GeoFilterMemory
      parse a
"indexed" = forall (f :: * -> *) a. Applicative f => a -> f a
pure GeoFilterType
GeoFilterIndexed
      parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unrecognized GeoFilterType: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)

data LatLon = LatLon
  { LatLon -> Double
lat :: Double,
    LatLon -> Double
lon :: Double
  }
  deriving (LatLon -> LatLon -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LatLon -> LatLon -> Bool
$c/= :: LatLon -> LatLon -> Bool
== :: LatLon -> LatLon -> Bool
$c== :: LatLon -> LatLon -> Bool
Eq, Int -> LatLon -> ShowS
[LatLon] -> ShowS
LatLon -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LatLon] -> ShowS
$cshowList :: [LatLon] -> ShowS
show :: LatLon -> String
$cshow :: LatLon -> String
showsPrec :: Int -> LatLon -> ShowS
$cshowsPrec :: Int -> LatLon -> ShowS
Show, forall x. Rep LatLon x -> LatLon
forall x. LatLon -> Rep LatLon x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LatLon x -> LatLon
$cfrom :: forall x. LatLon -> Rep LatLon x
Generic)

instance ToJSON LatLon where
  toJSON :: LatLon -> Value
toJSON (LatLon Double
lLat Double
lLon) =
    [Pair] -> Value
object
      [ Key
"lat" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
lLat,
        Key
"lon" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
lLon
      ]

instance FromJSON LatLon where
  parseJSON :: Value -> Parser LatLon
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"LatLon" Object -> Parser LatLon
parse
    where
      parse :: Object -> Parser LatLon
parse Object
o =
        Double -> Double -> LatLon
LatLon
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"lat"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"lon"

data GeoBoundingBox = GeoBoundingBox
  { GeoBoundingBox -> LatLon
topLeft :: LatLon,
    GeoBoundingBox -> LatLon
bottomRight :: LatLon
  }
  deriving (GeoBoundingBox -> GeoBoundingBox -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeoBoundingBox -> GeoBoundingBox -> Bool
$c/= :: GeoBoundingBox -> GeoBoundingBox -> Bool
== :: GeoBoundingBox -> GeoBoundingBox -> Bool
$c== :: GeoBoundingBox -> GeoBoundingBox -> Bool
Eq, Int -> GeoBoundingBox -> ShowS
[GeoBoundingBox] -> ShowS
GeoBoundingBox -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeoBoundingBox] -> ShowS
$cshowList :: [GeoBoundingBox] -> ShowS
show :: GeoBoundingBox -> String
$cshow :: GeoBoundingBox -> String
showsPrec :: Int -> GeoBoundingBox -> ShowS
$cshowsPrec :: Int -> GeoBoundingBox -> ShowS
Show, forall x. Rep GeoBoundingBox x -> GeoBoundingBox
forall x. GeoBoundingBox -> Rep GeoBoundingBox x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GeoBoundingBox x -> GeoBoundingBox
$cfrom :: forall x. GeoBoundingBox -> Rep GeoBoundingBox x
Generic)

instance ToJSON GeoBoundingBox where
  toJSON :: GeoBoundingBox -> Value
toJSON (GeoBoundingBox LatLon
gbbTopLeft LatLon
gbbBottomRight) =
    [Pair] -> Value
object
      [ Key
"top_left" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= LatLon
gbbTopLeft,
        Key
"bottom_right" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= LatLon
gbbBottomRight
      ]

instance FromJSON GeoBoundingBox where
  parseJSON :: Value -> Parser GeoBoundingBox
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GeoBoundingBox" Object -> Parser GeoBoundingBox
parse
    where
      parse :: Object -> Parser GeoBoundingBox
parse Object
o =
        LatLon -> LatLon -> GeoBoundingBox
GeoBoundingBox
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"top_left"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"bottom_right"

data GeoBoundingBoxConstraint = GeoBoundingBoxConstraint
  { GeoBoundingBoxConstraint -> FieldName
geoBBField :: FieldName,
    GeoBoundingBoxConstraint -> GeoBoundingBox
constraintBox :: GeoBoundingBox,
    GeoBoundingBoxConstraint -> Bool
bbConstraintcache :: Cache,
    GeoBoundingBoxConstraint -> GeoFilterType
geoType :: GeoFilterType
  }
  deriving (GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
$c/= :: GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
== :: GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
$c== :: GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
Eq, Int -> GeoBoundingBoxConstraint -> ShowS
[GeoBoundingBoxConstraint] -> ShowS
GeoBoundingBoxConstraint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeoBoundingBoxConstraint] -> ShowS
$cshowList :: [GeoBoundingBoxConstraint] -> ShowS
show :: GeoBoundingBoxConstraint -> String
$cshow :: GeoBoundingBoxConstraint -> String
showsPrec :: Int -> GeoBoundingBoxConstraint -> ShowS
$cshowsPrec :: Int -> GeoBoundingBoxConstraint -> ShowS
Show, forall x.
Rep GeoBoundingBoxConstraint x -> GeoBoundingBoxConstraint
forall x.
GeoBoundingBoxConstraint -> Rep GeoBoundingBoxConstraint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GeoBoundingBoxConstraint x -> GeoBoundingBoxConstraint
$cfrom :: forall x.
GeoBoundingBoxConstraint -> Rep GeoBoundingBoxConstraint x
Generic)

instance ToJSON GeoBoundingBoxConstraint where
  toJSON :: GeoBoundingBoxConstraint -> Value
toJSON
    ( GeoBoundingBoxConstraint
        (FieldName Text
gbbcGeoBBField)
        GeoBoundingBox
gbbcConstraintBox
        Bool
cache
        GeoFilterType
type'
      ) =
      [Pair] -> Value
object
        [ Text -> Key
fromText Text
gbbcGeoBBField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= GeoBoundingBox
gbbcConstraintBox,
          Key
"_cache" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
cache,
          Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= GeoFilterType
type'
        ]

instance FromJSON GeoBoundingBoxConstraint where
  parseJSON :: Value -> Parser GeoBoundingBoxConstraint
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GeoBoundingBoxConstraint" Object -> Parser GeoBoundingBoxConstraint
parse
    where
      parse :: Object -> Parser GeoBoundingBoxConstraint
parse Object
o = case forall v. KeyMap v -> [(Key, v)]
X.toList (forall v. [Key] -> KeyMap v -> KeyMap v
deleteSeveral [Key
"type", Key
"_cache"] Object
o) of
        [(Key
fn, Value
v)] ->
          FieldName
-> GeoBoundingBox
-> Bool
-> GeoFilterType
-> GeoBoundingBoxConstraint
GeoBoundingBoxConstraint (Text -> FieldName
FieldName forall a b. (a -> b) -> a -> b
$ Key -> Text
toText Key
fn)
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_cache" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
defaultCache
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
        [Pair]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Could not find field name for GeoBoundingBoxConstraint"

data GeoPoint = GeoPoint
  { GeoPoint -> FieldName
geoField :: FieldName,
    GeoPoint -> LatLon
latLon :: LatLon
  }
  deriving (GeoPoint -> GeoPoint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeoPoint -> GeoPoint -> Bool
$c/= :: GeoPoint -> GeoPoint -> Bool
== :: GeoPoint -> GeoPoint -> Bool
$c== :: GeoPoint -> GeoPoint -> Bool
Eq, Int -> GeoPoint -> ShowS
[GeoPoint] -> ShowS
GeoPoint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeoPoint] -> ShowS
$cshowList :: [GeoPoint] -> ShowS
show :: GeoPoint -> String
$cshow :: GeoPoint -> String
showsPrec :: Int -> GeoPoint -> ShowS
$cshowsPrec :: Int -> GeoPoint -> ShowS
Show, forall x. Rep GeoPoint x -> GeoPoint
forall x. GeoPoint -> Rep GeoPoint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GeoPoint x -> GeoPoint
$cfrom :: forall x. GeoPoint -> Rep GeoPoint x
Generic)

instance ToJSON GeoPoint where
  toJSON :: GeoPoint -> Value
toJSON (GeoPoint (FieldName Text
geoPointField) LatLon
geoPointLatLon) =
    [Pair] -> Value
object [Text -> Key
fromText Text
geoPointField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= LatLon
geoPointLatLon]

data DistanceUnit
  = Miles
  | Yards
  | Feet
  | Inches
  | Kilometers
  | Meters
  | Centimeters
  | Millimeters
  | NauticalMiles
  deriving (DistanceUnit -> DistanceUnit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DistanceUnit -> DistanceUnit -> Bool
$c/= :: DistanceUnit -> DistanceUnit -> Bool
== :: DistanceUnit -> DistanceUnit -> Bool
$c== :: DistanceUnit -> DistanceUnit -> Bool
Eq, Int -> DistanceUnit -> ShowS
[DistanceUnit] -> ShowS
DistanceUnit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DistanceUnit] -> ShowS
$cshowList :: [DistanceUnit] -> ShowS
show :: DistanceUnit -> String
$cshow :: DistanceUnit -> String
showsPrec :: Int -> DistanceUnit -> ShowS
$cshowsPrec :: Int -> DistanceUnit -> ShowS
Show, forall x. Rep DistanceUnit x -> DistanceUnit
forall x. DistanceUnit -> Rep DistanceUnit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DistanceUnit x -> DistanceUnit
$cfrom :: forall x. DistanceUnit -> Rep DistanceUnit x
Generic)

instance ToJSON DistanceUnit where
  toJSON :: DistanceUnit -> Value
toJSON DistanceUnit
Miles = Text -> Value
String Text
"mi"
  toJSON DistanceUnit
Yards = Text -> Value
String Text
"yd"
  toJSON DistanceUnit
Feet = Text -> Value
String Text
"ft"
  toJSON DistanceUnit
Inches = Text -> Value
String Text
"in"
  toJSON DistanceUnit
Kilometers = Text -> Value
String Text
"km"
  toJSON DistanceUnit
Meters = Text -> Value
String Text
"m"
  toJSON DistanceUnit
Centimeters = Text -> Value
String Text
"cm"
  toJSON DistanceUnit
Millimeters = Text -> Value
String Text
"mm"
  toJSON DistanceUnit
NauticalMiles = Text -> Value
String Text
"nmi"

instance FromJSON DistanceUnit where
  parseJSON :: Value -> Parser DistanceUnit
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"DistanceUnit" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f DistanceUnit
parse
    where
      parse :: a -> f DistanceUnit
parse a
"mi" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Miles
      parse a
"yd" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Yards
      parse a
"ft" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Feet
      parse a
"in" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Inches
      parse a
"km" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Kilometers
      parse a
"m" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Meters
      parse a
"cm" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Centimeters
      parse a
"mm" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Millimeters
      parse a
"nmi" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
NauticalMiles
      parse a
u = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unrecognized DistanceUnit: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
u)

data DistanceType
  = Arc
  | SloppyArc -- doesn't exist <1.0
  | Plane
  deriving (DistanceType -> DistanceType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DistanceType -> DistanceType -> Bool
$c/= :: DistanceType -> DistanceType -> Bool
== :: DistanceType -> DistanceType -> Bool
$c== :: DistanceType -> DistanceType -> Bool
Eq, Int -> DistanceType -> ShowS
[DistanceType] -> ShowS
DistanceType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DistanceType] -> ShowS
$cshowList :: [DistanceType] -> ShowS
show :: DistanceType -> String
$cshow :: DistanceType -> String
showsPrec :: Int -> DistanceType -> ShowS
$cshowsPrec :: Int -> DistanceType -> ShowS
Show, forall x. Rep DistanceType x -> DistanceType
forall x. DistanceType -> Rep DistanceType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DistanceType x -> DistanceType
$cfrom :: forall x. DistanceType -> Rep DistanceType x
Generic)

instance ToJSON DistanceType where
  toJSON :: DistanceType -> Value
toJSON DistanceType
Arc = Text -> Value
String Text
"arc"
  toJSON DistanceType
SloppyArc = Text -> Value
String Text
"sloppy_arc"
  toJSON DistanceType
Plane = Text -> Value
String Text
"plane"

instance FromJSON DistanceType where
  parseJSON :: Value -> Parser DistanceType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"DistanceType" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f DistanceType
parse
    where
      parse :: a -> f DistanceType
parse a
"arc" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceType
Arc
      parse a
"sloppy_arc" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceType
SloppyArc
      parse a
"plane" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceType
Plane
      parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unrecognized DistanceType: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)

data OptimizeBbox
  = OptimizeGeoFilterType GeoFilterType
  | NoOptimizeBbox
  deriving (OptimizeBbox -> OptimizeBbox -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OptimizeBbox -> OptimizeBbox -> Bool
$c/= :: OptimizeBbox -> OptimizeBbox -> Bool
== :: OptimizeBbox -> OptimizeBbox -> Bool
$c== :: OptimizeBbox -> OptimizeBbox -> Bool
Eq, Int -> OptimizeBbox -> ShowS
[OptimizeBbox] -> ShowS
OptimizeBbox -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OptimizeBbox] -> ShowS
$cshowList :: [OptimizeBbox] -> ShowS
show :: OptimizeBbox -> String
$cshow :: OptimizeBbox -> String
showsPrec :: Int -> OptimizeBbox -> ShowS
$cshowsPrec :: Int -> OptimizeBbox -> ShowS
Show, forall x. Rep OptimizeBbox x -> OptimizeBbox
forall x. OptimizeBbox -> Rep OptimizeBbox x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OptimizeBbox x -> OptimizeBbox
$cfrom :: forall x. OptimizeBbox -> Rep OptimizeBbox x
Generic)

instance ToJSON OptimizeBbox where
  toJSON :: OptimizeBbox -> Value
toJSON OptimizeBbox
NoOptimizeBbox = Text -> Value
String Text
"none"
  toJSON (OptimizeGeoFilterType GeoFilterType
gft) = forall a. ToJSON a => a -> Value
toJSON GeoFilterType
gft

instance FromJSON OptimizeBbox where
  parseJSON :: Value -> Parser OptimizeBbox
parseJSON Value
v =
    forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"NoOptimizeBbox" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadPlus f) =>
a -> f OptimizeBbox
parseNoOptimize Value
v
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser OptimizeBbox
parseOptimize Value
v
    where
      parseNoOptimize :: a -> f OptimizeBbox
parseNoOptimize a
"none" = forall (f :: * -> *) a. Applicative f => a -> f a
pure OptimizeBbox
NoOptimizeBbox
      parseNoOptimize a
_ = forall (m :: * -> *) a. MonadPlus m => m a
mzero
      parseOptimize :: Value -> Parser OptimizeBbox
parseOptimize = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GeoFilterType -> OptimizeBbox
OptimizeGeoFilterType forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromJSON a => Value -> Parser a
parseJSON

data Distance = Distance
  { Distance -> Double
coefficient :: Double,
    Distance -> DistanceUnit
unit :: DistanceUnit
  }
  deriving (Distance -> Distance -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Distance -> Distance -> Bool
$c/= :: Distance -> Distance -> Bool
== :: Distance -> Distance -> Bool
$c== :: Distance -> Distance -> Bool
Eq, Int -> Distance -> ShowS
[Distance] -> ShowS
Distance -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Distance] -> ShowS
$cshowList :: [Distance] -> ShowS
show :: Distance -> String
$cshow :: Distance -> String
showsPrec :: Int -> Distance -> ShowS
$cshowsPrec :: Int -> Distance -> ShowS
Show, forall x. Rep Distance x -> Distance
forall x. Distance -> Rep Distance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Distance x -> Distance
$cfrom :: forall x. Distance -> Rep Distance x
Generic)

instance ToJSON Distance where
  toJSON :: Distance -> Value
toJSON (Distance Double
dCoefficient DistanceUnit
dUnit) =
    Text -> Value
String Text
boltedTogether
    where
      coefText :: Text
coefText = forall a. Show a => a -> Text
showText Double
dCoefficient
      (String Text
unitText) = forall a. ToJSON a => a -> Value
toJSON DistanceUnit
dUnit
      boltedTogether :: Text
boltedTogether = forall a. Monoid a => a -> a -> a
mappend Text
coefText Text
unitText

instance FromJSON Distance where
  parseJSON :: Value -> Parser Distance
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"Distance" Text -> Parser Distance
parse
    where
      parse :: Text -> Parser Distance
parse Text
t =
        Double -> DistanceUnit -> Distance
Distance
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {m :: * -> *} {a}. (MonadFail m, Read a) => Text -> m a
parseCoeff Text
nT
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. FromJSON a => Value -> Parser a
parseJSON (Text -> Value
String Text
unitT)
        where
          (Text
nT, Text
unitT) = (Char -> Bool) -> Text -> (Text, Text)
T.span Char -> Bool
validForNumber Text
t
          -- may be a better way to do this
          validForNumber :: Char -> Bool
validForNumber Char
'-' = Bool
True
          validForNumber Char
'.' = Bool
True
          validForNumber Char
'e' = Bool
True
          validForNumber Char
c = Char -> Bool
isNumber Char
c
          parseCoeff :: Text -> m a
parseCoeff Text
"" = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Empty string cannot be parsed as number"
          parseCoeff Text
s = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Read a => String -> a
read (Text -> String
T.unpack Text
s))

data DistanceRange = DistanceRange
  { DistanceRange -> Distance
distanceFrom :: Distance,
    DistanceRange -> Distance
distanceTo :: Distance
  }
  deriving (DistanceRange -> DistanceRange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DistanceRange -> DistanceRange -> Bool
$c/= :: DistanceRange -> DistanceRange -> Bool
== :: DistanceRange -> DistanceRange -> Bool
$c== :: DistanceRange -> DistanceRange -> Bool
Eq, Int -> DistanceRange -> ShowS
[DistanceRange] -> ShowS
DistanceRange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DistanceRange] -> ShowS
$cshowList :: [DistanceRange] -> ShowS
show :: DistanceRange -> String
$cshow :: DistanceRange -> String
showsPrec :: Int -> DistanceRange -> ShowS
$cshowsPrec :: Int -> DistanceRange -> ShowS
Show, forall x. Rep DistanceRange x -> DistanceRange
forall x. DistanceRange -> Rep DistanceRange x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DistanceRange x -> DistanceRange
$cfrom :: forall x. DistanceRange -> Rep DistanceRange x
Generic)

type TemplateQueryValue = Text

newtype TemplateQueryKeyValuePairs
  = TemplateQueryKeyValuePairs (X.KeyMap TemplateQueryValue)
  deriving (TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
$c/= :: TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
== :: TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
$c== :: TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
Eq, Int -> TemplateQueryKeyValuePairs -> ShowS
[TemplateQueryKeyValuePairs] -> ShowS
TemplateQueryKeyValuePairs -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TemplateQueryKeyValuePairs] -> ShowS
$cshowList :: [TemplateQueryKeyValuePairs] -> ShowS
show :: TemplateQueryKeyValuePairs -> String
$cshow :: TemplateQueryKeyValuePairs -> String
showsPrec :: Int -> TemplateQueryKeyValuePairs -> ShowS
$cshowsPrec :: Int -> TemplateQueryKeyValuePairs -> ShowS
Show)

instance ToJSON TemplateQueryKeyValuePairs where
  toJSON :: TemplateQueryKeyValuePairs -> Value
toJSON (TemplateQueryKeyValuePairs KeyMap Text
x) = Object -> Value
Object forall a b. (a -> b) -> a -> b
$ Text -> Value
String forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> KeyMap Text
x

instance FromJSON TemplateQueryKeyValuePairs where
  parseJSON :: Value -> Parser TemplateQueryKeyValuePairs
parseJSON (Object Object
o) =
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap Text -> TemplateQueryKeyValuePairs
TemplateQueryKeyValuePairs forall a b. (a -> b) -> a -> b
$ forall a b. (a -> Maybe b) -> KeyMap a -> KeyMap b
X.mapMaybe Value -> Maybe Text
getValue Object
o
    where
      getValue :: Value -> Maybe Text
getValue (String Text
x) = forall a. a -> Maybe a
Just Text
x
      getValue Value
_ = forall a. Maybe a
Nothing
  parseJSON Value
_ =
    forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"error parsing TemplateQueryKeyValuePairs"

-- | 'BooleanOperator' is the usual And/Or operators with an ES compatible
--    JSON encoding baked in. Used all over the place.
data BooleanOperator = And | Or deriving (BooleanOperator -> BooleanOperator -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BooleanOperator -> BooleanOperator -> Bool
$c/= :: BooleanOperator -> BooleanOperator -> Bool
== :: BooleanOperator -> BooleanOperator -> Bool
$c== :: BooleanOperator -> BooleanOperator -> Bool
Eq, Int -> BooleanOperator -> ShowS
[BooleanOperator] -> ShowS
BooleanOperator -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BooleanOperator] -> ShowS
$cshowList :: [BooleanOperator] -> ShowS
show :: BooleanOperator -> String
$cshow :: BooleanOperator -> String
showsPrec :: Int -> BooleanOperator -> ShowS
$cshowsPrec :: Int -> BooleanOperator -> ShowS
Show, forall x. Rep BooleanOperator x -> BooleanOperator
forall x. BooleanOperator -> Rep BooleanOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BooleanOperator x -> BooleanOperator
$cfrom :: forall x. BooleanOperator -> Rep BooleanOperator x
Generic)

instance ToJSON BooleanOperator where
  toJSON :: BooleanOperator -> Value
toJSON BooleanOperator
And = Text -> Value
String Text
"and"
  toJSON BooleanOperator
Or = Text -> Value
String Text
"or"

instance FromJSON BooleanOperator where
  parseJSON :: Value -> Parser BooleanOperator
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"BooleanOperator" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f BooleanOperator
parse
    where
      parse :: a -> f BooleanOperator
parse a
"and" = forall (f :: * -> *) a. Applicative f => a -> f a
pure BooleanOperator
And
      parse a
"or" = forall (f :: * -> *) a. Applicative f => a -> f a
pure BooleanOperator
Or
      parse a
o = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected BooleanOperator: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
o)

-- | 'Cache' is for telling ES whether it should cache a 'Filter' not.
--    'Query's cannot be cached.
type Cache = Bool -- caching on/off

defaultCache :: Cache
defaultCache :: Bool
defaultCache = Bool
False

data FunctionScoreQuery = FunctionScoreQuery
  { FunctionScoreQuery -> Maybe Query
functionScoreQuery :: Maybe Query,
    FunctionScoreQuery -> Maybe Boost
functionScoreBoost :: Maybe Boost,
    FunctionScoreQuery -> FunctionScoreFunctions
functionScoreFunctions :: FunctionScoreFunctions,
    FunctionScoreQuery -> Maybe Boost
functionScoreMaxBoost :: Maybe Boost,
    FunctionScoreQuery -> Maybe BoostMode
functionScoreBoostMode :: Maybe BoostMode,
    FunctionScoreQuery -> Score
functionScoreMinScore :: Score,
    FunctionScoreQuery -> Maybe ScoreMode
functionScoreScoreMode :: Maybe ScoreMode
  }
  deriving (FunctionScoreQuery -> FunctionScoreQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionScoreQuery -> FunctionScoreQuery -> Bool
$c/= :: FunctionScoreQuery -> FunctionScoreQuery -> Bool
== :: FunctionScoreQuery -> FunctionScoreQuery -> Bool
$c== :: FunctionScoreQuery -> FunctionScoreQuery -> Bool
Eq, Int -> FunctionScoreQuery -> ShowS
[FunctionScoreQuery] -> ShowS
FunctionScoreQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionScoreQuery] -> ShowS
$cshowList :: [FunctionScoreQuery] -> ShowS
show :: FunctionScoreQuery -> String
$cshow :: FunctionScoreQuery -> String
showsPrec :: Int -> FunctionScoreQuery -> ShowS
$cshowsPrec :: Int -> FunctionScoreQuery -> ShowS
Show, forall x. Rep FunctionScoreQuery x -> FunctionScoreQuery
forall x. FunctionScoreQuery -> Rep FunctionScoreQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FunctionScoreQuery x -> FunctionScoreQuery
$cfrom :: forall x. FunctionScoreQuery -> Rep FunctionScoreQuery x
Generic)

instance ToJSON FunctionScoreQuery where
  toJSON :: FunctionScoreQuery -> Value
toJSON (FunctionScoreQuery Maybe Query
query Maybe Boost
boost FunctionScoreFunctions
fns Maybe Boost
maxBoost Maybe BoostMode
boostMode Score
minScore Maybe ScoreMode
scoreMode) =
    [Pair] -> Value
omitNulls [Pair]
base
    where
      base :: [Pair]
base =
        FunctionScoreFunctions -> Pair
functionScoreFunctionsPair FunctionScoreFunctions
fns
          forall a. a -> [a] -> [a]
: [ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Query
query,
              Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
              Key
"max_boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
maxBoost,
              Key
"boost_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BoostMode
boostMode,
              Key
"min_score" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Score
minScore,
              Key
"score_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe ScoreMode
scoreMode
            ]

instance FromJSON FunctionScoreQuery where
  parseJSON :: Value -> Parser FunctionScoreQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FunctionScoreQuery" Object -> Parser FunctionScoreQuery
parse
    where
      parse :: Object -> Parser FunctionScoreQuery
parse Object
o =
        Maybe Query
-> Maybe Boost
-> FunctionScoreFunctions
-> Maybe Boost
-> Maybe BoostMode
-> Score
-> Maybe ScoreMode
-> FunctionScoreQuery
FunctionScoreQuery
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"query"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( Object -> Parser FunctionScoreFunctions
singleFunction Object
o
                  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NonEmpty ComponentFunctionScoreFunction
-> Parser FunctionScoreFunctions
multipleFunctions
                  forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"functions"
              )
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_boost"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost_mode"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_score"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"score_mode"
        where
          taggedWith :: (a -> Parser b) -> Key -> Parser b
taggedWith a -> Parser b
parser Key
k = a -> Parser b
parser forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
k
      singleFunction :: Object -> Parser FunctionScoreFunctions
singleFunction = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FunctionScoreFunction -> FunctionScoreFunctions
FunctionScoreSingle forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object -> Parser FunctionScoreFunction
parseFunctionScoreFunction
      multipleFunctions :: NonEmpty ComponentFunctionScoreFunction
-> Parser FunctionScoreFunctions
multipleFunctions = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty ComponentFunctionScoreFunction -> FunctionScoreFunctions
FunctionScoreMultiple

data FunctionScoreFunctions
  = FunctionScoreSingle FunctionScoreFunction
  | FunctionScoreMultiple (NonEmpty ComponentFunctionScoreFunction)
  deriving (FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
$c/= :: FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
== :: FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
$c== :: FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
Eq, Int -> FunctionScoreFunctions -> ShowS
[FunctionScoreFunctions] -> ShowS
FunctionScoreFunctions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionScoreFunctions] -> ShowS
$cshowList :: [FunctionScoreFunctions] -> ShowS
show :: FunctionScoreFunctions -> String
$cshow :: FunctionScoreFunctions -> String
showsPrec :: Int -> FunctionScoreFunctions -> ShowS
$cshowsPrec :: Int -> FunctionScoreFunctions -> ShowS
Show, forall x. Rep FunctionScoreFunctions x -> FunctionScoreFunctions
forall x. FunctionScoreFunctions -> Rep FunctionScoreFunctions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FunctionScoreFunctions x -> FunctionScoreFunctions
$cfrom :: forall x. FunctionScoreFunctions -> Rep FunctionScoreFunctions x
Generic)

data ComponentFunctionScoreFunction = ComponentFunctionScoreFunction
  { ComponentFunctionScoreFunction -> Maybe Filter
componentScoreFunctionFilter :: Maybe Filter,
    ComponentFunctionScoreFunction -> FunctionScoreFunction
componentScoreFunction :: FunctionScoreFunction,
    ComponentFunctionScoreFunction -> Maybe Weight
componentScoreFunctionWeight :: Maybe Weight
  }
  deriving (ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
$c/= :: ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
== :: ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
$c== :: ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
Eq, Int -> ComponentFunctionScoreFunction -> ShowS
[ComponentFunctionScoreFunction] -> ShowS
ComponentFunctionScoreFunction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ComponentFunctionScoreFunction] -> ShowS
$cshowList :: [ComponentFunctionScoreFunction] -> ShowS
show :: ComponentFunctionScoreFunction -> String
$cshow :: ComponentFunctionScoreFunction -> String
showsPrec :: Int -> ComponentFunctionScoreFunction -> ShowS
$cshowsPrec :: Int -> ComponentFunctionScoreFunction -> ShowS
Show, forall x.
Rep ComponentFunctionScoreFunction x
-> ComponentFunctionScoreFunction
forall x.
ComponentFunctionScoreFunction
-> Rep ComponentFunctionScoreFunction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ComponentFunctionScoreFunction x
-> ComponentFunctionScoreFunction
$cfrom :: forall x.
ComponentFunctionScoreFunction
-> Rep ComponentFunctionScoreFunction x
Generic)

instance ToJSON ComponentFunctionScoreFunction where
  toJSON :: ComponentFunctionScoreFunction -> Value
toJSON (ComponentFunctionScoreFunction Maybe Filter
filter' FunctionScoreFunction
fn Maybe Weight
weight) =
    [Pair] -> Value
omitNulls [Pair]
base
    where
      base :: [Pair]
base =
        FunctionScoreFunction -> Pair
functionScoreFunctionPair FunctionScoreFunction
fn
          forall a. a -> [a] -> [a]
: [ Key
"filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Filter
filter',
              Key
"weight" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Weight
weight
            ]

instance FromJSON ComponentFunctionScoreFunction where
  parseJSON :: Value -> Parser ComponentFunctionScoreFunction
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ComponentFunctionScoreFunction" Object -> Parser ComponentFunctionScoreFunction
parse
    where
      parse :: Object -> Parser ComponentFunctionScoreFunction
parse Object
o =
        Maybe Filter
-> FunctionScoreFunction
-> Maybe Weight
-> ComponentFunctionScoreFunction
ComponentFunctionScoreFunction
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"filter"
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object -> Parser FunctionScoreFunction
parseFunctionScoreFunction Object
o
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"weight"

functionScoreFunctionsPair :: FunctionScoreFunctions -> (Key, Value)
functionScoreFunctionsPair :: FunctionScoreFunctions -> Pair
functionScoreFunctionsPair (FunctionScoreSingle FunctionScoreFunction
fn) =
  FunctionScoreFunction -> Pair
functionScoreFunctionPair FunctionScoreFunction
fn
functionScoreFunctionsPair (FunctionScoreMultiple NonEmpty ComponentFunctionScoreFunction
componentFns) =
  (Key
"functions", forall a. ToJSON a => a -> Value
toJSON NonEmpty ComponentFunctionScoreFunction
componentFns)

fieldTagged :: (Monad m, MonadFail m) => (FieldName -> Object -> m a) -> Object -> m a
fieldTagged :: forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged FieldName -> Object -> m a
f Object
o = case forall v. KeyMap v -> [(Key, v)]
X.toList Object
o of
  [(Key
k, Object Object
o')] -> FieldName -> Object -> m a
f (Text -> FieldName
FieldName forall a b. (a -> b) -> a -> b
$ Key -> Text
toText Key
k) Object
o'
  [Pair]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected object with 1 field-named key"

-- | Fuzziness value as a number or 'AUTO'.
-- See:
-- https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#fuzziness
data Fuzziness = Fuzziness Double | FuzzinessAuto
  deriving (Fuzziness -> Fuzziness -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fuzziness -> Fuzziness -> Bool
$c/= :: Fuzziness -> Fuzziness -> Bool
== :: Fuzziness -> Fuzziness -> Bool
$c== :: Fuzziness -> Fuzziness -> Bool
Eq, Int -> Fuzziness -> ShowS
[Fuzziness] -> ShowS
Fuzziness -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fuzziness] -> ShowS
$cshowList :: [Fuzziness] -> ShowS
show :: Fuzziness -> String
$cshow :: Fuzziness -> String
showsPrec :: Int -> Fuzziness -> ShowS
$cshowsPrec :: Int -> Fuzziness -> ShowS
Show, forall x. Rep Fuzziness x -> Fuzziness
forall x. Fuzziness -> Rep Fuzziness x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Fuzziness x -> Fuzziness
$cfrom :: forall x. Fuzziness -> Rep Fuzziness x
Generic)

instance ToJSON Fuzziness where
  toJSON :: Fuzziness -> Value
toJSON (Fuzziness Double
n) = forall a. ToJSON a => a -> Value
toJSON Double
n
  toJSON Fuzziness
FuzzinessAuto = Text -> Value
String Text
"AUTO"

instance FromJSON Fuzziness where
  parseJSON :: Value -> Parser Fuzziness
parseJSON (String Text
"AUTO") = forall (m :: * -> *) a. Monad m => a -> m a
return Fuzziness
FuzzinessAuto
  parseJSON Value
v = Double -> Fuzziness
Fuzziness forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v

data InnerHits = InnerHits
  { InnerHits -> Maybe Integer
innerHitsFrom :: Maybe Integer,
    InnerHits -> Maybe Integer
innerHitsSize :: Maybe Integer
  }
  deriving (InnerHits -> InnerHits -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InnerHits -> InnerHits -> Bool
$c/= :: InnerHits -> InnerHits -> Bool
== :: InnerHits -> InnerHits -> Bool
$c== :: InnerHits -> InnerHits -> Bool
Eq, Int -> InnerHits -> ShowS
[InnerHits] -> ShowS
InnerHits -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InnerHits] -> ShowS
$cshowList :: [InnerHits] -> ShowS
show :: InnerHits -> String
$cshow :: InnerHits -> String
showsPrec :: Int -> InnerHits -> ShowS
$cshowsPrec :: Int -> InnerHits -> ShowS
Show, forall x. Rep InnerHits x -> InnerHits
forall x. InnerHits -> Rep InnerHits x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InnerHits x -> InnerHits
$cfrom :: forall x. InnerHits -> Rep InnerHits x
Generic)

instance ToJSON InnerHits where
  toJSON :: InnerHits -> Value
toJSON (InnerHits Maybe Integer
ihFrom Maybe Integer
ihSize) =
    [Pair] -> Value
omitNulls
      [ Key
"from" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Integer
ihFrom,
        Key
"size" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Integer
ihSize
      ]

instance FromJSON InnerHits where
  parseJSON :: Value -> Parser InnerHits
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"InnerHits" Object -> Parser InnerHits
parse
    where
      parse :: Object -> Parser InnerHits
parse Object
o =
        Maybe Integer -> Maybe Integer -> InnerHits
InnerHits
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o 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
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"size"