-- | Pinecone's filtering query language
module Pinecone.Metadata
    ( Scalar(..)
    , Filter(..)
    ) where

import Pinecone.Prelude

-- | A scalar value used for metadata filters
data Scalar
    = ScalarNumber Scientific
    | ScalarString Text
    | ScalarBoolean Bool
    deriving stock (Scalar -> Scalar -> Bool
(Scalar -> Scalar -> Bool)
-> (Scalar -> Scalar -> Bool) -> Eq Scalar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Scalar -> Scalar -> Bool
== :: Scalar -> Scalar -> Bool
$c/= :: Scalar -> Scalar -> Bool
/= :: Scalar -> Scalar -> Bool
Eq, (forall x. Scalar -> Rep Scalar x)
-> (forall x. Rep Scalar x -> Scalar) -> Generic Scalar
forall x. Rep Scalar x -> Scalar
forall x. Scalar -> Rep Scalar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Scalar -> Rep Scalar x
from :: forall x. Scalar -> Rep Scalar x
$cto :: forall x. Rep Scalar x -> Scalar
to :: forall x. Rep Scalar x -> Scalar
Generic, Int -> Scalar -> ShowS
[Scalar] -> ShowS
Scalar -> String
(Int -> Scalar -> ShowS)
-> (Scalar -> String) -> ([Scalar] -> ShowS) -> Show Scalar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Scalar -> ShowS
showsPrec :: Int -> Scalar -> ShowS
$cshow :: Scalar -> String
show :: Scalar -> String
$cshowList :: [Scalar] -> ShowS
showList :: [Scalar] -> ShowS
Show)

instance IsString Scalar where
    fromString :: String -> Scalar
fromString String
string = Text -> Scalar
ScalarString (String -> Text
forall a. IsString a => String -> a
fromString String
string)

instance Num Scalar where
    fromInteger :: Integer -> Scalar
fromInteger Integer
n = Scientific -> Scalar
ScalarNumber (Integer -> Scientific
forall a. Num a => Integer -> a
fromInteger Integer
n)

    ScalarNumber Scientific
l + :: Scalar -> Scalar -> Scalar
+ ScalarNumber Scientific
r = Scientific -> Scalar
ScalarNumber (Scientific
l Scientific -> Scientific -> Scientific
forall a. Num a => a -> a -> a
+ Scientific
r)
    Scalar
_ + ScalarNumber Scientific
r = Scientific -> Scalar
ScalarNumber Scientific
r
    Scalar
l + Scalar
_ = Scalar
l

    ScalarNumber Scientific
l * :: Scalar -> Scalar -> Scalar
* ScalarNumber Scientific
r = Scientific -> Scalar
ScalarNumber (Scientific
l Scientific -> Scientific -> Scientific
forall a. Num a => a -> a -> a
* Scientific
r)
    Scalar
_ * ScalarNumber Scientific
r = Scientific -> Scalar
ScalarNumber Scientific
r
    Scalar
l * Scalar
_ = Scalar
l

    abs :: Scalar -> Scalar
abs (ScalarNumber Scientific
n) = Scientific -> Scalar
ScalarNumber (Scientific -> Scientific
forall a. Num a => a -> a
abs Scientific
n)
    abs Scalar
n = Scalar
n

    signum :: Scalar -> Scalar
signum (ScalarNumber Scientific
n) = Scientific -> Scalar
ScalarNumber (Scientific -> Scientific
forall a. Num a => a -> a
signum Scientific
n)
    signum Scalar
n = Scalar
n

    negate :: Scalar -> Scalar
negate (ScalarNumber Scientific
n) = Scientific -> Scalar
ScalarNumber (Scientific -> Scientific
forall a. Num a => a -> a
negate Scientific
n)
    negate Scalar
n = Scalar
n

instance ToJSON Scalar where
    toJSON :: Scalar -> Value
toJSON (ScalarNumber Scientific
scientific) = Scientific -> Value
Number Scientific
scientific
    toJSON (ScalarString Text
text) = Text -> Value
String Text
text
    toJSON (ScalarBoolean Bool
bool) = Bool -> Value
Bool Bool
bool

instance FromJSON Scalar where
    parseJSON :: Value -> Parser Scalar
parseJSON (Number Scientific
scientific) = Scalar -> Parser Scalar
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Scientific -> Scalar
ScalarNumber Scientific
scientific)
    parseJSON (String Text
text) = Scalar -> Parser Scalar
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Scalar
ScalarString Text
text)
    parseJSON (Bool Bool
bool) = Scalar -> Parser Scalar
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> Scalar
ScalarBoolean Bool
bool)
    parseJSON Value
object = String -> Value -> Parser Scalar
forall a. String -> Value -> Parser a
typeMismatch String
"Number/String/Boolean" Value
object

-- | Metadata query language
data Filter
    = Equal Text Scalar
    | NotEqual Text Scalar
    | GreaterThan Text Scientific
    | GreaterThanOrEqual Text Scientific
    | LessThan Text Scientific
    | LessThanOrEqual Text Scientific
    | In Text Scalar
    | NotIn Text Scalar
    | Exists Text Bool
    | And (Vector Filter)
    | Or (Vector Filter)
    deriving stock (Filter -> Filter -> Bool
(Filter -> Filter -> Bool)
-> (Filter -> Filter -> Bool) -> Eq Filter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Filter -> Filter -> Bool
== :: Filter -> Filter -> Bool
$c/= :: Filter -> Filter -> Bool
/= :: Filter -> Filter -> Bool
Eq, (forall x. Filter -> Rep Filter x)
-> (forall x. Rep Filter x -> Filter) -> Generic Filter
forall x. Rep Filter x -> Filter
forall x. Filter -> Rep Filter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Filter -> Rep Filter x
from :: forall x. Filter -> Rep Filter x
$cto :: forall x. Rep Filter x -> Filter
to :: forall x. Rep Filter x -> Filter
Generic, Int -> Filter -> ShowS
[Filter] -> ShowS
Filter -> String
(Int -> Filter -> ShowS)
-> (Filter -> String) -> ([Filter] -> ShowS) -> Show Filter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Filter -> ShowS
showsPrec :: Int -> Filter -> ShowS
$cshow :: Filter -> String
show :: Filter -> String
$cshowList :: [Filter] -> ShowS
showList :: [Filter] -> ShowS
Show)

