{-# LANGUAGE OverloadedStrings #-}

module Database.Bloodhound.Internal.Versions.Common.Types.Query.Match
  ( MatchQuery (..),
    MatchQueryType (..),
    MultiMatchQuery (..),
    MultiMatchQueryType (..),
    mkMatchQuery,
    mkMultiMatchQuery,
  )
where

import Database.Bloodhound.Internal.Utils.Imports
import Database.Bloodhound.Internal.Versions.Common.Types.Newtypes
import Database.Bloodhound.Internal.Versions.Common.Types.Query.Commons
import GHC.Generics

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 stock (MatchQuery -> MatchQuery -> Bool
(MatchQuery -> MatchQuery -> Bool)
-> (MatchQuery -> MatchQuery -> Bool) -> Eq MatchQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MatchQuery -> MatchQuery -> Bool
== :: MatchQuery -> MatchQuery -> Bool
$c/= :: MatchQuery -> MatchQuery -> Bool
/= :: MatchQuery -> MatchQuery -> Bool
Eq, Int -> MatchQuery -> ShowS
[MatchQuery] -> ShowS
MatchQuery -> String
(Int -> MatchQuery -> ShowS)
-> (MatchQuery -> String)
-> ([MatchQuery] -> ShowS)
-> Show MatchQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MatchQuery -> ShowS
showsPrec :: Int -> MatchQuery -> ShowS
$cshow :: MatchQuery -> String
show :: MatchQuery -> String
$cshowList :: [MatchQuery] -> ShowS
showList :: [MatchQuery] -> ShowS
Show, (forall x. MatchQuery -> Rep MatchQuery x)
-> (forall x. Rep MatchQuery x -> MatchQuery) -> Generic MatchQuery
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
$cfrom :: forall x. MatchQuery -> Rep MatchQuery x
from :: forall x. MatchQuery -> Rep MatchQuery x
$cto :: forall x. Rep MatchQuery x -> MatchQuery
to :: forall x. Rep MatchQuery x -> MatchQuery
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 Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"query" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
mqQueryString,
            Key
"operator" Key -> BooleanOperator -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
booleanOperator,
            Key
"zero_terms_query" Key -> ZeroTermsQuery -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ZeroTermsQuery
zeroTermsQuery,
            Key
"cutoff_frequency" Key -> Maybe CutoffFrequency -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe CutoffFrequency
cutoffFrequency,
            Key
"type" Key -> Maybe MatchQueryType -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe MatchQueryType
matchQueryType,
            Key
"analyzer" Key -> Maybe Analyzer -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
            Key
"max_expansions" Key -> Maybe MaxExpansions -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxExpansions
maxExpansions,
            Key
"lenient" Key -> Maybe Lenient -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Lenient
lenient,
            Key
"boost" Key -> Maybe Boost -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
            Key
"minimum_should_match" Key -> Maybe Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
minShouldMatch,
            Key
"fuzziness" Key -> Maybe Fuzziness -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Fuzziness
mqFuzziness
          ]

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

data MatchQueryType
  = MatchPhrase
  | MatchPhrasePrefix
  deriving stock (MatchQueryType -> MatchQueryType -> Bool
(MatchQueryType -> MatchQueryType -> Bool)
-> (MatchQueryType -> MatchQueryType -> Bool) -> Eq MatchQueryType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MatchQueryType -> MatchQueryType -> Bool
== :: MatchQueryType -> MatchQueryType -> Bool
$c/= :: MatchQueryType -> MatchQueryType -> Bool
/= :: MatchQueryType -> MatchQueryType -> Bool
Eq, Int -> MatchQueryType -> ShowS
[MatchQueryType] -> ShowS
MatchQueryType -> String
(Int -> MatchQueryType -> ShowS)
-> (MatchQueryType -> String)
-> ([MatchQueryType] -> ShowS)
-> Show MatchQueryType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MatchQueryType -> ShowS
showsPrec :: Int -> MatchQueryType -> ShowS
$cshow :: MatchQueryType -> String
show :: MatchQueryType -> String
$cshowList :: [MatchQueryType] -> ShowS
showList :: [MatchQueryType] -> ShowS
Show, (forall x. MatchQueryType -> Rep MatchQueryType x)
-> (forall x. Rep MatchQueryType x -> MatchQueryType)
-> Generic MatchQueryType
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
$cfrom :: forall x. MatchQueryType -> Rep MatchQueryType x
from :: forall x. MatchQueryType -> Rep MatchQueryType x
$cto :: forall x. Rep MatchQueryType x -> MatchQueryType
to :: forall x. Rep MatchQueryType x -> MatchQueryType
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 = String
-> (Text -> Parser MatchQueryType)
-> Value
-> Parser MatchQueryType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"MatchQueryType" Text -> Parser MatchQueryType
forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f MatchQueryType
parse
    where
      parse :: a -> f MatchQueryType
parse a
"phrase" = MatchQueryType -> f MatchQueryType
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MatchQueryType
MatchPhrase
      parse a
"phrase_prefix" = MatchQueryType -> f MatchQueryType
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MatchQueryType
MatchPhrasePrefix
      parse a
t = String -> f MatchQueryType
forall a. String -> f a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected MatchQueryType: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> a -> String
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 stock (MultiMatchQuery -> MultiMatchQuery -> Bool
(MultiMatchQuery -> MultiMatchQuery -> Bool)
-> (MultiMatchQuery -> MultiMatchQuery -> Bool)
-> Eq MultiMatchQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiMatchQuery -> MultiMatchQuery -> Bool
== :: MultiMatchQuery -> MultiMatchQuery -> Bool
$c/= :: MultiMatchQuery -> MultiMatchQuery -> Bool
/= :: MultiMatchQuery -> MultiMatchQuery -> Bool
Eq, Int -> MultiMatchQuery -> ShowS
[MultiMatchQuery] -> ShowS
MultiMatchQuery -> String
(Int -> MultiMatchQuery -> ShowS)
-> (MultiMatchQuery -> String)
-> ([MultiMatchQuery] -> ShowS)
-> Show MultiMatchQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MultiMatchQuery -> ShowS
showsPrec :: Int -> MultiMatchQuery -> ShowS
$cshow :: MultiMatchQuery -> String
show :: MultiMatchQuery -> String
$cshowList :: [MultiMatchQuery] -> ShowS
showList :: [MultiMatchQuery] -> ShowS
Show, (forall x. MultiMatchQuery -> Rep MultiMatchQuery x)
-> (forall x. Rep MultiMatchQuery x -> MultiMatchQuery)
-> Generic MultiMatchQuery
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
$cfrom :: forall x. MultiMatchQuery -> Rep MultiMatchQuery x
from :: forall x. MultiMatchQuery -> Rep MultiMatchQuery x
$cto :: forall x. Rep MultiMatchQuery x -> MultiMatchQuery
to :: forall x. Rep MultiMatchQuery x -> MultiMatchQuery
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" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"fields" Key -> [Value] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (FieldName -> Value) -> [FieldName] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FieldName -> Value
forall a. ToJSON a => a -> Value
toJSON [FieldName]
fields,
            Key
"query" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
query,
            Key
"operator" Key -> BooleanOperator -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
boolOp,
            Key
"zero_terms_query" Key -> ZeroTermsQuery -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ZeroTermsQuery
ztQ,
            Key
"tie_breaker" Key -> Maybe Tiebreaker -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Tiebreaker
tb,
            Key
"type" Key -> Maybe MultiMatchQueryType -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe MultiMatchQueryType
mmqt,
            Key
"cutoff_frequency" Key -> Maybe CutoffFrequency -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe CutoffFrequency
cf,
            Key
"analyzer" Key -> Maybe Analyzer -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
            Key
"max_expansions" Key -> Maybe MaxExpansions -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxExpansions
maxEx,
            Key
"lenient" Key -> Maybe Lenient -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Lenient
lenient
          ]

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

data MultiMatchQueryType
  = MultiMatchBestFields
  | MultiMatchMostFields
  | MultiMatchCrossFields
  | MultiMatchPhrase
  | MultiMatchPhrasePrefix
  deriving stock (MultiMatchQueryType -> MultiMatchQueryType -> Bool
(MultiMatchQueryType -> MultiMatchQueryType -> Bool)
-> (MultiMatchQueryType -> MultiMatchQueryType -> Bool)
-> Eq MultiMatchQueryType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
== :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
$c/= :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
/= :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
Eq, Int -> MultiMatchQueryType -> ShowS
[MultiMatchQueryType] -> ShowS
MultiMatchQueryType -> String
(Int -> MultiMatchQueryType -> ShowS)
-> (MultiMatchQueryType -> String)
-> ([MultiMatchQueryType] -> ShowS)
-> Show MultiMatchQueryType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MultiMatchQueryType -> ShowS
showsPrec :: Int -> MultiMatchQueryType -> ShowS
$cshow :: MultiMatchQueryType -> String
show :: MultiMatchQueryType -> String
$cshowList :: [MultiMatchQueryType] -> ShowS
showList :: [MultiMatchQueryType] -> ShowS
Show, (forall x. MultiMatchQueryType -> Rep MultiMatchQueryType x)
-> (forall x. Rep MultiMatchQueryType x -> MultiMatchQueryType)
-> Generic MultiMatchQueryType
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
$cfrom :: forall x. MultiMatchQueryType -> Rep MultiMatchQueryType x
from :: forall x. MultiMatchQueryType -> Rep MultiMatchQueryType x
$cto :: forall x. Rep MultiMatchQueryType x -> MultiMatchQueryType
to :: forall x. Rep MultiMatchQueryType x -> MultiMatchQueryType
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 = String
-> (Text -> Parser MultiMatchQueryType)
-> Value
-> Parser MultiMatchQueryType
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"MultiMatchPhrasePrefix" Text -> Parser MultiMatchQueryType
forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f MultiMatchQueryType
parse
    where
      parse :: a -> f MultiMatchQueryType
parse a
"best_fields" = MultiMatchQueryType -> f MultiMatchQueryType
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchBestFields
      parse a
"most_fields" = MultiMatchQueryType -> f MultiMatchQueryType
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchMostFields
      parse a
"cross_fields" = MultiMatchQueryType -> f MultiMatchQueryType
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchCrossFields
      parse a
"phrase" = MultiMatchQueryType -> f MultiMatchQueryType
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchPhrase
      parse a
"phrase_prefix" = MultiMatchQueryType -> f MultiMatchQueryType
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchPhrasePrefix
      parse a
t = String -> f MultiMatchQueryType
forall a. String -> f a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected MultiMatchPhrasePrefix: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> a -> String
forall a. Show a => a -> String
show a
t)