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

module Database.Bloodhound.Internal.Versions.Common.Types.Query.SimpleQueryString
  ( FieldOrFields (..),
    SimpleQueryFlag (..),
    SimpleQueryStringQuery (..),
  )
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 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 stock (SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
(SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool)
-> (SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool)
-> Eq SimpleQueryStringQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
== :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
$c/= :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
/= :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
Eq, Int -> SimpleQueryStringQuery -> ShowS
[SimpleQueryStringQuery] -> ShowS
SimpleQueryStringQuery -> String
(Int -> SimpleQueryStringQuery -> ShowS)
-> (SimpleQueryStringQuery -> String)
-> ([SimpleQueryStringQuery] -> ShowS)
-> Show SimpleQueryStringQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SimpleQueryStringQuery -> ShowS
showsPrec :: Int -> SimpleQueryStringQuery -> ShowS
$cshow :: SimpleQueryStringQuery -> String
show :: SimpleQueryStringQuery -> String
$cshowList :: [SimpleQueryStringQuery] -> ShowS
showList :: [SimpleQueryStringQuery] -> ShowS
Show, (forall x. SimpleQueryStringQuery -> Rep SimpleQueryStringQuery x)
-> (forall x.
    Rep SimpleQueryStringQuery x -> SimpleQueryStringQuery)
-> Generic SimpleQueryStringQuery
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
$cfrom :: forall x. SimpleQueryStringQuery -> Rep SimpleQueryStringQuery x
from :: forall x. SimpleQueryStringQuery -> Rep SimpleQueryStringQuery x
$cto :: forall x. Rep SimpleQueryStringQuery x -> SimpleQueryStringQuery
to :: forall x. Rep SimpleQueryStringQuery x -> SimpleQueryStringQuery
Generic)

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

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

data SimpleQueryFlag
  = SimpleQueryAll
  | SimpleQueryNone
  | SimpleQueryAnd
  | SimpleQueryOr
  | SimpleQueryPrefix
  | SimpleQueryPhrase
  | SimpleQueryPrecedence
  | SimpleQueryEscape
  | SimpleQueryWhitespace
  | SimpleQueryFuzzy
  | SimpleQueryNear
  | SimpleQuerySlop
  deriving stock (SimpleQueryFlag -> SimpleQueryFlag -> Bool
(SimpleQueryFlag -> SimpleQueryFlag -> Bool)
-> (SimpleQueryFlag -> SimpleQueryFlag -> Bool)
-> Eq SimpleQueryFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
== :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
$c/= :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
/= :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
Eq, Int -> SimpleQueryFlag -> ShowS
[SimpleQueryFlag] -> ShowS
SimpleQueryFlag -> String
(Int -> SimpleQueryFlag -> ShowS)
-> (SimpleQueryFlag -> String)
-> ([SimpleQueryFlag] -> ShowS)
-> Show SimpleQueryFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SimpleQueryFlag -> ShowS
showsPrec :: Int -> SimpleQueryFlag -> ShowS
$cshow :: SimpleQueryFlag -> String
show :: SimpleQueryFlag -> String
$cshowList :: [SimpleQueryFlag] -> ShowS
showList :: [SimpleQueryFlag] -> ShowS
Show, (forall x. SimpleQueryFlag -> Rep SimpleQueryFlag x)
-> (forall x. Rep SimpleQueryFlag x -> SimpleQueryFlag)
-> Generic SimpleQueryFlag
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
$cfrom :: forall x. SimpleQueryFlag -> Rep SimpleQueryFlag x
from :: forall x. SimpleQueryFlag -> Rep SimpleQueryFlag x
$cto :: forall x. Rep SimpleQueryFlag x -> SimpleQueryFlag
to :: forall x. Rep SimpleQueryFlag x -> SimpleQueryFlag
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 = String
-> (Text -> Parser SimpleQueryFlag)
-> Value
-> Parser SimpleQueryFlag
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"SimpleQueryFlag" Text -> Parser SimpleQueryFlag
forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f SimpleQueryFlag
parse
    where
      parse :: a -> f SimpleQueryFlag
parse a
"ALL" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryAll
      parse a
"NONE" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryNone
      parse a
"AND" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryAnd
      parse a
"OR" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryOr
      parse a
"PREFIX" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPrefix
      parse a
"PHRASE" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPhrase
      parse a
"PRECEDENCE" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPrecedence
      parse a
"ESCAPE" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryEscape
      parse a
"WHITESPACE" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryWhitespace
      parse a
"FUZZY" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryFuzzy
      parse a
"NEAR" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryNear
      parse a
"SLOP" = SimpleQueryFlag -> f SimpleQueryFlag
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQuerySlop
      parse a
f = String -> f SimpleQueryFlag
forall a. String -> f a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected SimpleQueryFlag: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> a -> String
forall a. Show a => a -> String
show a
f)

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

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

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