instance ToJSON Filter where
    toJSON :: Filter -> Value
toJSON (Equal Text
field Scalar
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Scalar)) [ (Text
field, [ (Text
"$eq", Scalar
literal) ]) ]
    toJSON (NotEqual Text
field Scalar
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Scalar)) [ (Text
field, [ (Text
"$ne", Scalar
literal) ]) ]
    toJSON (GreaterThan Text
field Scientific
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Scientific)) [ (Text
field, [ (Text
"$gt", Scientific
literal) ]) ]
    toJSON (GreaterThanOrEqual Text
field Scientific
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Scientific)) [ (Text
field, [ (Text
"$gte", Scientific
literal) ]) ]
    toJSON (LessThan Text
field Scientific
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Scientific)) [ (Text
field, [ (Text
"$lt", Scientific
literal) ]) ]
    toJSON (LessThanOrEqual Text
field Scientific
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Scientific)) [ (Text
field, [ (Text
"$lte", Scientific
literal) ]) ]
    toJSON (In Text
field Scalar
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Scalar)) [ (Text
field, [ (Text
"$in", Scalar
literal) ]) ]
    toJSON (NotIn Text
field Scalar
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Scalar)) [ (Text
field, [ (Text
"$nin", Scalar
literal) ]) ]
    toJSON (Exists Text
field Bool
literal) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Map Text Bool)) [ (Text
field, [ (Text
"$exists", Bool
literal) ]) ]
    toJSON (And Vector Filter
clauses) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Vector Filter)) [ (Text
"$and", Vector Filter
clauses) ]
    toJSON (Or Vector Filter
clauses) =
        forall a. ToJSON a => a -> Value
toJSON @(Map Text (Vector Filter)) [ (Text
"$or", Vector Filter
clauses) ]

instance FromJSON Filter where
    parseJSON :: Value -> Parser Filter
parseJSON Value
v =
            Value -> Parser Filter
parseEqual Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseNotEqual Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseGreaterThan Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseGreaterThanOrEqual Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseLessThan Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseLessThanOrEqual Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseIn Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseNotIn Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseAnd Value
v
        Parser Filter -> Parser Filter -> Parser Filter
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser Filter
parseOr Value
v
      where
        parseEqual :: Value -> Parser Filter
parseEqual Value
value = do
            [ (Text
field, [ (Text
"$eq", Scalar
literal) ]) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Map Text Scalar)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Scalar -> Filter
Equal Text
field Scalar
literal)

        parseNotEqual :: Value -> Parser Filter
parseNotEqual Value
value = do
            [ (Text
field, [ (Text
"$ne", Scalar
literal) ]) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Map Text Scalar)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Scalar -> Filter
NotEqual Text
field Scalar
literal)

        parseGreaterThan :: Value -> Parser Filter
parseGreaterThan Value
value = do
            [ (Text
field, [ (Text
"$gt", Scientific
literal) ]) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Map Text Scientific)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Scientific -> Filter
GreaterThan Text
field Scientific
literal)

        parseGreaterThanOrEqual :: Value -> Parser Filter
parseGreaterThanOrEqual Value
value = do
            [ (Text
field, [ (Text
"$gte", Scientific
literal) ]) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Map Text Scientific)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Scientific -> Filter
GreaterThanOrEqual Text
field Scientific
literal)

        parseLessThan :: Value -> Parser Filter
parseLessThan Value
value = do
            [ (Text
field, [ (Text
"$lt", Scientific
literal) ]) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Map Text Scientific)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Scientific -> Filter
LessThan Text
field Scientific
literal)

        parseLessThanOrEqual :: Value -> Parser Filter
parseLessThanOrEqual Value
value = do
            [ (Text
field, [ (Text
"$lte", Scientific
literal) ]) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Map Text Scientific)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Scientific -> Filter
LessThanOrEqual Text
field Scientific
literal)

        parseIn :: Value -> Parser Filter
parseIn Value
value = do
            [ (Text
field, [ (Text
"$in", Scalar
literal) ]) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Map Text Scalar)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Scalar -> Filter
In Text
field Scalar
literal)

        parseNotIn :: Value -> Parser Filter
parseNotIn Value
value = do
            [ (Text
field, [ (Text
"$nin", Scalar
literal) ]) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Map Text Scalar)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Scalar -> Filter
NotIn Text
field Scalar
literal)

        parseAnd :: Value -> Parser Filter
parseAnd Value
value = do
            [ (Text
"$and", Vector Filter
clauses) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Vector Filter)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector Filter -> Filter
And Vector Filter
clauses)

        parseOr :: Value -> Parser Filter
parseOr Value
value = do
            [ (Text
"$or", Vector Filter
clauses) ] <- forall a. FromJSON a => Value -> Parser a
parseJSON @(Map Text (Vector Filter)) Value
value
            Filter -> Parser Filter
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector Filter -> Filter
Or Vector Filter
clauses)