{-# language DataKinds             #-}
{-# language FlexibleContexts      #-}
{-# language FlexibleInstances     #-}
{-# language GADTs                 #-}
{-# language MultiParamTypeClasses #-}
{-# language OverloadedStrings     #-}
{-# language PolyKinds             #-}
{-# language ScopedTypeVariables   #-}
{-# language TypeApplications      #-}
{-# language TypeOperators         #-}
{-# language UndecidableInstances  #-}
{-# language ViewPatterns          #-}
{-# OPTIONS_GHC -Wincomplete-patterns -fno-warn-orphans #-}

module Mu.GraphQL.Query.Parse where

import           Control.Monad.Except
import qualified Data.Aeson                    as A
import           Data.Coerce                   (coerce)
import qualified Data.Foldable                 as F
import qualified Data.HashMap.Strict           as HM
import           Data.Int                      (Int32)
import           Data.Kind
import           Data.List                     (find)
import           Data.Maybe
import           Data.Proxy
import           Data.Scientific               (floatingOrInteger)
import           Data.SOP.NS
import qualified Data.Text                     as T
import           GHC.TypeLits
import qualified Language.GraphQL.Draft.Syntax as GQL

import           Mu.GraphQL.Annotations
import           Mu.GraphQL.Query.Definition
import           Mu.Rpc
import           Mu.Schema

type VariableMapC = HM.HashMap T.Text GQL.ValueConst
type VariableMap  = HM.HashMap T.Text GQL.Value
type FragmentMap  = HM.HashMap T.Text GQL.FragmentDefinition

instance A.FromJSON GQL.ValueConst where
  parseJSON :: Value -> Parser ValueConst
parseJSON A.Null       = ValueConst -> Parser ValueConst
forall (f :: * -> *) a. Applicative f => a -> f a
pure ValueConst
GQL.VCNull
  parseJSON (A.Bool b :: Bool
b)   = ValueConst -> Parser ValueConst
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValueConst -> Parser ValueConst)
-> ValueConst -> Parser ValueConst
forall a b. (a -> b) -> a -> b
$ Bool -> ValueConst
GQL.VCBoolean Bool
b
  parseJSON (A.String s :: Text
s) = ValueConst -> Parser ValueConst
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValueConst -> Parser ValueConst)
-> ValueConst -> Parser ValueConst
forall a b. (a -> b) -> a -> b
$ StringValue -> ValueConst
GQL.VCString (StringValue -> ValueConst) -> StringValue -> ValueConst
forall a b. (a -> b) -> a -> b
$ Text -> StringValue
forall a b. Coercible a b => a -> b
coerce Text
s
  parseJSON (A.Number n :: Scientific
n) = ValueConst -> Parser ValueConst
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValueConst -> Parser ValueConst)
-> ValueConst -> Parser ValueConst
forall a b. (a -> b) -> a -> b
$ (Double -> ValueConst)
-> (Int32 -> ValueConst) -> Either Double Int32 -> ValueConst
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Double -> ValueConst
GQL.VCFloat Int32 -> ValueConst
GQL.VCInt (Either Double Int32 -> ValueConst)
-> Either Double Int32 -> ValueConst
forall a b. (a -> b) -> a -> b
$ Scientific -> Either Double Int32
forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
n
  parseJSON (A.Array xs :: Array
xs) = ListValueC -> ValueConst
GQL.VCList (ListValueC -> ValueConst)
-> (Vector ValueConst -> ListValueC)
-> Vector ValueConst
-> ValueConst
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ValueConst] -> ListValueC
forall a. [a] -> ListValueG a
GQL.ListValueG ([ValueConst] -> ListValueC)
-> (Vector ValueConst -> [ValueConst])
-> Vector ValueConst
-> ListValueC
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector ValueConst -> [ValueConst]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList (Vector ValueConst -> ValueConst)
-> Parser (Vector ValueConst) -> Parser ValueConst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Parser ValueConst) -> Array -> Parser (Vector ValueConst)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Value -> Parser ValueConst
forall a. FromJSON a => Value -> Parser a
A.parseJSON Array
xs
  parseJSON (A.Object o :: Object
o) = ObjectValueC -> ValueConst
GQL.VCObject (ObjectValueC -> ValueConst)
-> (HashMap Text ValueConst -> ObjectValueC)
-> HashMap Text ValueConst
-> ValueConst
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ObjectFieldG ValueConst] -> ObjectValueC
forall a. [ObjectFieldG a] -> ObjectValueG a
GQL.ObjectValueG ([ObjectFieldG ValueConst] -> ObjectValueC)
-> (HashMap Text ValueConst -> [ObjectFieldG ValueConst])
-> HashMap Text ValueConst
-> ObjectValueC
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Text, ValueConst) -> ObjectFieldG ValueConst)
-> [(Text, ValueConst)] -> [ObjectFieldG ValueConst]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text, ValueConst) -> ObjectFieldG ValueConst
toObjFld ([(Text, ValueConst)] -> [ObjectFieldG ValueConst])
-> (HashMap Text ValueConst -> [(Text, ValueConst)])
-> HashMap Text ValueConst
-> [ObjectFieldG ValueConst]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap Text ValueConst -> [(Text, ValueConst)]
forall k v. HashMap k v -> [(k, v)]
HM.toList (HashMap Text ValueConst -> ValueConst)
-> Parser (HashMap Text ValueConst) -> Parser ValueConst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Parser ValueConst)
-> Object -> Parser (HashMap Text ValueConst)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Value -> Parser ValueConst
forall a. FromJSON a => Value -> Parser a
A.parseJSON Object
o
    where
      toObjFld :: (T.Text, GQL.ValueConst) -> GQL.ObjectFieldG GQL.ValueConst
      toObjFld :: (Text, ValueConst) -> ObjectFieldG ValueConst
toObjFld (k :: Text
k, v :: ValueConst
v) = Name -> ValueConst -> ObjectFieldG ValueConst
forall a. Name -> a -> ObjectFieldG a
GQL.ObjectFieldG (Text -> Name
forall a b. Coercible a b => a -> b
coerce Text
k) ValueConst
v

parseDoc ::
  forall qr mut sub p f.
  ( MonadError T.Text f, ParseTypedDoc p qr mut sub ) =>
  Maybe T.Text -> VariableMapC ->
  GQL.ExecutableDocument ->
  f (Document p qr mut sub)
-- If there's no operation name, there must be only one query
parseDoc :: Maybe Text
-> HashMap Text ValueConst
-> ExecutableDocument
-> f (Document p qr mut sub)
parseDoc Nothing vmap :: HashMap Text ValueConst
vmap (GQL.ExecutableDocument defns :: [ExecutableDefinition]
defns)
  = case [ExecutableDefinition]
-> ([SelectionSet], [TypedOperationDefinition],
    [FragmentDefinition])
GQL.partitionExDefs [ExecutableDefinition]
defns of
      ([unnamed :: SelectionSet
unnamed], [], frs :: [FragmentDefinition]
frs)
        -> VariableMap
-> FragmentMap -> SelectionSet -> f (Document p qr mut sub)
forall (p :: Package') (qr :: Maybe Symbol) (mut :: Maybe Symbol)
       (sub :: Maybe Symbol) (f :: * -> *).
(ParseTypedDoc p qr mut sub, MonadError Text f) =>
VariableMap
-> FragmentMap -> SelectionSet -> f (Document p qr mut sub)
parseTypedDocQuery VariableMap
forall k v. HashMap k v
HM.empty ([FragmentDefinition] -> FragmentMap
fragmentsToMap [FragmentDefinition]
frs) SelectionSet
unnamed
      ([], [named :: TypedOperationDefinition
named], frs :: [FragmentDefinition]
frs)
        -> HashMap Text ValueConst
-> FragmentMap
-> TypedOperationDefinition
-> f (Document p qr mut sub)
forall (f :: * -> *) (p :: Package') (qr :: Maybe Symbol)
       (mut :: Maybe Symbol) (sub :: Maybe Symbol).
(MonadError Text f, ParseTypedDoc p qr mut sub) =>
HashMap Text ValueConst
-> FragmentMap
-> TypedOperationDefinition
-> f (Document p qr mut sub)
parseTypedDoc HashMap Text ValueConst
vmap ([FragmentDefinition] -> FragmentMap
fragmentsToMap [FragmentDefinition]
frs) TypedOperationDefinition
named
      ([], [], _) -> Text -> f (Document p qr mut sub)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no operation to execute"
      (_,  [], _) -> Text -> f (Document p qr mut sub)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "more than one unnamed query"
      ([], _, _)  -> Text -> f (Document p qr mut sub)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "more than one named operation but no 'operationName' given"
      (_,  _, _)  -> Text -> f (Document p qr mut sub)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "both named and unnamed queries, but no 'operationName' given"
-- If there's an operation name, look in the named queries
parseDoc (Just operationName :: Text
operationName) vmap :: HashMap Text ValueConst
vmap (GQL.ExecutableDocument defns :: [ExecutableDefinition]
defns)
  = case [ExecutableDefinition]
-> ([SelectionSet], [TypedOperationDefinition],
    [FragmentDefinition])
GQL.partitionExDefs [ExecutableDefinition]
defns of
      (_, named :: [TypedOperationDefinition]
named, frs :: [FragmentDefinition]
frs) -> f (Document p qr mut sub)
-> (TypedOperationDefinition -> f (Document p qr mut sub))
-> Maybe TypedOperationDefinition
-> f (Document p qr mut sub)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe f (Document p qr mut sub)
forall a. MonadError Text f => f a
notFound (HashMap Text ValueConst
-> FragmentMap
-> TypedOperationDefinition
-> f (Document p qr mut sub)
forall (f :: * -> *) (p :: Package') (qr :: Maybe Symbol)
       (mut :: Maybe Symbol) (sub :: Maybe Symbol).
(MonadError Text f, ParseTypedDoc p qr mut sub) =>
HashMap Text ValueConst
-> FragmentMap
-> TypedOperationDefinition
-> f (Document p qr mut sub)
parseTypedDoc HashMap Text ValueConst
vmap ([FragmentDefinition] -> FragmentMap
fragmentsToMap [FragmentDefinition]
frs)) ((TypedOperationDefinition -> Bool)
-> [TypedOperationDefinition] -> Maybe TypedOperationDefinition
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find TypedOperationDefinition -> Bool
isThis [TypedOperationDefinition]
named)
    where isThis :: TypedOperationDefinition -> Bool
isThis (TypedOperationDefinition -> Maybe Name
GQL._todName -> Just nm :: Name
nm)
            = Name -> Text
GQL.unName Name
nm Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
operationName
          isThis _ = Bool
False
          notFound :: MonadError T.Text f => f a
          notFound :: f a
notFound = Text -> f a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f a) -> Text -> f a
forall a b. (a -> b) -> a -> b
$ "operation '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
operationName Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found"

fragmentsToMap :: [GQL.FragmentDefinition] -> FragmentMap
fragmentsToMap :: [FragmentDefinition] -> FragmentMap
fragmentsToMap = [(Text, FragmentDefinition)] -> FragmentMap
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList ([(Text, FragmentDefinition)] -> FragmentMap)
-> ([FragmentDefinition] -> [(Text, FragmentDefinition)])
-> [FragmentDefinition]
-> FragmentMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FragmentDefinition -> (Text, FragmentDefinition))
-> [FragmentDefinition] -> [(Text, FragmentDefinition)]
forall a b. (a -> b) -> [a] -> [b]
map FragmentDefinition -> (Text, FragmentDefinition)
fragmentToThingy
  where fragmentToThingy :: GQL.FragmentDefinition -> (T.Text, GQL.FragmentDefinition)
        fragmentToThingy :: FragmentDefinition -> (Text, FragmentDefinition)
fragmentToThingy f :: FragmentDefinition
f = (Name -> Text
GQL.unName (Name -> Text) -> Name -> Text
forall a b. (a -> b) -> a -> b
$ FragmentDefinition -> Name
GQL._fdName FragmentDefinition
f, FragmentDefinition
f)

parseTypedDoc ::
  (MonadError T.Text f, ParseTypedDoc p qr mut sub) =>
  VariableMapC -> FragmentMap ->
  GQL.TypedOperationDefinition ->
  f (Document p qr mut sub)
parseTypedDoc :: HashMap Text ValueConst
-> FragmentMap
-> TypedOperationDefinition
-> f (Document p qr mut sub)
parseTypedDoc vmap :: HashMap Text ValueConst
vmap frmap :: FragmentMap
frmap tod :: TypedOperationDefinition
tod
  = let defVmap :: HashMap Text ValueConst
defVmap = [VariableDefinition] -> HashMap Text ValueConst
parseVariableMap (TypedOperationDefinition -> [VariableDefinition]
GQL._todVariableDefinitions TypedOperationDefinition
tod)
        finalVmap :: VariableMap
finalVmap = ValueConst -> Value
constToValue (ValueConst -> Value) -> HashMap Text ValueConst -> VariableMap
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HashMap Text ValueConst
-> HashMap Text ValueConst -> HashMap Text ValueConst
forall k v.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k v -> HashMap k v
HM.union HashMap Text ValueConst
vmap HashMap Text ValueConst
defVmap  -- first one takes precedence
    in case TypedOperationDefinition -> OperationType
GQL._todType TypedOperationDefinition
tod of
        GQL.OperationTypeQuery
          -> VariableMap
-> FragmentMap -> SelectionSet -> f (Document p qr mut sub)
forall (p :: Package') (qr :: Maybe Symbol) (mut :: Maybe Symbol)
       (sub :: Maybe Symbol) (f :: * -> *).
(ParseTypedDoc p qr mut sub, MonadError Text f) =>
VariableMap
-> FragmentMap -> SelectionSet -> f (Document p qr mut sub)
parseTypedDocQuery VariableMap
finalVmap FragmentMap
frmap (TypedOperationDefinition -> SelectionSet
GQL._todSelectionSet TypedOperationDefinition
tod)
        GQL.OperationTypeMutation
          -> VariableMap
-> FragmentMap -> SelectionSet -> f (Document p qr mut sub)
forall (p :: Package') (qr :: Maybe Symbol) (mut :: Maybe Symbol)
       (sub :: Maybe Symbol) (f :: * -> *).
(ParseTypedDoc p qr mut sub, MonadError Text f) =>
VariableMap
-> FragmentMap -> SelectionSet -> f (Document p qr mut sub)
parseTypedDocMutation VariableMap
finalVmap FragmentMap
frmap (TypedOperationDefinition -> SelectionSet
GQL._todSelectionSet TypedOperationDefinition
tod)
        GQL.OperationTypeSubscription
          -> VariableMap
-> FragmentMap -> SelectionSet -> f (Document p qr mut sub)
forall (p :: Package') (qr :: Maybe Symbol) (mut :: Maybe Symbol)
       (sub :: Maybe Symbol) (f :: * -> *).
(ParseTypedDoc p qr mut sub, MonadError Text f) =>
VariableMap
-> FragmentMap -> SelectionSet -> f (Document p qr mut sub)
parseTypedDocSubscription VariableMap
finalVmap FragmentMap
frmap (TypedOperationDefinition -> SelectionSet
GQL._todSelectionSet TypedOperationDefinition
tod)

class ParseTypedDoc (p :: Package')
                    (qr :: Maybe Symbol) (mut :: Maybe Symbol) (sub :: Maybe Symbol) where
  parseTypedDocQuery ::
    MonadError T.Text f =>
    VariableMap -> FragmentMap ->
    GQL.SelectionSet ->
    f (Document p qr mut sub)
  parseTypedDocMutation ::
    MonadError T.Text f =>
    VariableMap -> FragmentMap ->
    GQL.SelectionSet ->
    f (Document p qr mut sub)
  parseTypedDocSubscription ::
    MonadError T.Text f =>
    VariableMap -> FragmentMap ->
    GQL.SelectionSet ->
    f (Document p qr mut sub)

instance
  ( p ~ 'Package pname ss,
    LookupService ss qr ~ 'Service qr qanns qmethods,
    KnownName qr, ParseMethod p qmethods,
    LookupService ss mut ~ 'Service mut manns mmethods,
    KnownName mut, ParseMethod p mmethods,
    LookupService ss sub ~ 'Service sub sanns smethods,
    KnownName sub, ParseMethod p smethods
  ) => ParseTypedDoc p ('Just qr) ('Just mut) ('Just sub) where
  parseTypedDocQuery :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) ('Just mut) ('Just sub))
parseTypedDocQuery vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
-> Document ('Package pname ss) ('Just qr) ('Just mut) ('Just sub)
forall a mnm anm (ss :: [Service a mnm anm]) (qr :: a)
       (qanns :: [*]) (qms :: [Method a mnm anm]) (pname :: Maybe a)
       (mut :: Maybe a) (sub :: Maybe a).
(LookupService ss qr ~ 'Service qr qanns qms) =>
ServiceQuery ('Package pname ss) (LookupService ss qr)
-> Document ('Package pname ss) ('Just qr) mut sub
QueryDoc ([OneMethodQuery ('Package pname ss) (LookupService ss qr)]
 -> Document ('Package pname ss) ('Just qr) ('Just mut) ('Just sub))
-> f [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
-> f (Document
        ('Package pname ss) ('Just qr) ('Just mut) ('Just sub))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy ('Package pname ss)
-> Proxy qr
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy qr
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
  parseTypedDocMutation :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) ('Just mut) ('Just sub))
parseTypedDocMutation vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
-> Document ('Package pname ss) ('Just qr) ('Just mut) ('Just sub)
forall a mnm anm (ss :: [Service a mnm anm]) (mut :: a)
       (manns :: [*]) (mms :: [Method a mnm anm]) (pname :: Maybe a)
       (qr :: Maybe a) (sub :: Maybe a).
(LookupService ss mut ~ 'Service mut manns mms) =>
ServiceQuery ('Package pname ss) (LookupService ss mut)
-> Document ('Package pname ss) qr ('Just mut) sub
MutationDoc ([OneMethodQuery ('Package pname ss) (LookupService ss mut)]
 -> Document ('Package pname ss) ('Just qr) ('Just mut) ('Just sub))
-> f [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
-> f (Document
        ('Package pname ss) ('Just qr) ('Just mut) ('Just sub))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy ('Package pname ss)
-> Proxy mut
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy mut
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
  parseTypedDocSubscription :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) ('Just mut) ('Just sub))
parseTypedDocSubscription vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = do [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
q <- Proxy ('Package pname ss)
-> Proxy sub
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy sub
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
         case [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
q of
           [one :: OneMethodQuery ('Package pname ss) (LookupService ss sub)
one] -> Document ('Package pname ss) ('Just qr) ('Just mut) ('Just sub)
-> f (Document p ('Just qr) ('Just mut) ('Just sub))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Document ('Package pname ss) ('Just qr) ('Just mut) ('Just sub)
 -> f (Document p ('Just qr) ('Just mut) ('Just sub)))
-> Document ('Package pname ss) ('Just qr) ('Just mut) ('Just sub)
-> f (Document p ('Just qr) ('Just mut) ('Just sub))
forall a b. (a -> b) -> a -> b
$ OneMethodQuery ('Package pname ss) (LookupService ss sub)
-> Document ('Package pname ss) ('Just qr) ('Just mut) ('Just sub)
forall a mnm anm (ss :: [Service a mnm anm]) (sub :: a)
       (manns :: [*]) (mms :: [Method a mnm anm]) (pname :: Maybe a)
       (qr :: Maybe a) (mut :: Maybe a).
(LookupService ss sub ~ 'Service sub manns mms) =>
OneMethodQuery ('Package pname ss) (LookupService ss sub)
-> Document ('Package pname ss) qr mut ('Just sub)
SubscriptionDoc OneMethodQuery ('Package pname ss) (LookupService ss sub)
one
           _     -> Text -> f (Document p ('Just qr) ('Just mut) ('Just sub))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "subscriptions may only have one field"

instance
  ( p ~ 'Package pname ss,
    LookupService ss qr ~ 'Service qr qanns qmethods,
    KnownName qr, ParseMethod p qmethods,
    LookupService ss mut ~ 'Service mut manns mmethods,
    KnownName mut, ParseMethod p mmethods
  ) => ParseTypedDoc p ('Just qr) ('Just mut) 'Nothing where
  parseTypedDocQuery :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) ('Just mut) 'Nothing)
parseTypedDocQuery vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
-> Document ('Package pname ss) ('Just qr) ('Just mut) 'Nothing
forall a mnm anm (ss :: [Service a mnm anm]) (qr :: a)
       (qanns :: [*]) (qms :: [Method a mnm anm]) (pname :: Maybe a)
       (mut :: Maybe a) (sub :: Maybe a).
(LookupService ss qr ~ 'Service qr qanns qms) =>
ServiceQuery ('Package pname ss) (LookupService ss qr)
-> Document ('Package pname ss) ('Just qr) mut sub
QueryDoc ([OneMethodQuery ('Package pname ss) (LookupService ss qr)]
 -> Document ('Package pname ss) ('Just qr) ('Just mut) 'Nothing)
-> f [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
-> f (Document ('Package pname ss) ('Just qr) ('Just mut) 'Nothing)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy ('Package pname ss)
-> Proxy qr
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy qr
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
  parseTypedDocMutation :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) ('Just mut) 'Nothing)
parseTypedDocMutation vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
-> Document ('Package pname ss) ('Just qr) ('Just mut) 'Nothing
forall a mnm anm (ss :: [Service a mnm anm]) (mut :: a)
       (manns :: [*]) (mms :: [Method a mnm anm]) (pname :: Maybe a)
       (qr :: Maybe a) (sub :: Maybe a).
(LookupService ss mut ~ 'Service mut manns mms) =>
ServiceQuery ('Package pname ss) (LookupService ss mut)
-> Document ('Package pname ss) qr ('Just mut) sub
MutationDoc ([OneMethodQuery ('Package pname ss) (LookupService ss mut)]
 -> Document ('Package pname ss) ('Just qr) ('Just mut) 'Nothing)
-> f [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
-> f (Document ('Package pname ss) ('Just qr) ('Just mut) 'Nothing)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy ('Package pname ss)
-> Proxy mut
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy mut
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
  parseTypedDocSubscription :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) ('Just mut) 'Nothing)
parseTypedDocSubscription _ _ _
    = Text -> f (Document p ('Just qr) ('Just mut) 'Nothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no subscriptions are defined in the schema"

instance
  ( p ~ 'Package pname ss,
    LookupService ss qr ~ 'Service qr qanns qmethods,
    KnownName qr, ParseMethod p qmethods,
    LookupService ss sub ~ 'Service sub sanns smethods,
    KnownName sub, ParseMethod p smethods
  ) => ParseTypedDoc p ('Just qr) 'Nothing ('Just sub) where
  parseTypedDocQuery :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) 'Nothing ('Just sub))
parseTypedDocQuery vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
-> Document ('Package pname ss) ('Just qr) 'Nothing ('Just sub)
forall a mnm anm (ss :: [Service a mnm anm]) (qr :: a)
       (qanns :: [*]) (qms :: [Method a mnm anm]) (pname :: Maybe a)
       (mut :: Maybe a) (sub :: Maybe a).
(LookupService ss qr ~ 'Service qr qanns qms) =>
ServiceQuery ('Package pname ss) (LookupService ss qr)
-> Document ('Package pname ss) ('Just qr) mut sub
QueryDoc ([OneMethodQuery ('Package pname ss) (LookupService ss qr)]
 -> Document ('Package pname ss) ('Just qr) 'Nothing ('Just sub))
-> f [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
-> f (Document ('Package pname ss) ('Just qr) 'Nothing ('Just sub))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy ('Package pname ss)
-> Proxy qr
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy qr
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
  parseTypedDocMutation :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) 'Nothing ('Just sub))
parseTypedDocMutation _ _ _
    = Text -> f (Document p ('Just qr) 'Nothing ('Just sub))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no mutations are defined in the schema"
  parseTypedDocSubscription :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) 'Nothing ('Just sub))
parseTypedDocSubscription vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = do [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
q <- Proxy ('Package pname ss)
-> Proxy sub
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy sub
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
         case [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
q of
           [one :: OneMethodQuery ('Package pname ss) (LookupService ss sub)
one] -> Document ('Package pname ss) ('Just qr) 'Nothing ('Just sub)
-> f (Document p ('Just qr) 'Nothing ('Just sub))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Document ('Package pname ss) ('Just qr) 'Nothing ('Just sub)
 -> f (Document p ('Just qr) 'Nothing ('Just sub)))
-> Document ('Package pname ss) ('Just qr) 'Nothing ('Just sub)
-> f (Document p ('Just qr) 'Nothing ('Just sub))
forall a b. (a -> b) -> a -> b
$ OneMethodQuery ('Package pname ss) (LookupService ss sub)
-> Document ('Package pname ss) ('Just qr) 'Nothing ('Just sub)
forall a mnm anm (ss :: [Service a mnm anm]) (sub :: a)
       (manns :: [*]) (mms :: [Method a mnm anm]) (pname :: Maybe a)
       (qr :: Maybe a) (mut :: Maybe a).
(LookupService ss sub ~ 'Service sub manns mms) =>
OneMethodQuery ('Package pname ss) (LookupService ss sub)
-> Document ('Package pname ss) qr mut ('Just sub)
SubscriptionDoc OneMethodQuery ('Package pname ss) (LookupService ss sub)
one
           _     -> Text -> f (Document p ('Just qr) 'Nothing ('Just sub))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "subscriptions may only have one field"

instance
  ( p ~ 'Package pname ss,
    LookupService ss qr ~ 'Service qr qanns qmethods,
    KnownName qr, ParseMethod p qmethods
  ) => ParseTypedDoc p ('Just qr) 'Nothing 'Nothing where
  parseTypedDocQuery :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) 'Nothing 'Nothing)
parseTypedDocQuery vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
-> Document ('Package pname ss) ('Just qr) 'Nothing 'Nothing
forall a mnm anm (ss :: [Service a mnm anm]) (qr :: a)
       (qanns :: [*]) (qms :: [Method a mnm anm]) (pname :: Maybe a)
       (mut :: Maybe a) (sub :: Maybe a).
(LookupService ss qr ~ 'Service qr qanns qms) =>
ServiceQuery ('Package pname ss) (LookupService ss qr)
-> Document ('Package pname ss) ('Just qr) mut sub
QueryDoc ([OneMethodQuery ('Package pname ss) (LookupService ss qr)]
 -> Document ('Package pname ss) ('Just qr) 'Nothing 'Nothing)
-> f [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
-> f (Document ('Package pname ss) ('Just qr) 'Nothing 'Nothing)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy ('Package pname ss)
-> Proxy qr
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss qr)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy qr
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
  parseTypedDocMutation :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) 'Nothing 'Nothing)
parseTypedDocMutation _ _ _
    = Text -> f (Document p ('Just qr) 'Nothing 'Nothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no mutations are defined in the schema"
  parseTypedDocSubscription :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p ('Just qr) 'Nothing 'Nothing)
parseTypedDocSubscription _ _ _
    = Text -> f (Document p ('Just qr) 'Nothing 'Nothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no subscriptions are defined in the schema"

instance
  ( p ~ 'Package pname ss,
    LookupService ss mut ~ 'Service mut manns mmethods,
    KnownName mut, ParseMethod p mmethods,
    LookupService ss sub ~ 'Service sub sanns smethods,
    KnownName sub, ParseMethod p smethods
  ) => ParseTypedDoc p 'Nothing ('Just mut) ('Just sub) where
  parseTypedDocQuery :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing ('Just mut) ('Just sub))
parseTypedDocQuery _ _ _
    = Text -> f (Document p 'Nothing ('Just mut) ('Just sub))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no queries are defined in the schema"
  parseTypedDocMutation :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing ('Just mut) ('Just sub))
parseTypedDocMutation vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
-> Document ('Package pname ss) 'Nothing ('Just mut) ('Just sub)
forall a mnm anm (ss :: [Service a mnm anm]) (mut :: a)
       (manns :: [*]) (mms :: [Method a mnm anm]) (pname :: Maybe a)
       (qr :: Maybe a) (sub :: Maybe a).
(LookupService ss mut ~ 'Service mut manns mms) =>
ServiceQuery ('Package pname ss) (LookupService ss mut)
-> Document ('Package pname ss) qr ('Just mut) sub
MutationDoc ([OneMethodQuery ('Package pname ss) (LookupService ss mut)]
 -> Document ('Package pname ss) 'Nothing ('Just mut) ('Just sub))
-> f [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
-> f (Document
        ('Package pname ss) 'Nothing ('Just mut) ('Just sub))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy ('Package pname ss)
-> Proxy mut
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy mut
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
  parseTypedDocSubscription :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing ('Just mut) ('Just sub))
parseTypedDocSubscription vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = do [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
q <- Proxy ('Package pname ss)
-> Proxy sub
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy sub
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
         case [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
q of
           [one :: OneMethodQuery ('Package pname ss) (LookupService ss sub)
one] -> Document ('Package pname ss) 'Nothing ('Just mut) ('Just sub)
-> f (Document p 'Nothing ('Just mut) ('Just sub))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Document ('Package pname ss) 'Nothing ('Just mut) ('Just sub)
 -> f (Document p 'Nothing ('Just mut) ('Just sub)))
-> Document ('Package pname ss) 'Nothing ('Just mut) ('Just sub)
-> f (Document p 'Nothing ('Just mut) ('Just sub))
forall a b. (a -> b) -> a -> b
$ OneMethodQuery ('Package pname ss) (LookupService ss sub)
-> Document ('Package pname ss) 'Nothing ('Just mut) ('Just sub)
forall a mnm anm (ss :: [Service a mnm anm]) (sub :: a)
       (manns :: [*]) (mms :: [Method a mnm anm]) (pname :: Maybe a)
       (qr :: Maybe a) (mut :: Maybe a).
(LookupService ss sub ~ 'Service sub manns mms) =>
OneMethodQuery ('Package pname ss) (LookupService ss sub)
-> Document ('Package pname ss) qr mut ('Just sub)
SubscriptionDoc OneMethodQuery ('Package pname ss) (LookupService ss sub)
one
           _     -> Text -> f (Document p 'Nothing ('Just mut) ('Just sub))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "subscriptions may only have one field"

instance
  ( p ~ 'Package pname ss,
    LookupService ss mut ~ 'Service mut manns mmethods,
    KnownName mut, ParseMethod p mmethods
  ) => ParseTypedDoc p 'Nothing ('Just mut) 'Nothing where
  parseTypedDocQuery :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing ('Just mut) 'Nothing)
parseTypedDocQuery _ _ _
    = Text -> f (Document p 'Nothing ('Just mut) 'Nothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no queries are defined in the schema"
  parseTypedDocMutation :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing ('Just mut) 'Nothing)
parseTypedDocMutation vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
-> Document ('Package pname ss) 'Nothing ('Just mut) 'Nothing
forall a mnm anm (ss :: [Service a mnm anm]) (mut :: a)
       (manns :: [*]) (mms :: [Method a mnm anm]) (pname :: Maybe a)
       (qr :: Maybe a) (sub :: Maybe a).
(LookupService ss mut ~ 'Service mut manns mms) =>
ServiceQuery ('Package pname ss) (LookupService ss mut)
-> Document ('Package pname ss) qr ('Just mut) sub
MutationDoc ([OneMethodQuery ('Package pname ss) (LookupService ss mut)]
 -> Document ('Package pname ss) 'Nothing ('Just mut) 'Nothing)
-> f [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
-> f (Document ('Package pname ss) 'Nothing ('Just mut) 'Nothing)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy ('Package pname ss)
-> Proxy mut
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss mut)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy mut
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
  parseTypedDocSubscription :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing ('Just mut) 'Nothing)
parseTypedDocSubscription _ _ _
    = Text -> f (Document p 'Nothing ('Just mut) 'Nothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no subscriptions are defined in the schema"

instance
  ( p ~ 'Package pname ss,
    LookupService ss sub ~ 'Service sub sanns smethods,
    KnownName sub, ParseMethod p smethods
  ) => ParseTypedDoc p 'Nothing 'Nothing ('Just sub) where
  parseTypedDocQuery :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing 'Nothing ('Just sub))
parseTypedDocQuery _ _ _
    = Text -> f (Document p 'Nothing 'Nothing ('Just sub))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no queries are defined in the schema"
  parseTypedDocMutation :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing 'Nothing ('Just sub))
parseTypedDocMutation _ _ _
    = Text -> f (Document p 'Nothing 'Nothing ('Just sub))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no mutations are defined in the schema"
  parseTypedDocSubscription :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing 'Nothing ('Just sub))
parseTypedDocSubscription vmap :: VariableMap
vmap frmap :: FragmentMap
frmap sset :: SelectionSet
sset
    = do [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
q <- Proxy ('Package pname ss)
-> Proxy sub
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy ('Package pname ss)
forall k (t :: k). Proxy t
Proxy Proxy sub
forall k (t :: k). Proxy t
Proxy VariableMap
vmap FragmentMap
frmap SelectionSet
sset
         case [OneMethodQuery ('Package pname ss) (LookupService ss sub)]
q of
           [one :: OneMethodQuery ('Package pname ss) (LookupService ss sub)
one] -> Document ('Package pname ss) 'Nothing 'Nothing ('Just sub)
-> f (Document p 'Nothing 'Nothing ('Just sub))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Document ('Package pname ss) 'Nothing 'Nothing ('Just sub)
 -> f (Document p 'Nothing 'Nothing ('Just sub)))
-> Document ('Package pname ss) 'Nothing 'Nothing ('Just sub)
-> f (Document p 'Nothing 'Nothing ('Just sub))
forall a b. (a -> b) -> a -> b
$ OneMethodQuery ('Package pname ss) (LookupService ss sub)
-> Document ('Package pname ss) 'Nothing 'Nothing ('Just sub)
forall a mnm anm (ss :: [Service a mnm anm]) (sub :: a)
       (manns :: [*]) (mms :: [Method a mnm anm]) (pname :: Maybe a)
       (qr :: Maybe a) (mut :: Maybe a).
(LookupService ss sub ~ 'Service sub manns mms) =>
OneMethodQuery ('Package pname ss) (LookupService ss sub)
-> Document ('Package pname ss) qr mut ('Just sub)
SubscriptionDoc OneMethodQuery ('Package pname ss) (LookupService ss sub)
one
           _     -> Text -> f (Document p 'Nothing 'Nothing ('Just sub))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "subscriptions may only have one field"

instance
  ParseTypedDoc p 'Nothing 'Nothing 'Nothing where
  parseTypedDocQuery :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing 'Nothing 'Nothing)
parseTypedDocQuery _ _ _
    = Text -> f (Document p 'Nothing 'Nothing 'Nothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no queries are defined in the schema"
  parseTypedDocMutation :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing 'Nothing 'Nothing)
parseTypedDocMutation _ _ _
    = Text -> f (Document p 'Nothing 'Nothing 'Nothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no mutations are defined in the schema"
  parseTypedDocSubscription :: VariableMap
-> FragmentMap
-> SelectionSet
-> f (Document p 'Nothing 'Nothing 'Nothing)
parseTypedDocSubscription _ _ _
    = Text -> f (Document p 'Nothing 'Nothing 'Nothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "no subscriptions are defined in the schema"

parseVariableMap :: [GQL.VariableDefinition] -> VariableMapC
parseVariableMap :: [VariableDefinition] -> HashMap Text ValueConst
parseVariableMap vmap :: [VariableDefinition]
vmap
  = [(Text, ValueConst)] -> HashMap Text ValueConst
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(Name -> Text
GQL.unName (Variable -> Name
GQL.unVariable Variable
v), ValueConst
def)
                | GQL.VariableDefinition v :: Variable
v _ (Just def :: ValueConst
def) <- [VariableDefinition]
vmap]

constToValue :: GQL.ValueConst -> GQL.Value
constToValue :: ValueConst -> Value
constToValue (GQL.VCInt n :: Int32
n)     = Int32 -> Value
GQL.VInt Int32
n
constToValue (GQL.VCFloat n :: Double
n)   = Double -> Value
GQL.VFloat Double
n
constToValue (GQL.VCString n :: StringValue
n)  = StringValue -> Value
GQL.VString StringValue
n
constToValue (GQL.VCBoolean n :: Bool
n) = Bool -> Value
GQL.VBoolean Bool
n
constToValue GQL.VCNull        = Value
GQL.VNull
constToValue (GQL.VCEnum n :: EnumValue
n)    = EnumValue -> Value
GQL.VEnum EnumValue
n
constToValue (GQL.VCList (GQL.ListValueG n :: [ValueConst]
n))
  = ListValue -> Value
GQL.VList (ListValue -> Value) -> ListValue -> Value
forall a b. (a -> b) -> a -> b
$ [Value] -> ListValue
forall a. [a] -> ListValueG a
GQL.ListValueG ([Value] -> ListValue) -> [Value] -> ListValue
forall a b. (a -> b) -> a -> b
$ ValueConst -> Value
constToValue (ValueConst -> Value) -> [ValueConst] -> [Value]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ValueConst]
n
constToValue (GQL.VCObject (GQL.ObjectValueG n :: [ObjectFieldG ValueConst]
n))
  = ObjectValue -> Value
GQL.VObject (ObjectValue -> Value) -> ObjectValue -> Value
forall a b. (a -> b) -> a -> b
$ [ObjectFieldG Value] -> ObjectValue
forall a. [ObjectFieldG a] -> ObjectValueG a
GQL.ObjectValueG
      [ Name -> Value -> ObjectFieldG Value
forall a. Name -> a -> ObjectFieldG a
GQL.ObjectFieldG Name
a (ValueConst -> Value
constToValue ValueConst
v) | GQL.ObjectFieldG a :: Name
a v :: ValueConst
v <- [ObjectFieldG ValueConst]
n ]

parseQuery ::
  forall (p :: Package') (s :: Symbol) pname ss sanns methods f.
  ( MonadError T.Text f, p ~ 'Package pname ss,
    LookupService ss s ~ 'Service s sanns methods,
    KnownName s, ParseMethod p methods
  ) =>
  Proxy p ->
  Proxy s ->
  VariableMap -> FragmentMap -> GQL.SelectionSet ->
  f (ServiceQuery p (LookupService ss s))
parseQuery :: Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery _ _ _ _ [] = [OneMethodQuery ('Package pname ss) ('Service s sanns methods)]
-> f [OneMethodQuery
        ('Package pname ss) ('Service s sanns methods)]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
parseQuery pp :: Proxy p
pp ps :: Proxy s
ps vmap :: VariableMap
vmap frmap :: FragmentMap
frmap (GQL.SelectionField fld :: Field
fld : ss :: SelectionSet
ss)
  = [OneMethodQuery p ('Service s sanns methods)]
-> [OneMethodQuery p ('Service s sanns methods)]
-> [OneMethodQuery p ('Service s sanns methods)]
forall a. [a] -> [a] -> [a]
(++) ([OneMethodQuery p ('Service s sanns methods)]
 -> [OneMethodQuery p ('Service s sanns methods)]
 -> [OneMethodQuery p ('Service s sanns methods)])
-> f [OneMethodQuery p ('Service s sanns methods)]
-> f ([OneMethodQuery p ('Service s sanns methods)]
      -> [OneMethodQuery p ('Service s sanns methods)])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe (OneMethodQuery p ('Service s sanns methods))
-> [OneMethodQuery p ('Service s sanns methods)]
forall a. Maybe a -> [a]
maybeToList (Maybe (OneMethodQuery p ('Service s sanns methods))
 -> [OneMethodQuery p ('Service s sanns methods)])
-> f (Maybe (OneMethodQuery p ('Service s sanns methods)))
-> f [OneMethodQuery p ('Service s sanns methods)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> f (Maybe (OneMethodQuery p ('Service s sanns methods)))
forall (sname :: Symbol).
Field
-> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
fieldToMethod Field
fld)
         f ([OneMethodQuery p ('Service s sanns methods)]
   -> [OneMethodQuery p ('Service s sanns methods)])
-> f [OneMethodQuery p ('Service s sanns methods)]
-> f [OneMethodQuery p ('Service s sanns methods)]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy p
pp Proxy s
ps VariableMap
vmap FragmentMap
frmap SelectionSet
ss
  where
    fieldToMethod :: GQL.Field -> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
    fieldToMethod :: Field
-> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
fieldToMethod (GQL.Field alias :: Maybe Alias
alias name :: Name
name args :: [Argument]
args dirs :: [Directive]
dirs sels :: SelectionSet
sels)
      | (Directive -> Bool) -> [Directive] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (VariableMap -> Directive -> Bool
shouldSkip VariableMap
vmap) [Directive]
dirs
      = Maybe (OneMethodQuery p ('Service sname sanns methods))
-> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (OneMethodQuery p ('Service sname sanns methods))
forall a. Maybe a
Nothing
      | Name -> Text
GQL.unName Name
name Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "__typename"
      = case ([Argument]
args, SelectionSet
sels) of
          ([], []) -> Maybe (OneMethodQuery p ('Service sname sanns methods))
-> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (OneMethodQuery p ('Service sname sanns methods))
 -> f (Maybe (OneMethodQuery p ('Service sname sanns methods))))
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
-> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall a b. (a -> b) -> a -> b
$ OneMethodQuery p ('Service sname sanns methods)
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
forall a. a -> Maybe a
Just (OneMethodQuery p ('Service sname sanns methods)
 -> Maybe (OneMethodQuery p ('Service sname sanns methods)))
-> OneMethodQuery p ('Service sname sanns methods)
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
forall a b. (a -> b) -> a -> b
$ Maybe Text -> OneMethodQuery p ('Service sname sanns methods)
forall snm mnm anm (p :: Package snm mnm anm) (anns :: snm)
       (anns :: [*]) (nm :: [Method snm mnm anm]).
Maybe Text -> OneMethodQuery p ('Service anns anns nm)
TypeNameQuery (Maybe Text -> OneMethodQuery p ('Service sname sanns methods))
-> Maybe Text -> OneMethodQuery p ('Service sname sanns methods)
forall a b. (a -> b) -> a -> b
$ Name -> Text
GQL.unName (Name -> Text) -> (Alias -> Name) -> Alias -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alias -> Name
GQL.unAlias (Alias -> Text) -> Maybe Alias -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Alias
alias
          _        -> Text -> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "__typename does not admit arguments nor selection of subfields"
      | Name -> Text
GQL.unName Name
name Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "__schema"
      = case [Argument]
args of
          [] -> OneMethodQuery p ('Service sname sanns methods)
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
forall a. a -> Maybe a
Just (OneMethodQuery p ('Service sname sanns methods)
 -> Maybe (OneMethodQuery p ('Service sname sanns methods)))
-> (SelectionSet
    -> OneMethodQuery p ('Service sname sanns methods))
-> SelectionSet
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Text
-> SelectionSet -> OneMethodQuery p ('Service sname sanns methods)
forall snm mnm anm (p :: Package snm mnm anm) (nm :: snm)
       (anns :: [*]) (nm :: [Method snm mnm anm]).
Maybe Text
-> SelectionSet -> OneMethodQuery p ('Service nm anns nm)
SchemaQuery (Name -> Text
GQL.unName (Name -> Text) -> (Alias -> Name) -> Alias -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alias -> Name
GQL.unAlias (Alias -> Text) -> Maybe Alias -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Alias
alias) (SelectionSet
 -> Maybe (OneMethodQuery p ('Service sname sanns methods)))
-> f SelectionSet
-> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FragmentMap -> SelectionSet -> f SelectionSet
forall (f :: * -> *).
MonadError Text f =>
FragmentMap -> SelectionSet -> f SelectionSet
unFragment FragmentMap
frmap SelectionSet
sels
          _  -> Text -> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "__schema does not admit selection of subfields"
      | Name -> Text
GQL.unName Name
name Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "__type"
      = let alias' :: Maybe Text
alias' = Name -> Text
GQL.unName (Name -> Text) -> (Alias -> Name) -> Alias -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alias -> Name
GQL.unAlias (Alias -> Text) -> Maybe Alias -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Alias
alias
            getString :: Value -> Maybe Text
getString (GQL.VString s :: StringValue
s)   = Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ StringValue -> Text
forall a b. Coercible a b => a -> b
coerce StringValue
s
            getString (GQL.VVariable v :: Variable
v) = Text -> VariableMap -> Maybe Value
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup (Variable -> Text
forall a b. Coercible a b => a -> b
coerce Variable
v) VariableMap
vmap Maybe Value -> (Value -> Maybe Text) -> Maybe Text
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Value -> Maybe Text
getString
            getString _                 = Maybe Text
forall a. Maybe a
Nothing
        in case [Argument]
args of
          [GQL.Argument _ val :: Value
val]
            -> case Value -> Maybe Text
getString Value
val of
                 Just s :: Text
s -> OneMethodQuery p ('Service sname sanns methods)
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
forall a. a -> Maybe a
Just (OneMethodQuery p ('Service sname sanns methods)
 -> Maybe (OneMethodQuery p ('Service sname sanns methods)))
-> (SelectionSet
    -> OneMethodQuery p ('Service sname sanns methods))
-> SelectionSet
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Text
-> Text
-> SelectionSet
-> OneMethodQuery p ('Service sname sanns methods)
forall snm mnm anm (p :: Package snm mnm anm) (nm :: snm)
       (anns :: [*]) (ms :: [Method snm mnm anm]).
Maybe Text
-> Text -> SelectionSet -> OneMethodQuery p ('Service nm anns ms)
TypeQuery Maybe Text
alias' Text
s (SelectionSet
 -> Maybe (OneMethodQuery p ('Service sname sanns methods)))
-> f SelectionSet
-> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FragmentMap -> SelectionSet -> f SelectionSet
forall (f :: * -> *).
MonadError Text f =>
FragmentMap -> SelectionSet -> f SelectionSet
unFragment FragmentMap
frmap SelectionSet
sels
                 _      -> Text -> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "__type requires a string argument"
          _ -> Text -> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "__type requires one single argument"
      | Bool
otherwise
      = OneMethodQuery p ('Service sname sanns methods)
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
forall a. a -> Maybe a
Just (OneMethodQuery p ('Service sname sanns methods)
 -> Maybe (OneMethodQuery p ('Service sname sanns methods)))
-> (NS (ChosenMethodQuery p) methods
    -> OneMethodQuery p ('Service sname sanns methods))
-> NS (ChosenMethodQuery p) methods
-> Maybe (OneMethodQuery p ('Service sname sanns methods))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Text
-> NS (ChosenMethodQuery p) methods
-> OneMethodQuery p ('Service sname sanns methods)
forall serviceName methodName argName
       (p :: Package serviceName methodName argName)
       (ms :: [Method serviceName methodName argName]) (nm :: serviceName)
       (anns :: [*]).
Maybe Text
-> NS (ChosenMethodQuery p) ms
-> OneMethodQuery p ('Service nm anns ms)
OneMethodQuery (Name -> Text
GQL.unName (Name -> Text) -> (Alias -> Name) -> Alias -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alias -> Name
GQL.unAlias (Alias -> Text) -> Maybe Alias -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Alias
alias)
         (NS (ChosenMethodQuery p) methods
 -> Maybe (OneMethodQuery p ('Service sname sanns methods)))
-> f (NS (ChosenMethodQuery p) methods)
-> f (Maybe (OneMethodQuery p ('Service sname sanns methods)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> VariableMap
-> FragmentMap
-> Name
-> [Argument]
-> SelectionSet
-> f (NS (ChosenMethodQuery p) methods)
forall (p :: Package') (ms :: [Method Symbol Symbol Symbol])
       (f :: * -> *).
(ParseMethod p ms, MonadError Text f) =>
Text
-> VariableMap
-> FragmentMap
-> Name
-> [Argument]
-> SelectionSet
-> f (NS (ChosenMethodQuery p) ms)
selectMethod (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy s -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy s
forall k (t :: k). Proxy t
Proxy @s)) VariableMap
vmap FragmentMap
frmap Name
name [Argument]
args SelectionSet
sels
parseQuery pp :: Proxy p
pp ps :: Proxy s
ps vmap :: VariableMap
vmap frmap :: FragmentMap
frmap (GQL.SelectionFragmentSpread (GQL.FragmentSpread nm :: Name
nm dirs :: [Directive]
dirs) : ss :: SelectionSet
ss)
  | Just fr :: FragmentDefinition
fr <- Text -> FragmentMap -> Maybe FragmentDefinition
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup (Name -> Text
GQL.unName Name
nm) FragmentMap
frmap
  = if Bool -> Bool
not ((Directive -> Bool) -> [Directive] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (VariableMap -> Directive -> Bool
shouldSkip VariableMap
vmap) [Directive]
dirs) Bool -> Bool -> Bool
&& Bool -> Bool
not ((Directive -> Bool) -> [Directive] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (VariableMap -> Directive -> Bool
shouldSkip VariableMap
vmap) ([Directive] -> Bool) -> [Directive] -> Bool
forall a b. (a -> b) -> a -> b
$ FragmentDefinition -> [Directive]
GQL._fdDirectives FragmentDefinition
fr)
       then [OneMethodQuery ('Package pname ss) ('Service s sanns methods)]
-> [OneMethodQuery ('Package pname ss) ('Service s sanns methods)]
-> [OneMethodQuery ('Package pname ss) ('Service s sanns methods)]
forall a. [a] -> [a] -> [a]
(++) ([OneMethodQuery ('Package pname ss) ('Service s sanns methods)]
 -> [OneMethodQuery ('Package pname ss) ('Service s sanns methods)]
 -> [OneMethodQuery ('Package pname ss) ('Service s sanns methods)])
-> f [OneMethodQuery
        ('Package pname ss) ('Service s sanns methods)]
-> f ([OneMethodQuery
         ('Package pname ss) ('Service s sanns methods)]
      -> [OneMethodQuery ('Package pname ss) ('Service s sanns methods)])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy p
pp Proxy s
ps VariableMap
vmap FragmentMap
frmap (FragmentDefinition -> SelectionSet
GQL._fdSelectionSet FragmentDefinition
fr)
                 f ([OneMethodQuery ('Package pname ss) ('Service s sanns methods)]
   -> [OneMethodQuery ('Package pname ss) ('Service s sanns methods)])
-> f [OneMethodQuery
        ('Package pname ss) ('Service s sanns methods)]
-> f [OneMethodQuery
        ('Package pname ss) ('Service s sanns methods)]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy p
pp Proxy s
ps VariableMap
vmap FragmentMap
frmap SelectionSet
ss
       else Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery Proxy p
pp Proxy s
ps VariableMap
vmap FragmentMap
frmap SelectionSet
ss
  | Bool
otherwise  -- the fragment definition was not found
  = Text -> f (ServiceQuery p (LookupService ss s))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ServiceQuery p (LookupService ss s)))
-> Text -> f (ServiceQuery p (LookupService ss s))
forall a b. (a -> b) -> a -> b
$ "fragment '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Name -> Text
GQL.unName Name
nm Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found"
parseQuery _ _ _ _ (_ : _)  -- Inline fragments are not yet supported
  = Text
-> f [OneMethodQuery
        ('Package pname ss) ('Service s sanns methods)]
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "inline fragments are not (yet) supported"

shouldSkip :: VariableMap -> GQL.Directive -> Bool
shouldSkip :: VariableMap -> Directive -> Bool
shouldSkip vmap :: VariableMap
vmap (GQL.Directive (Name -> Text
GQL.unName -> Text
nm) [GQL.Argument (Name -> Text
GQL.unName -> Text
ifn) v :: Value
v])
  | Text
nm Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "skip", Text
ifn Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "if"
  = case VariableMap
-> Text -> Value -> Either Text (FieldValue '[] ('TPrimitive Bool))
forall (sch :: Schema') (v :: FieldType Symbol) (f :: * -> *).
(ValueParser sch v, MonadError Text f) =>
VariableMap -> Text -> Value -> f (FieldValue sch v)
valueParser' @'[] @('TPrimitive Bool) VariableMap
vmap "" Value
v of
      Right (FPrimitive b :: t1
b) -> t1
Bool
b
      _                    -> Bool
False
  | Text
nm Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "include", Text
ifn Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "if"
  = case VariableMap
-> Text -> Value -> Either Text (FieldValue '[] ('TPrimitive Bool))
forall (sch :: Schema') (v :: FieldType Symbol) (f :: * -> *).
(ValueParser sch v, MonadError Text f) =>
VariableMap -> Text -> Value -> f (FieldValue sch v)
valueParser' @'[] @('TPrimitive Bool) VariableMap
vmap "" Value
v of
      Right (FPrimitive b :: t1
b) -> Bool -> Bool
not t1
Bool
b
      _                    -> Bool
False
shouldSkip _ _ = Bool
False

unFragment :: MonadError T.Text f
           => FragmentMap -> GQL.SelectionSet -> f GQL.SelectionSet
unFragment :: FragmentMap -> SelectionSet -> f SelectionSet
unFragment _ [] = SelectionSet -> f SelectionSet
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
unFragment frmap :: FragmentMap
frmap (GQL.SelectionFragmentSpread (GQL.FragmentSpread nm :: Name
nm _) : ss :: SelectionSet
ss)
  | Just fr :: FragmentDefinition
fr <- Text -> FragmentMap -> Maybe FragmentDefinition
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup (Name -> Text
GQL.unName Name
nm) FragmentMap
frmap
  = SelectionSet -> SelectionSet -> SelectionSet
forall a. [a] -> [a] -> [a]
(++) (SelectionSet -> SelectionSet -> SelectionSet)
-> f SelectionSet -> f (SelectionSet -> SelectionSet)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FragmentMap -> SelectionSet -> f SelectionSet
forall (f :: * -> *).
MonadError Text f =>
FragmentMap -> SelectionSet -> f SelectionSet
unFragment FragmentMap
frmap (FragmentDefinition -> SelectionSet
GQL._fdSelectionSet FragmentDefinition
fr)
         f (SelectionSet -> SelectionSet)
-> f SelectionSet -> f SelectionSet
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FragmentMap -> SelectionSet -> f SelectionSet
forall (f :: * -> *).
MonadError Text f =>
FragmentMap -> SelectionSet -> f SelectionSet
unFragment FragmentMap
frmap SelectionSet
ss
  | Bool
otherwise  -- the fragment definition was not found
  = Text -> f SelectionSet
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f SelectionSet) -> Text -> f SelectionSet
forall a b. (a -> b) -> a -> b
$ "fragment '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Name -> Text
GQL.unName Name
nm Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found"
unFragment frmap :: FragmentMap
frmap (GQL.SelectionField (GQL.Field al :: Maybe Alias
al nm :: Name
nm args :: [Argument]
args dir :: [Directive]
dir innerss :: SelectionSet
innerss) : ss :: SelectionSet
ss)
  = (:) (Selection -> SelectionSet -> SelectionSet)
-> f Selection -> f (SelectionSet -> SelectionSet)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Field -> Selection
GQL.SelectionField (Field -> Selection)
-> (SelectionSet -> Field) -> SelectionSet -> Selection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Alias
-> Name -> [Argument] -> [Directive] -> SelectionSet -> Field
GQL.Field Maybe Alias
al Name
nm [Argument]
args [Directive]
dir (SelectionSet -> Selection) -> f SelectionSet -> f Selection
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FragmentMap -> SelectionSet -> f SelectionSet
forall (f :: * -> *).
MonadError Text f =>
FragmentMap -> SelectionSet -> f SelectionSet
unFragment FragmentMap
frmap SelectionSet
innerss)
        f (SelectionSet -> SelectionSet)
-> f SelectionSet -> f SelectionSet
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FragmentMap -> SelectionSet -> f SelectionSet
forall (f :: * -> *).
MonadError Text f =>
FragmentMap -> SelectionSet -> f SelectionSet
unFragment FragmentMap
frmap SelectionSet
ss
unFragment _ _
  = Text -> f SelectionSet
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "inline fragments are not (yet) supported"

class ParseMethod (p :: Package') (ms :: [Method']) where
  selectMethod ::
    MonadError T.Text f =>
    T.Text ->
    VariableMap ->
    FragmentMap ->
    GQL.Name ->
    [GQL.Argument] ->
    GQL.SelectionSet ->
    f (NS (ChosenMethodQuery p) ms)

instance ParseMethod p '[] where
  selectMethod :: Text
-> VariableMap
-> FragmentMap
-> Name
-> [Argument]
-> SelectionSet
-> f (NS (ChosenMethodQuery p) '[])
selectMethod tyName :: Text
tyName _ _ (Name -> Text
GQL.unName -> Text
wanted) _ _
    = Text -> f (NS (ChosenMethodQuery p) '[])
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (NS (ChosenMethodQuery p) '[]))
-> Text -> f (NS (ChosenMethodQuery p) '[])
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
wanted Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found on type '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
tyName Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "'"
instance
  (KnownSymbol mname, ParseMethod p ms, ParseArgs p args, ParseDifferentReturn p r) =>
  ParseMethod p ('Method mname manns args r ': ms)
  where
  selectMethod :: Text
-> VariableMap
-> FragmentMap
-> Name
-> [Argument]
-> SelectionSet
-> f (NS (ChosenMethodQuery p) ('Method mname manns args r : ms))
selectMethod tyName :: Text
tyName vmap :: VariableMap
vmap frmap :: FragmentMap
frmap w :: Name
w@(Name -> Text
GQL.unName -> Text
wanted) args :: [Argument]
args sels :: SelectionSet
sels
    | Text
wanted Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
mname
    = ChosenMethodQuery p ('Method mname manns args r)
-> NS (ChosenMethodQuery p) ('Method mname manns args r : ms)
forall k (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (ChosenMethodQuery p ('Method mname manns args r)
 -> NS (ChosenMethodQuery p) ('Method mname manns args r : ms))
-> f (ChosenMethodQuery p ('Method mname manns args r))
-> f (NS (ChosenMethodQuery p) ('Method mname manns args r : ms))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (NP (ArgumentValue p) args
-> ReturnQuery p r
-> ChosenMethodQuery p ('Method mname manns args r)
forall serviceName mnm argName
       (p :: Package serviceName mnm argName)
       (args :: [Argument serviceName argName]) (r :: Return serviceName)
       (mname :: mnm) (anns :: [*]).
NP (ArgumentValue p) args
-> ReturnQuery p r
-> ChosenMethodQuery p ('Method mname anns args r)
ChosenMethodQuery (NP (ArgumentValue p) args
 -> ReturnQuery p r
 -> ChosenMethodQuery p ('Method mname manns args r))
-> f (NP (ArgumentValue p) args)
-> f (ReturnQuery p r
      -> ChosenMethodQuery p ('Method mname manns args r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> [Argument] -> f (NP (ArgumentValue p) args)
forall (p :: Package') (args :: [Argument']) (f :: * -> *).
(ParseArgs p args, MonadError Text f) =>
VariableMap -> [Argument] -> f (NP (ArgumentValue p) args)
parseArgs VariableMap
vmap [Argument]
args
                               f (ReturnQuery p r
   -> ChosenMethodQuery p ('Method mname manns args r))
-> f (ReturnQuery p r)
-> f (ChosenMethodQuery p ('Method mname manns args r))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery p r)
forall (p :: Package') (r :: Return Symbol) (f :: * -> *).
(ParseDifferentReturn p r, MonadError Text f) =>
VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery p r)
parseDiffReturn VariableMap
vmap FragmentMap
frmap Text
wanted SelectionSet
sels)
    | Bool
otherwise
    = NS (ChosenMethodQuery p) ms
-> NS (ChosenMethodQuery p) ('Method mname manns args r : ms)
forall k (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (NS (ChosenMethodQuery p) ms
 -> NS (ChosenMethodQuery p) ('Method mname manns args r : ms))
-> f (NS (ChosenMethodQuery p) ms)
-> f (NS (ChosenMethodQuery p) ('Method mname manns args r : ms))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> VariableMap
-> FragmentMap
-> Name
-> [Argument]
-> SelectionSet
-> f (NS (ChosenMethodQuery p) ms)
forall (p :: Package') (ms :: [Method Symbol Symbol Symbol])
       (f :: * -> *).
(ParseMethod p ms, MonadError Text f) =>
Text
-> VariableMap
-> FragmentMap
-> Name
-> [Argument]
-> SelectionSet
-> f (NS (ChosenMethodQuery p) ms)
selectMethod Text
tyName VariableMap
vmap FragmentMap
frmap Name
w [Argument]
args SelectionSet
sels
    where
      mname :: Text
mname = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy mname -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy mname
forall k (t :: k). Proxy t
Proxy @mname)

class ParseArgs (p :: Package') (args :: [Argument']) where
  parseArgs :: MonadError T.Text f
            => VariableMap
            -> [GQL.Argument]
            -> f (NP (ArgumentValue p) args)

instance ParseArgs p '[] where
  parseArgs :: VariableMap -> [Argument] -> f (NP (ArgumentValue p) '[])
parseArgs _ _ = NP (ArgumentValue p) '[] -> f (NP (ArgumentValue p) '[])
forall (f :: * -> *) a. Applicative f => a -> f a
pure NP (ArgumentValue p) '[]
forall k (a :: k -> *). NP a '[]
Nil
-- one single argument without name
instance ParseArg p a
         => ParseArgs p '[ 'ArgSingle 'Nothing anns a ] where
  parseArgs :: VariableMap
-> [Argument]
-> f (NP (ArgumentValue p) '[ 'ArgSingle 'Nothing anns a])
parseArgs vmap :: VariableMap
vmap [GQL.Argument _ x :: Value
x]
    = (\v :: ArgumentValue' p a
v -> ArgumentValue' p a -> ArgumentValue p ('ArgSingle 'Nothing anns a)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName) (aname :: Maybe anm) (r :: [*]).
ArgumentValue' p r -> ArgumentValue p ('ArgSingle aname r r)
ArgumentValue ArgumentValue' p a
v ArgumentValue p ('ArgSingle 'Nothing anns a)
-> NP (ArgumentValue p) '[]
-> NP (ArgumentValue p) '[ 'ArgSingle 'Nothing anns a]
forall k (a :: k -> *) (x :: k) (xs :: [k]).
a x -> NP a xs -> NP a (x : xs)
:* NP (ArgumentValue p) '[]
forall k (a :: k -> *). NP a '[]
Nil) (ArgumentValue' p a
 -> NP (ArgumentValue p) '[ 'ArgSingle 'Nothing anns a])
-> f (ArgumentValue' p a)
-> f (NP (ArgumentValue p) '[ 'ArgSingle 'Nothing anns a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (ArgumentValue' p a)
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg' VariableMap
vmap "arg" Value
x
  parseArgs _ _
    = Text -> f (NP (ArgumentValue p) '[ 'ArgSingle 'Nothing anns a])
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "this field receives one single argument"
instance ParseArg p a
         => ParseArgs p '[ 'ArgStream 'Nothing anns a ] where
  parseArgs :: VariableMap
-> [Argument]
-> f (NP (ArgumentValue p) '[ 'ArgStream 'Nothing anns a])
parseArgs vmap :: VariableMap
vmap [GQL.Argument _ x :: Value
x]
    = (\v :: ArgumentValue' p ('ListRef a)
v -> ArgumentValue' p ('ListRef a)
-> ArgumentValue p ('ArgStream 'Nothing anns a)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName) (aname :: Maybe anm) (anns :: [*]).
ArgumentValue' p ('ListRef r)
-> ArgumentValue p ('ArgStream aname anns r)
ArgumentStream ArgumentValue' p ('ListRef a)
v ArgumentValue p ('ArgStream 'Nothing anns a)
-> NP (ArgumentValue p) '[]
-> NP (ArgumentValue p) '[ 'ArgStream 'Nothing anns a]
forall k (a :: k -> *) (x :: k) (xs :: [k]).
a x -> NP a xs -> NP a (x : xs)
:* NP (ArgumentValue p) '[]
forall k (a :: k -> *). NP a '[]
Nil) (ArgumentValue' p ('ListRef a)
 -> NP (ArgumentValue p) '[ 'ArgStream 'Nothing anns a])
-> f (ArgumentValue' p ('ListRef a))
-> f (NP (ArgumentValue p) '[ 'ArgStream 'Nothing anns a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (ArgumentValue' p ('ListRef a))
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg' VariableMap
vmap "arg" Value
x
  parseArgs _ _
    = Text -> f (NP (ArgumentValue p) '[ 'ArgStream 'Nothing anns a])
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "this field receives one single argument"
-- more than one argument
instance (KnownName aname, ParseArg p a, ParseArgs p as, FindDefaultArgValue aanns)
         => ParseArgs p ('ArgSingle ('Just aname) aanns a ': as) where
  parseArgs :: VariableMap
-> [Argument]
-> f (NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
parseArgs vmap :: VariableMap
vmap args :: [Argument]
args
    = let aname :: Text
aname = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy aname -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy aname
forall k (t :: k). Proxy t
Proxy @aname)
      in case (Argument -> Bool) -> [Argument] -> Maybe Argument
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== Proxy aname -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy aname
forall k (t :: k). Proxy t
Proxy @aname)) (String -> Bool) -> (Argument -> String) -> Argument -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack (Text -> String) -> (Argument -> Text) -> Argument -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Text
GQL.unName (Name -> Text) -> (Argument -> Name) -> Argument -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Argument -> Name
GQL._aName) [Argument]
args of
        Just (GQL.Argument _ x :: Value
x)
          -> ArgumentValue p ('ArgSingle ('Just aname) aanns a)
-> NP (ArgumentValue p) as
-> NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as)
forall k (a :: k -> *) (x :: k) (xs :: [k]).
a x -> NP a xs -> NP a (x : xs)
(:*) (ArgumentValue p ('ArgSingle ('Just aname) aanns a)
 -> NP (ArgumentValue p) as
 -> NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
-> f (ArgumentValue p ('ArgSingle ('Just aname) aanns a))
-> f (NP (ArgumentValue p) as
      -> NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ArgumentValue' p a
-> ArgumentValue p ('ArgSingle ('Just aname) aanns a)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName) (aname :: Maybe anm) (r :: [*]).
ArgumentValue' p r -> ArgumentValue p ('ArgSingle aname r r)
ArgumentValue (ArgumentValue' p a
 -> ArgumentValue p ('ArgSingle ('Just aname) aanns a))
-> f (ArgumentValue' p a)
-> f (ArgumentValue p ('ArgSingle ('Just aname) aanns a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (ArgumentValue' p a)
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg' VariableMap
vmap Text
aname Value
x)
                  f (NP (ArgumentValue p) as
   -> NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
-> f (NP (ArgumentValue p) as)
-> f (NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> VariableMap -> [Argument] -> f (NP (ArgumentValue p) as)
forall (p :: Package') (args :: [Argument']) (f :: * -> *).
(ParseArgs p args, MonadError Text f) =>
VariableMap -> [Argument] -> f (NP (ArgumentValue p) args)
parseArgs VariableMap
vmap [Argument]
args
        Nothing
          -> do ValueConst
x <- Proxy aanns -> Text -> f ValueConst
forall (vs :: [*]) (f :: * -> *).
(FindDefaultArgValue vs, MonadError Text f) =>
Proxy vs -> Text -> f ValueConst
findDefaultArgValue (Proxy aanns
forall k (t :: k). Proxy t
Proxy @aanns) Text
aname
                ArgumentValue p ('ArgSingle ('Just aname) aanns a)
-> NP (ArgumentValue p) as
-> NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as)
forall k (a :: k -> *) (x :: k) (xs :: [k]).
a x -> NP a xs -> NP a (x : xs)
(:*) (ArgumentValue p ('ArgSingle ('Just aname) aanns a)
 -> NP (ArgumentValue p) as
 -> NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
-> f (ArgumentValue p ('ArgSingle ('Just aname) aanns a))
-> f (NP (ArgumentValue p) as
      -> NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ArgumentValue' p a
-> ArgumentValue p ('ArgSingle ('Just aname) aanns a)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName) (aname :: Maybe anm) (r :: [*]).
ArgumentValue' p r -> ArgumentValue p ('ArgSingle aname r r)
ArgumentValue (ArgumentValue' p a
 -> ArgumentValue p ('ArgSingle ('Just aname) aanns a))
-> f (ArgumentValue' p a)
-> f (ArgumentValue p ('ArgSingle ('Just aname) aanns a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (ArgumentValue' p a)
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg' VariableMap
vmap Text
aname (ValueConst -> Value
constToValue ValueConst
x))
                     f (NP (ArgumentValue p) as
   -> NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
-> f (NP (ArgumentValue p) as)
-> f (NP (ArgumentValue p) ('ArgSingle ('Just aname) aanns a : as))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> VariableMap -> [Argument] -> f (NP (ArgumentValue p) as)
forall (p :: Package') (args :: [Argument']) (f :: * -> *).
(ParseArgs p args, MonadError Text f) =>
VariableMap -> [Argument] -> f (NP (ArgumentValue p) args)
parseArgs VariableMap
vmap [Argument]
args
instance (KnownName aname, ParseArg p a, ParseArgs p as, FindDefaultArgValue aanns)
         => ParseArgs p ('ArgStream ('Just aname) aanns a ': as) where
  parseArgs :: VariableMap
-> [Argument]
-> f (NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
parseArgs vmap :: VariableMap
vmap args :: [Argument]
args
    = let aname :: Text
aname = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy aname -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy aname
forall k (t :: k). Proxy t
Proxy @aname)
      in case (Argument -> Bool) -> [Argument] -> Maybe Argument
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== Proxy aname -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy aname
forall k (t :: k). Proxy t
Proxy @aname)) (String -> Bool) -> (Argument -> String) -> Argument -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack (Text -> String) -> (Argument -> Text) -> Argument -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Text
GQL.unName (Name -> Text) -> (Argument -> Name) -> Argument -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Argument -> Name
GQL._aName) [Argument]
args of
        Just (GQL.Argument _ x :: Value
x)
          -> ArgumentValue p ('ArgStream ('Just aname) aanns a)
-> NP (ArgumentValue p) as
-> NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as)
forall k (a :: k -> *) (x :: k) (xs :: [k]).
a x -> NP a xs -> NP a (x : xs)
(:*) (ArgumentValue p ('ArgStream ('Just aname) aanns a)
 -> NP (ArgumentValue p) as
 -> NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
-> f (ArgumentValue p ('ArgStream ('Just aname) aanns a))
-> f (NP (ArgumentValue p) as
      -> NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ArgumentValue' p ('ListRef a)
-> ArgumentValue p ('ArgStream ('Just aname) aanns a)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName) (aname :: Maybe anm) (anns :: [*]).
ArgumentValue' p ('ListRef r)
-> ArgumentValue p ('ArgStream aname anns r)
ArgumentStream (ArgumentValue' p ('ListRef a)
 -> ArgumentValue p ('ArgStream ('Just aname) aanns a))
-> f (ArgumentValue' p ('ListRef a))
-> f (ArgumentValue p ('ArgStream ('Just aname) aanns a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (ArgumentValue' p ('ListRef a))
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg' VariableMap
vmap Text
aname Value
x)
                  f (NP (ArgumentValue p) as
   -> NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
-> f (NP (ArgumentValue p) as)
-> f (NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> VariableMap -> [Argument] -> f (NP (ArgumentValue p) as)
forall (p :: Package') (args :: [Argument']) (f :: * -> *).
(ParseArgs p args, MonadError Text f) =>
VariableMap -> [Argument] -> f (NP (ArgumentValue p) args)
parseArgs VariableMap
vmap [Argument]
args
        Nothing
          -> do ValueConst
x <- Proxy aanns -> Text -> f ValueConst
forall (vs :: [*]) (f :: * -> *).
(FindDefaultArgValue vs, MonadError Text f) =>
Proxy vs -> Text -> f ValueConst
findDefaultArgValue (Proxy aanns
forall k (t :: k). Proxy t
Proxy @aanns) Text
aname
                ArgumentValue p ('ArgStream ('Just aname) aanns a)
-> NP (ArgumentValue p) as
-> NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as)
forall k (a :: k -> *) (x :: k) (xs :: [k]).
a x -> NP a xs -> NP a (x : xs)
(:*) (ArgumentValue p ('ArgStream ('Just aname) aanns a)
 -> NP (ArgumentValue p) as
 -> NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
-> f (ArgumentValue p ('ArgStream ('Just aname) aanns a))
-> f (NP (ArgumentValue p) as
      -> NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ArgumentValue' p ('ListRef a)
-> ArgumentValue p ('ArgStream ('Just aname) aanns a)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName) (aname :: Maybe anm) (anns :: [*]).
ArgumentValue' p ('ListRef r)
-> ArgumentValue p ('ArgStream aname anns r)
ArgumentStream (ArgumentValue' p ('ListRef a)
 -> ArgumentValue p ('ArgStream ('Just aname) aanns a))
-> f (ArgumentValue' p ('ListRef a))
-> f (ArgumentValue p ('ArgStream ('Just aname) aanns a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (ArgumentValue' p ('ListRef a))
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg' VariableMap
vmap Text
aname (ValueConst -> Value
constToValue ValueConst
x))
                     f (NP (ArgumentValue p) as
   -> NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
-> f (NP (ArgumentValue p) as)
-> f (NP (ArgumentValue p) ('ArgStream ('Just aname) aanns a : as))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> VariableMap -> [Argument] -> f (NP (ArgumentValue p) as)
forall (p :: Package') (args :: [Argument']) (f :: * -> *).
(ParseArgs p args, MonadError Text f) =>
VariableMap -> [Argument] -> f (NP (ArgumentValue p) args)
parseArgs VariableMap
vmap [Argument]
args

class FindDefaultArgValue (vs :: [Type]) where
  findDefaultArgValue :: MonadError T.Text f
                      => Proxy vs
                      -> T.Text
                      -> f GQL.ValueConst
instance FindDefaultArgValue '[] where
  findDefaultArgValue :: Proxy '[] -> Text -> f ValueConst
findDefaultArgValue _ aname :: Text
aname
    = Text -> f ValueConst
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f ValueConst) -> Text -> f ValueConst
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not given a value, and has no default one"
instance {-# OVERLAPPABLE #-} FindDefaultArgValue xs
         => FindDefaultArgValue (x ': xs) where
  findDefaultArgValue :: Proxy (x : xs) -> Text -> f ValueConst
findDefaultArgValue _ = Proxy xs -> Text -> f ValueConst
forall (vs :: [*]) (f :: * -> *).
(FindDefaultArgValue vs, MonadError Text f) =>
Proxy vs -> Text -> f ValueConst
findDefaultArgValue (Proxy xs
forall k (t :: k). Proxy t
Proxy @xs)
instance {-# OVERLAPS #-} ReflectValueConst v
         => FindDefaultArgValue (DefaultValue v ': xs) where
  findDefaultArgValue :: Proxy (DefaultValue v : xs) -> Text -> f ValueConst
findDefaultArgValue _ _ = ValueConst -> f ValueConst
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValueConst -> f ValueConst) -> ValueConst -> f ValueConst
forall a b. (a -> b) -> a -> b
$ Proxy v -> ValueConst
forall nat symbol (v :: ValueConst nat symbol)
       (proxy :: ValueConst nat symbol -> *).
ReflectValueConst v =>
proxy v -> ValueConst
reflectValueConst (Proxy v
forall k (t :: k). Proxy t
Proxy @v)

parseArg' :: (ParseArg p a, MonadError T.Text f)
          => VariableMap
          -> T.Text
          -> GQL.Value
          -> f (ArgumentValue' p a)
parseArg' :: VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg' vmap :: VariableMap
vmap aname :: Text
aname (GQL.VVariable (Name -> Text
GQL.unName (Name -> Text) -> (Variable -> Name) -> Variable -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Variable -> Name
GQL.unVariable -> Text
x))
  = case Text -> VariableMap -> Maybe Value
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup Text
x VariableMap
vmap of
      Nothing -> Text -> f (ArgumentValue' p a)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p a)) -> Text -> f (ArgumentValue' p a)
forall a b. (a -> b) -> a -> b
$ "variable '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found"
      Just v :: Value
v  -> VariableMap -> Text -> Value -> f (ArgumentValue' p a)
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg VariableMap
vmap Text
aname Value
v
parseArg' vmap :: VariableMap
vmap aname :: Text
aname v :: Value
v = VariableMap -> Text -> Value -> f (ArgumentValue' p a)
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg VariableMap
vmap Text
aname Value
v

class ParseArg (p :: Package') (a :: TypeRef Symbol) where
  parseArg :: MonadError T.Text f
           => VariableMap
           -> T.Text
           -> GQL.Value
           -> f (ArgumentValue' p a)

instance (ParseArg p r) => ParseArg p ('ListRef r) where
  parseArg :: VariableMap -> Text -> Value -> f (ArgumentValue' p ('ListRef r))
parseArg vmap :: VariableMap
vmap aname :: Text
aname (GQL.VList (GQL.ListValueG xs :: [Value]
xs))
    = [ArgumentValue' p r] -> ArgumentValue' p ('ListRef r)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName).
[ArgumentValue' p r] -> ArgumentValue' p ('ListRef r)
ArgList ([ArgumentValue' p r] -> ArgumentValue' p ('ListRef r))
-> f [ArgumentValue' p r] -> f (ArgumentValue' p ('ListRef r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> f (ArgumentValue' p r))
-> [Value] -> f [ArgumentValue' p r]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (VariableMap -> Text -> Value -> f (ArgumentValue' p r)
forall (p :: Package') (a :: TypeRef Symbol) (f :: * -> *).
(ParseArg p a, MonadError Text f) =>
VariableMap -> Text -> Value -> f (ArgumentValue' p a)
parseArg' VariableMap
vmap Text
aname) [Value]
xs
  parseArg _ aname :: Text
aname _
    = Text -> f (ArgumentValue' p ('ListRef r))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p ('ListRef r)))
-> Text -> f (ArgumentValue' p ('ListRef r))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ParseArg p ('PrimitiveRef Bool) where
  parseArg :: VariableMap
-> Text -> Value -> f (ArgumentValue' p ('PrimitiveRef Bool))
parseArg _ _ (GQL.VBoolean b :: Bool
b)
    = ArgumentValue' p ('PrimitiveRef Bool)
-> f (ArgumentValue' p ('PrimitiveRef Bool))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> ArgumentValue' p ('PrimitiveRef Bool)
forall snm mnm anm t (p :: Package snm mnm anm).
t -> ArgumentValue' p ('PrimitiveRef t)
ArgPrimitive Bool
b)
  parseArg _ aname :: Text
aname _
    = Text -> f (ArgumentValue' p ('PrimitiveRef Bool))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p ('PrimitiveRef Bool)))
-> Text -> f (ArgumentValue' p ('PrimitiveRef Bool))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ParseArg p ('PrimitiveRef Int32) where
  parseArg :: VariableMap
-> Text -> Value -> f (ArgumentValue' p ('PrimitiveRef Int32))
parseArg _ _ (GQL.VInt b :: Int32
b)
    = ArgumentValue' p ('PrimitiveRef Int32)
-> f (ArgumentValue' p ('PrimitiveRef Int32))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int32 -> ArgumentValue' p ('PrimitiveRef Int32)
forall snm mnm anm t (p :: Package snm mnm anm).
t -> ArgumentValue' p ('PrimitiveRef t)
ArgPrimitive Int32
b)
  parseArg _ aname :: Text
aname _
    = Text -> f (ArgumentValue' p ('PrimitiveRef Int32))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p ('PrimitiveRef Int32)))
-> Text -> f (ArgumentValue' p ('PrimitiveRef Int32))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ParseArg p ('PrimitiveRef Integer) where
  parseArg :: VariableMap
-> Text -> Value -> f (ArgumentValue' p ('PrimitiveRef Integer))
parseArg _ _ (GQL.VInt b :: Int32
b)
    = ArgumentValue' p ('PrimitiveRef Integer)
-> f (ArgumentValue' p ('PrimitiveRef Integer))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ArgumentValue' p ('PrimitiveRef Integer)
 -> f (ArgumentValue' p ('PrimitiveRef Integer)))
-> ArgumentValue' p ('PrimitiveRef Integer)
-> f (ArgumentValue' p ('PrimitiveRef Integer))
forall a b. (a -> b) -> a -> b
$ Integer -> ArgumentValue' p ('PrimitiveRef Integer)
forall snm mnm anm t (p :: Package snm mnm anm).
t -> ArgumentValue' p ('PrimitiveRef t)
ArgPrimitive (Integer -> ArgumentValue' p ('PrimitiveRef Integer))
-> Integer -> ArgumentValue' p ('PrimitiveRef Integer)
forall a b. (a -> b) -> a -> b
$ Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
b
  parseArg _ aname :: Text
aname _
    = Text -> f (ArgumentValue' p ('PrimitiveRef Integer))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p ('PrimitiveRef Integer)))
-> Text -> f (ArgumentValue' p ('PrimitiveRef Integer))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ParseArg p ('PrimitiveRef Double) where
  parseArg :: VariableMap
-> Text -> Value -> f (ArgumentValue' p ('PrimitiveRef Double))
parseArg _ _ (GQL.VFloat b :: Double
b)
    = ArgumentValue' p ('PrimitiveRef Double)
-> f (ArgumentValue' p ('PrimitiveRef Double))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> ArgumentValue' p ('PrimitiveRef Double)
forall snm mnm anm t (p :: Package snm mnm anm).
t -> ArgumentValue' p ('PrimitiveRef t)
ArgPrimitive Double
b)
  parseArg _ aname :: Text
aname _
    = Text -> f (ArgumentValue' p ('PrimitiveRef Double))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p ('PrimitiveRef Double)))
-> Text -> f (ArgumentValue' p ('PrimitiveRef Double))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ParseArg p ('PrimitiveRef T.Text) where
  parseArg :: VariableMap
-> Text -> Value -> f (ArgumentValue' p ('PrimitiveRef Text))
parseArg _ _ (GQL.VString (GQL.StringValue b :: Text
b))
    = ArgumentValue' p ('PrimitiveRef Text)
-> f (ArgumentValue' p ('PrimitiveRef Text))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ArgumentValue' p ('PrimitiveRef Text)
 -> f (ArgumentValue' p ('PrimitiveRef Text)))
-> ArgumentValue' p ('PrimitiveRef Text)
-> f (ArgumentValue' p ('PrimitiveRef Text))
forall a b. (a -> b) -> a -> b
$ Text -> ArgumentValue' p ('PrimitiveRef Text)
forall snm mnm anm t (p :: Package snm mnm anm).
t -> ArgumentValue' p ('PrimitiveRef t)
ArgPrimitive Text
b
  parseArg _ aname :: Text
aname _
    = Text -> f (ArgumentValue' p ('PrimitiveRef Text))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p ('PrimitiveRef Text)))
-> Text -> f (ArgumentValue' p ('PrimitiveRef Text))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ParseArg p ('PrimitiveRef String) where
  parseArg :: VariableMap
-> Text -> Value -> f (ArgumentValue' p ('PrimitiveRef String))
parseArg _ _ (GQL.VString (GQL.StringValue b :: Text
b))
    = ArgumentValue' p ('PrimitiveRef String)
-> f (ArgumentValue' p ('PrimitiveRef String))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ArgumentValue' p ('PrimitiveRef String)
 -> f (ArgumentValue' p ('PrimitiveRef String)))
-> ArgumentValue' p ('PrimitiveRef String)
-> f (ArgumentValue' p ('PrimitiveRef String))
forall a b. (a -> b) -> a -> b
$ String -> ArgumentValue' p ('PrimitiveRef String)
forall snm mnm anm t (p :: Package snm mnm anm).
t -> ArgumentValue' p ('PrimitiveRef t)
ArgPrimitive (String -> ArgumentValue' p ('PrimitiveRef String))
-> String -> ArgumentValue' p ('PrimitiveRef String)
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
b
  parseArg _ aname :: Text
aname _
    = Text -> f (ArgumentValue' p ('PrimitiveRef String))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p ('PrimitiveRef String)))
-> Text -> f (ArgumentValue' p ('PrimitiveRef String))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ParseArg p ('PrimitiveRef ()) where
  parseArg :: VariableMap
-> Text -> Value -> f (ArgumentValue' p ('PrimitiveRef ()))
parseArg _ _ GQL.VNull = ArgumentValue' p ('PrimitiveRef ())
-> f (ArgumentValue' p ('PrimitiveRef ()))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ArgumentValue' p ('PrimitiveRef ())
 -> f (ArgumentValue' p ('PrimitiveRef ())))
-> ArgumentValue' p ('PrimitiveRef ())
-> f (ArgumentValue' p ('PrimitiveRef ()))
forall a b. (a -> b) -> a -> b
$ () -> ArgumentValue' p ('PrimitiveRef ())
forall snm mnm anm t (p :: Package snm mnm anm).
t -> ArgumentValue' p ('PrimitiveRef t)
ArgPrimitive ()
  parseArg _ aname :: Text
aname _
    = Text -> f (ArgumentValue' p ('PrimitiveRef ()))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ArgumentValue' p ('PrimitiveRef ())))
-> Text -> f (ArgumentValue' p ('PrimitiveRef ()))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance (ObjectOrEnumParser sch (sch :/: sty))
         => ParseArg p ('SchemaRef sch sty) where
  parseArg :: VariableMap
-> Text -> Value -> f (ArgumentValue' p ('SchemaRef sch sty))
parseArg vmap :: VariableMap
vmap aname :: Text
aname v :: Value
v
    = Term sch (sch :/: sty) -> ArgumentValue' p ('SchemaRef sch sty)
forall typeName fieldName snm mnm anm
       (sch :: Schema typeName fieldName) (sty :: typeName)
       (p :: Package snm mnm anm).
Term sch (sch :/: sty) -> ArgumentValue' p ('SchemaRef sch sty)
ArgSchema (Term sch (sch :/: sty) -> ArgumentValue' p ('SchemaRef sch sty))
-> f (Term sch (sch :/: sty))
-> f (ArgumentValue' p ('SchemaRef sch sty))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (Term sch (sch :/: sty))
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (f :: * -> *).
(ObjectOrEnumParser sch t, MonadError Text f) =>
VariableMap -> Text -> Value -> f (Term sch t)
parseObjectOrEnum' VariableMap
vmap Text
aname Value
v

parseObjectOrEnum' :: (ObjectOrEnumParser sch t, MonadError T.Text f)
          => VariableMap
          -> T.Text
          -> GQL.Value
          -> f (Term sch t)
parseObjectOrEnum' :: VariableMap -> Text -> Value -> f (Term sch t)
parseObjectOrEnum' vmap :: VariableMap
vmap aname :: Text
aname (GQL.VVariable (Name -> Text
GQL.unName (Name -> Text) -> (Variable -> Name) -> Variable -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Variable -> Name
GQL.unVariable -> Text
x))
  = case Text -> VariableMap -> Maybe Value
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup Text
x VariableMap
vmap of
      Nothing -> Text -> f (Term sch t)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (Term sch t)) -> Text -> f (Term sch t)
forall a b. (a -> b) -> a -> b
$ "variable '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found"
      Just v :: Value
v  -> VariableMap -> Text -> Value -> f (Term sch t)
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (f :: * -> *).
(ObjectOrEnumParser sch t, MonadError Text f) =>
VariableMap -> Text -> Value -> f (Term sch t)
parseObjectOrEnum VariableMap
vmap Text
aname Value
v
parseObjectOrEnum' vmap :: VariableMap
vmap aname :: Text
aname v :: Value
v
  = VariableMap -> Text -> Value -> f (Term sch t)
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (f :: * -> *).
(ObjectOrEnumParser sch t, MonadError Text f) =>
VariableMap -> Text -> Value -> f (Term sch t)
parseObjectOrEnum VariableMap
vmap Text
aname Value
v

class ObjectOrEnumParser (sch :: Schema') (t :: TypeDef Symbol Symbol) where
  parseObjectOrEnum :: MonadError T.Text f
                    => VariableMap
                    -> T.Text
                    -> GQL.Value
                    -> f (Term sch t)

instance (ObjectParser sch args, KnownName name)
         => ObjectOrEnumParser sch ('DRecord name args) where
  parseObjectOrEnum :: VariableMap -> Text -> Value -> f (Term sch ('DRecord name args))
parseObjectOrEnum vmap :: VariableMap
vmap _ (GQL.VObject (GQL.ObjectValueG vs :: [ObjectFieldG Value]
vs))
    = NP (Field sch) args -> Term sch ('DRecord name args)
forall typeName fieldName (sch :: Schema typeName fieldName)
       (args :: [FieldDef typeName fieldName]) (name :: typeName).
NP (Field sch) args -> Term sch ('DRecord name args)
TRecord (NP (Field sch) args -> Term sch ('DRecord name args))
-> f (NP (Field sch) args) -> f (Term sch ('DRecord name args))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> Text -> [ObjectFieldG Value] -> f (NP (Field sch) args)
forall (sch :: Schema') (args :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(ObjectParser sch args, MonadError Text f) =>
VariableMap
-> Text -> [ObjectFieldG Value] -> f (NP (Field sch) args)
objectParser VariableMap
vmap (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy name -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy name
forall k (t :: k). Proxy t
Proxy @name)) [ObjectFieldG Value]
vs
  parseObjectOrEnum _ aname :: Text
aname _
    = Text -> f (Term sch ('DRecord name args))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (Term sch ('DRecord name args)))
-> Text -> f (Term sch ('DRecord name args))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance (EnumParser choices, KnownName name)
         => ObjectOrEnumParser sch ('DEnum name choices) where
  parseObjectOrEnum :: VariableMap -> Text -> Value -> f (Term sch ('DEnum name choices))
parseObjectOrEnum _ _ (GQL.VEnum (GQL.EnumValue nm :: Name
nm))
    = NS Proxy choices -> Term sch ('DEnum name choices)
forall fieldName typeName (choices :: [ChoiceDef fieldName])
       (sch :: Schema typeName fieldName) (name :: typeName).
NS Proxy choices -> Term sch ('DEnum name choices)
TEnum (NS Proxy choices -> Term sch ('DEnum name choices))
-> f (NS Proxy choices) -> f (Term sch ('DEnum name choices))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Name -> f (NS Proxy choices)
forall (choices :: [ChoiceDef Symbol]) (f :: * -> *).
(EnumParser choices, MonadError Text f) =>
Text -> Name -> f (NS Proxy choices)
enumParser (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy name -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy name
forall k (t :: k). Proxy t
Proxy @name)) Name
nm
  parseObjectOrEnum _ aname :: Text
aname _
    = Text -> f (Term sch ('DEnum name choices))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (Term sch ('DEnum name choices)))
-> Text -> f (Term sch ('DEnum name choices))
forall a b. (a -> b) -> a -> b
$ "argument '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
aname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"

class ObjectParser (sch :: Schema') (args :: [FieldDef Symbol Symbol]) where
  objectParser :: MonadError T.Text f
               => VariableMap
               -> T.Text
               -> [GQL.ObjectFieldG GQL.Value]
               -> f (NP (Field sch) args)

instance ObjectParser sch '[] where
  objectParser :: VariableMap
-> Text -> [ObjectFieldG Value] -> f (NP (Field sch) '[])
objectParser _ _ _ = NP (Field sch) '[] -> f (NP (Field sch) '[])
forall (f :: * -> *) a. Applicative f => a -> f a
pure NP (Field sch) '[]
forall k (a :: k -> *). NP a '[]
Nil
instance
  (ObjectParser sch args, ValueParser sch v, KnownName nm) =>
  ObjectParser sch ('FieldDef nm v ': args)
  where
  objectParser :: VariableMap
-> Text
-> [ObjectFieldG Value]
-> f (NP (Field sch) ('FieldDef nm v : args))
objectParser vmap :: VariableMap
vmap tyName :: Text
tyName args :: [ObjectFieldG Value]
args
    = let wanted :: Text
wanted = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy nm -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy nm
forall k (t :: k). Proxy t
Proxy @nm)
      in case (ObjectFieldG Value -> Bool)
-> [ObjectFieldG Value] -> Maybe (ObjectFieldG Value)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
wanted) (Text -> Bool)
-> (ObjectFieldG Value -> Text) -> ObjectFieldG Value -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Text
GQL.unName (Name -> Text)
-> (ObjectFieldG Value -> Name) -> ObjectFieldG Value -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectFieldG Value -> Name
forall a. ObjectFieldG a -> Name
GQL._ofName) [ObjectFieldG Value]
args of
        Just (GQL.ObjectFieldG _ v :: Value
v)
          -> Field sch ('FieldDef nm v)
-> NP (Field sch) args -> NP (Field sch) ('FieldDef nm v : args)
forall k (a :: k -> *) (x :: k) (xs :: [k]).
a x -> NP a xs -> NP a (x : xs)
(:*) (Field sch ('FieldDef nm v)
 -> NP (Field sch) args -> NP (Field sch) ('FieldDef nm v : args))
-> f (Field sch ('FieldDef nm v))
-> f (NP (Field sch) args
      -> NP (Field sch) ('FieldDef nm v : args))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldValue sch v -> Field sch ('FieldDef nm v)
forall typeName fieldName (sch :: Schema typeName fieldName)
       (t :: FieldType typeName) (name :: fieldName).
FieldValue sch t -> Field sch ('FieldDef name t)
Field (FieldValue sch v -> Field sch ('FieldDef nm v))
-> f (FieldValue sch v) -> f (Field sch ('FieldDef nm v))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (FieldValue sch v)
forall (sch :: Schema') (v :: FieldType Symbol) (f :: * -> *).
(ValueParser sch v, MonadError Text f) =>
VariableMap -> Text -> Value -> f (FieldValue sch v)
valueParser' VariableMap
vmap Text
wanted Value
v) f (NP (Field sch) args -> NP (Field sch) ('FieldDef nm v : args))
-> f (NP (Field sch) args)
-> f (NP (Field sch) ('FieldDef nm v : args))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> VariableMap
-> Text -> [ObjectFieldG Value] -> f (NP (Field sch) args)
forall (sch :: Schema') (args :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(ObjectParser sch args, MonadError Text f) =>
VariableMap
-> Text -> [ObjectFieldG Value] -> f (NP (Field sch) args)
objectParser VariableMap
vmap Text
tyName [ObjectFieldG Value]
args
        Nothing -> Text -> f (NP (Field sch) ('FieldDef nm v : args))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (NP (Field sch) ('FieldDef nm v : args)))
-> Text -> f (NP (Field sch) ('FieldDef nm v : args))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
wanted Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found on type '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
tyName Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "'"

class EnumParser (choices :: [ChoiceDef Symbol]) where
  enumParser :: MonadError T.Text f
             => T.Text -> GQL.Name
             -> f (NS Proxy choices)

instance EnumParser '[] where
  enumParser :: Text -> Name -> f (NS Proxy '[])
enumParser tyName :: Text
tyName (Name -> Text
GQL.unName -> Text
wanted)
    = Text -> f (NS Proxy '[])
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (NS Proxy '[])) -> Text -> f (NS Proxy '[])
forall a b. (a -> b) -> a -> b
$ "value '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
wanted Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found on enum '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
tyName Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "'"
instance (KnownName name, EnumParser choices)
         => EnumParser ('ChoiceDef name ': choices) where
  enumParser :: Text -> Name -> f (NS Proxy ('ChoiceDef name : choices))
enumParser tyName :: Text
tyName w :: Name
w@(Name -> Text
GQL.unName -> Text
wanted)
    | Text
wanted Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
mname = NS Proxy ('ChoiceDef name : choices)
-> f (NS Proxy ('ChoiceDef name : choices))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Proxy ('ChoiceDef name) -> NS Proxy ('ChoiceDef name : choices)
forall k (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z Proxy ('ChoiceDef name)
forall k (t :: k). Proxy t
Proxy)
    | Bool
otherwise = NS Proxy choices -> NS Proxy ('ChoiceDef name : choices)
forall k (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (NS Proxy choices -> NS Proxy ('ChoiceDef name : choices))
-> f (NS Proxy choices) -> f (NS Proxy ('ChoiceDef name : choices))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Name -> f (NS Proxy choices)
forall (choices :: [ChoiceDef Symbol]) (f :: * -> *).
(EnumParser choices, MonadError Text f) =>
Text -> Name -> f (NS Proxy choices)
enumParser Text
tyName Name
w
    where
      mname :: Text
mname = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy name -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy name
forall k (t :: k). Proxy t
Proxy @name)

valueParser' :: (ValueParser sch v, MonadError T.Text f)
             => VariableMap
             -> T.Text
             -> GQL.Value
             -> f (FieldValue sch v)
valueParser' :: VariableMap -> Text -> Value -> f (FieldValue sch v)
valueParser' vmap :: VariableMap
vmap aname :: Text
aname (GQL.VVariable (Name -> Text
GQL.unName (Name -> Text) -> (Variable -> Name) -> Variable -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Variable -> Name
GQL.unVariable -> Text
x))
  = case Text -> VariableMap -> Maybe Value
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup Text
x VariableMap
vmap of
      Nothing -> Text -> f (FieldValue sch v)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch v)) -> Text -> f (FieldValue sch v)
forall a b. (a -> b) -> a -> b
$ "variable '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found"
      Just v :: Value
v  -> VariableMap -> Text -> Value -> f (FieldValue sch v)
forall (sch :: Schema') (v :: FieldType Symbol) (f :: * -> *).
(ValueParser sch v, MonadError Text f) =>
VariableMap -> Text -> Value -> f (FieldValue sch v)
valueParser VariableMap
vmap Text
aname Value
v
valueParser' vmap :: VariableMap
vmap aname :: Text
aname v :: Value
v = VariableMap -> Text -> Value -> f (FieldValue sch v)
forall (sch :: Schema') (v :: FieldType Symbol) (f :: * -> *).
(ValueParser sch v, MonadError Text f) =>
VariableMap -> Text -> Value -> f (FieldValue sch v)
valueParser VariableMap
vmap Text
aname Value
v

class ValueParser (sch :: Schema') (v :: FieldType Symbol) where
  valueParser :: MonadError T.Text f
              => VariableMap
              -> T.Text
              -> GQL.Value
              -> f (FieldValue sch v)

instance ValueParser sch 'TNull where
  valueParser :: VariableMap -> Text -> Value -> f (FieldValue sch 'TNull)
valueParser _ _ GQL.VNull = FieldValue sch 'TNull -> f (FieldValue sch 'TNull)
forall (f :: * -> *) a. Applicative f => a -> f a
pure FieldValue sch 'TNull
forall typeName fieldName (sch :: Schema typeName fieldName).
FieldValue sch 'TNull
FNull
  valueParser _ fname :: Text
fname _
    = Text -> f (FieldValue sch 'TNull)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch 'TNull))
-> Text -> f (FieldValue sch 'TNull)
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ValueParser sch ('TPrimitive Bool) where
  valueParser :: VariableMap
-> Text -> Value -> f (FieldValue sch ('TPrimitive Bool))
valueParser _ _ (GQL.VBoolean b :: Bool
b) = FieldValue sch ('TPrimitive Bool)
-> f (FieldValue sch ('TPrimitive Bool))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> FieldValue sch ('TPrimitive Bool)
forall typeName fieldName t1 (sch :: Schema typeName fieldName).
t1 -> FieldValue sch ('TPrimitive t1)
FPrimitive Bool
b)
  valueParser _ fname :: Text
fname _
    = Text -> f (FieldValue sch ('TPrimitive Bool))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch ('TPrimitive Bool)))
-> Text -> f (FieldValue sch ('TPrimitive Bool))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ValueParser sch ('TPrimitive Int32) where
  valueParser :: VariableMap
-> Text -> Value -> f (FieldValue sch ('TPrimitive Int32))
valueParser _ _ (GQL.VInt b :: Int32
b) = FieldValue sch ('TPrimitive Int32)
-> f (FieldValue sch ('TPrimitive Int32))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int32 -> FieldValue sch ('TPrimitive Int32)
forall typeName fieldName t1 (sch :: Schema typeName fieldName).
t1 -> FieldValue sch ('TPrimitive t1)
FPrimitive Int32
b)
  valueParser _ fname :: Text
fname _
    = Text -> f (FieldValue sch ('TPrimitive Int32))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch ('TPrimitive Int32)))
-> Text -> f (FieldValue sch ('TPrimitive Int32))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ValueParser sch ('TPrimitive Integer) where
  valueParser :: VariableMap
-> Text -> Value -> f (FieldValue sch ('TPrimitive Integer))
valueParser _ _ (GQL.VInt b :: Int32
b) = FieldValue sch ('TPrimitive Integer)
-> f (FieldValue sch ('TPrimitive Integer))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (FieldValue sch ('TPrimitive Integer)
 -> f (FieldValue sch ('TPrimitive Integer)))
-> FieldValue sch ('TPrimitive Integer)
-> f (FieldValue sch ('TPrimitive Integer))
forall a b. (a -> b) -> a -> b
$ Integer -> FieldValue sch ('TPrimitive Integer)
forall typeName fieldName t1 (sch :: Schema typeName fieldName).
t1 -> FieldValue sch ('TPrimitive t1)
FPrimitive (Integer -> FieldValue sch ('TPrimitive Integer))
-> Integer -> FieldValue sch ('TPrimitive Integer)
forall a b. (a -> b) -> a -> b
$ Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
b
  valueParser _ fname :: Text
fname _
    = Text -> f (FieldValue sch ('TPrimitive Integer))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch ('TPrimitive Integer)))
-> Text -> f (FieldValue sch ('TPrimitive Integer))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ValueParser sch ('TPrimitive Double) where
  valueParser :: VariableMap
-> Text -> Value -> f (FieldValue sch ('TPrimitive Double))
valueParser _ _ (GQL.VFloat b :: Double
b) = FieldValue sch ('TPrimitive Double)
-> f (FieldValue sch ('TPrimitive Double))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> FieldValue sch ('TPrimitive Double)
forall typeName fieldName t1 (sch :: Schema typeName fieldName).
t1 -> FieldValue sch ('TPrimitive t1)
FPrimitive Double
b)
  valueParser _ fname :: Text
fname _
    = Text -> f (FieldValue sch ('TPrimitive Double))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch ('TPrimitive Double)))
-> Text -> f (FieldValue sch ('TPrimitive Double))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ValueParser sch ('TPrimitive T.Text) where
  valueParser :: VariableMap
-> Text -> Value -> f (FieldValue sch ('TPrimitive Text))
valueParser _ _ (GQL.VString (GQL.StringValue b :: Text
b))
    = FieldValue sch ('TPrimitive Text)
-> f (FieldValue sch ('TPrimitive Text))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (FieldValue sch ('TPrimitive Text)
 -> f (FieldValue sch ('TPrimitive Text)))
-> FieldValue sch ('TPrimitive Text)
-> f (FieldValue sch ('TPrimitive Text))
forall a b. (a -> b) -> a -> b
$ Text -> FieldValue sch ('TPrimitive Text)
forall typeName fieldName t1 (sch :: Schema typeName fieldName).
t1 -> FieldValue sch ('TPrimitive t1)
FPrimitive Text
b
  valueParser _ fname :: Text
fname _
    = Text -> f (FieldValue sch ('TPrimitive Text))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch ('TPrimitive Text)))
-> Text -> f (FieldValue sch ('TPrimitive Text))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance ValueParser sch ('TPrimitive String) where
  valueParser :: VariableMap
-> Text -> Value -> f (FieldValue sch ('TPrimitive String))
valueParser _ _ (GQL.VString (GQL.StringValue b :: Text
b))
    = FieldValue sch ('TPrimitive String)
-> f (FieldValue sch ('TPrimitive String))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (FieldValue sch ('TPrimitive String)
 -> f (FieldValue sch ('TPrimitive String)))
-> FieldValue sch ('TPrimitive String)
-> f (FieldValue sch ('TPrimitive String))
forall a b. (a -> b) -> a -> b
$ String -> FieldValue sch ('TPrimitive String)
forall typeName fieldName t1 (sch :: Schema typeName fieldName).
t1 -> FieldValue sch ('TPrimitive t1)
FPrimitive (String -> FieldValue sch ('TPrimitive String))
-> String -> FieldValue sch ('TPrimitive String)
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
b
  valueParser _ fname :: Text
fname _
    = Text -> f (FieldValue sch ('TPrimitive String))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch ('TPrimitive String)))
-> Text -> f (FieldValue sch ('TPrimitive String))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance (ValueParser sch r) => ValueParser sch ('TList r) where
  valueParser :: VariableMap -> Text -> Value -> f (FieldValue sch ('TList r))
valueParser vmap :: VariableMap
vmap fname :: Text
fname (GQL.VList (GQL.ListValueG xs :: [Value]
xs))
    = [FieldValue sch r] -> FieldValue sch ('TList r)
forall typeName fieldName (sch :: Schema typeName fieldName)
       (t1 :: FieldType typeName).
[FieldValue sch t1] -> FieldValue sch ('TList t1)
FList ([FieldValue sch r] -> FieldValue sch ('TList r))
-> f [FieldValue sch r] -> f (FieldValue sch ('TList r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> f (FieldValue sch r)) -> [Value] -> f [FieldValue sch r]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (VariableMap -> Text -> Value -> f (FieldValue sch r)
forall (sch :: Schema') (v :: FieldType Symbol) (f :: * -> *).
(ValueParser sch v, MonadError Text f) =>
VariableMap -> Text -> Value -> f (FieldValue sch v)
valueParser' VariableMap
vmap Text
fname) [Value]
xs
  valueParser _ fname :: Text
fname _
    = Text -> f (FieldValue sch ('TList r))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (FieldValue sch ('TList r)))
-> Text -> f (FieldValue sch ('TList r))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not of right type"
instance (ValueParser sch r) => ValueParser sch ('TOption r) where
  valueParser :: VariableMap -> Text -> Value -> f (FieldValue sch ('TOption r))
valueParser _ _ GQL.VNull
    = FieldValue sch ('TOption r) -> f (FieldValue sch ('TOption r))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (FieldValue sch ('TOption r) -> f (FieldValue sch ('TOption r)))
-> FieldValue sch ('TOption r) -> f (FieldValue sch ('TOption r))
forall a b. (a -> b) -> a -> b
$ Maybe (FieldValue sch r) -> FieldValue sch ('TOption r)
forall typeName fieldName (sch :: Schema typeName fieldName)
       (t1 :: FieldType typeName).
Maybe (FieldValue sch t1) -> FieldValue sch ('TOption t1)
FOption Maybe (FieldValue sch r)
forall a. Maybe a
Nothing
  valueParser vmap :: VariableMap
vmap fname :: Text
fname v :: Value
v
    = Maybe (FieldValue sch r) -> FieldValue sch ('TOption r)
forall typeName fieldName (sch :: Schema typeName fieldName)
       (t1 :: FieldType typeName).
Maybe (FieldValue sch t1) -> FieldValue sch ('TOption t1)
FOption (Maybe (FieldValue sch r) -> FieldValue sch ('TOption r))
-> (FieldValue sch r -> Maybe (FieldValue sch r))
-> FieldValue sch r
-> FieldValue sch ('TOption r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldValue sch r -> Maybe (FieldValue sch r)
forall a. a -> Maybe a
Just (FieldValue sch r -> FieldValue sch ('TOption r))
-> f (FieldValue sch r) -> f (FieldValue sch ('TOption r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (FieldValue sch r)
forall (sch :: Schema') (v :: FieldType Symbol) (f :: * -> *).
(ValueParser sch v, MonadError Text f) =>
VariableMap -> Text -> Value -> f (FieldValue sch v)
valueParser' VariableMap
vmap Text
fname Value
v
instance (ObjectOrEnumParser sch (sch :/: sty), KnownName sty)
         => ValueParser sch ('TSchematic sty) where
  valueParser :: VariableMap
-> Text -> Value -> f (FieldValue sch ('TSchematic sty))
valueParser vmap :: VariableMap
vmap _ v :: Value
v
    = Term sch (sch :/: sty) -> FieldValue sch ('TSchematic sty)
forall typeName fieldName (sch :: Schema typeName fieldName)
       (t1 :: typeName).
Term sch (sch :/: t1) -> FieldValue sch ('TSchematic t1)
FSchematic (Term sch (sch :/: sty) -> FieldValue sch ('TSchematic sty))
-> f (Term sch (sch :/: sty))
-> f (FieldValue sch ('TSchematic sty))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap -> Text -> Value -> f (Term sch (sch :/: sty))
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (f :: * -> *).
(ObjectOrEnumParser sch t, MonadError Text f) =>
VariableMap -> Text -> Value -> f (Term sch t)
parseObjectOrEnum' VariableMap
vmap (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy sty -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy sty
forall k (t :: k). Proxy t
Proxy @sty)) Value
v

class ParseDifferentReturn (p :: Package') (r :: Return Symbol) where
  parseDiffReturn :: MonadError T.Text f
                  => VariableMap
                  -> FragmentMap
                  -> T.Text
                  -> GQL.SelectionSet
                  -> f (ReturnQuery p r)
instance ParseDifferentReturn p 'RetNothing where
  parseDiffReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnQuery p 'RetNothing)
parseDiffReturn _ _ _ [] = ReturnQuery p 'RetNothing -> f (ReturnQuery p 'RetNothing)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ReturnQuery p 'RetNothing
forall snm mnm anm (p :: Package snm mnm anm).
ReturnQuery p 'RetNothing
RNothing
  parseDiffReturn _ _ fname :: Text
fname _
    = Text -> f (ReturnQuery p 'RetNothing)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ReturnQuery p 'RetNothing))
-> Text -> f (ReturnQuery p 'RetNothing)
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' should not have a selection of subfields"
instance ParseReturn p r => ParseDifferentReturn p ('RetSingle r) where
  parseDiffReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnQuery p ('RetSingle r))
parseDiffReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap fname :: Text
fname s :: SelectionSet
s
    = ReturnQuery' p r -> ReturnQuery p ('RetSingle r)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName).
ReturnQuery' p r -> ReturnQuery p ('RetSingle r)
RSingle (ReturnQuery' p r -> ReturnQuery p ('RetSingle r))
-> f (ReturnQuery' p r) -> f (ReturnQuery p ('RetSingle r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery' p r)
forall (p :: Package') (r :: TypeRef Symbol) (f :: * -> *).
(ParseReturn p r, MonadError Text f) =>
VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery' p r)
parseReturn VariableMap
vmap FragmentMap
frmap Text
fname SelectionSet
s
instance ParseReturn p r => ParseDifferentReturn p ('RetStream r) where
  parseDiffReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnQuery p ('RetStream r))
parseDiffReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap fname :: Text
fname s :: SelectionSet
s
    = ReturnQuery' p r -> ReturnQuery p ('RetStream r)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName).
ReturnQuery' p r -> ReturnQuery p ('RetStream r)
RStream (ReturnQuery' p r -> ReturnQuery p ('RetStream r))
-> f (ReturnQuery' p r) -> f (ReturnQuery p ('RetStream r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery' p r)
forall (p :: Package') (r :: TypeRef Symbol) (f :: * -> *).
(ParseReturn p r, MonadError Text f) =>
VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery' p r)
parseReturn VariableMap
vmap FragmentMap
frmap Text
fname SelectionSet
s

class ParseReturn (p :: Package') (r :: TypeRef Symbol) where
  parseReturn :: MonadError T.Text f
              => VariableMap
              -> FragmentMap
              -> T.Text
              -> GQL.SelectionSet
              -> f (ReturnQuery' p r)

instance ParseReturn p ('PrimitiveRef t) where
  parseReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnQuery' p ('PrimitiveRef t))
parseReturn _ _ _ []
    = ReturnQuery' p ('PrimitiveRef t)
-> f (ReturnQuery' p ('PrimitiveRef t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ReturnQuery' p ('PrimitiveRef t)
forall snm mnm anm (p :: Package snm mnm anm) t.
ReturnQuery' p ('PrimitiveRef t)
RetPrimitive
  parseReturn _ _ fname :: Text
fname _
    = Text -> f (ReturnQuery' p ('PrimitiveRef t))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ReturnQuery' p ('PrimitiveRef t)))
-> Text -> f (ReturnQuery' p ('PrimitiveRef t))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' should not have a selection of subfields"
instance (ParseSchema sch (sch :/: sty))
         => ParseReturn p ('SchemaRef sch sty) where
  parseReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnQuery' p ('SchemaRef sch sty))
parseReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap fname :: Text
fname s :: SelectionSet
s
    = SchemaQuery sch (sch :/: sty)
-> ReturnQuery' p ('SchemaRef sch sty)
forall typeName fieldName snm mnm anm
       (sch :: Schema typeName fieldName) (r :: typeName)
       (p :: Package snm mnm anm).
SchemaQuery sch (sch :/: r) -> ReturnQuery' p ('SchemaRef sch r)
RetSchema (SchemaQuery sch (sch :/: sty)
 -> ReturnQuery' p ('SchemaRef sch sty))
-> f (SchemaQuery sch (sch :/: sty))
-> f (ReturnQuery' p ('SchemaRef sch sty))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (SchemaQuery sch (sch :/: sty))
forall (s :: Schema') (t :: TypeDefB * Symbol Symbol)
       (f :: * -> *).
(ParseSchema s t, MonadError Text f) =>
VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (SchemaQuery s t)
parseSchema VariableMap
vmap FragmentMap
frmap Text
fname SelectionSet
s
instance ParseReturn p r
         => ParseReturn p ('ListRef r) where
  parseReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnQuery' p ('ListRef r))
parseReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap fname :: Text
fname s :: SelectionSet
s
    = ReturnQuery' p r -> ReturnQuery' p ('ListRef r)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName).
ReturnQuery' p r -> ReturnQuery' p ('ListRef r)
RetList (ReturnQuery' p r -> ReturnQuery' p ('ListRef r))
-> f (ReturnQuery' p r) -> f (ReturnQuery' p ('ListRef r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery' p r)
forall (p :: Package') (r :: TypeRef Symbol) (f :: * -> *).
(ParseReturn p r, MonadError Text f) =>
VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery' p r)
parseReturn VariableMap
vmap FragmentMap
frmap Text
fname SelectionSet
s
instance ParseReturn p r
         => ParseReturn p ('OptionalRef r) where
  parseReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnQuery' p ('OptionalRef r))
parseReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap fname :: Text
fname s :: SelectionSet
s
    = ReturnQuery' p r -> ReturnQuery' p ('OptionalRef r)
forall serviceName mnm anm (p :: Package serviceName mnm anm)
       (r :: TypeRef serviceName).
ReturnQuery' p r -> ReturnQuery' p ('OptionalRef r)
RetOptional (ReturnQuery' p r -> ReturnQuery' p ('OptionalRef r))
-> f (ReturnQuery' p r) -> f (ReturnQuery' p ('OptionalRef r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery' p r)
forall (p :: Package') (r :: TypeRef Symbol) (f :: * -> *).
(ParseReturn p r, MonadError Text f) =>
VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (ReturnQuery' p r)
parseReturn VariableMap
vmap FragmentMap
frmap Text
fname SelectionSet
s
instance ( p ~ 'Package pname ss,
           LookupService ss s ~ 'Service s sanns methods,
           KnownName s, ParseMethod p methods
         ) => ParseReturn p ('ObjectRef s) where
  parseReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnQuery' p ('ObjectRef s))
parseReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap _ s :: SelectionSet
s
    = [OneMethodQuery ('Package pname ss) (LookupService ss s)]
-> ReturnQuery' ('Package pname ss) ('ObjectRef s)
forall serviceName mnm anm (pname :: Maybe serviceName)
       (ss :: [Service serviceName mnm anm]) (s :: serviceName).
ServiceQuery ('Package pname ss) (LookupService ss s)
-> ReturnQuery' ('Package pname ss) ('ObjectRef s)
RetObject ([OneMethodQuery ('Package pname ss) (LookupService ss s)]
 -> ReturnQuery' ('Package pname ss) ('ObjectRef s))
-> f [OneMethodQuery ('Package pname ss) (LookupService ss s)]
-> f (ReturnQuery' ('Package pname ss) ('ObjectRef s))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
forall (p :: Package') (s :: Symbol) (pname :: Maybe Symbol)
       (ss :: [Service Symbol Symbol Symbol]) (sanns :: [*])
       (methods :: [Method Symbol Symbol Symbol]) (f :: * -> *).
(MonadError Text f, p ~ 'Package pname ss,
 LookupService ss s ~ 'Service s sanns methods, KnownName s,
 ParseMethod p methods) =>
Proxy p
-> Proxy s
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f (ServiceQuery p (LookupService ss s))
parseQuery (Proxy p
forall k (t :: k). Proxy t
Proxy @p) (Proxy s
forall k (t :: k). Proxy t
Proxy @s) VariableMap
vmap FragmentMap
frmap SelectionSet
s

class ParseSchema (s :: Schema') (t :: TypeDef Symbol Symbol) where
  parseSchema :: MonadError T.Text f
              => VariableMap
              -> FragmentMap
              -> T.Text
              -> GQL.SelectionSet
              -> f (SchemaQuery s t)
instance ParseSchema sch ('DEnum name choices) where
  parseSchema :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (SchemaQuery sch ('DEnum name choices))
parseSchema _ _ _ []
    = SchemaQuery sch ('DEnum name choices)
-> f (SchemaQuery sch ('DEnum name choices))
forall (f :: * -> *) a. Applicative f => a -> f a
pure SchemaQuery sch ('DEnum name choices)
forall tn fn (sch :: Schema tn fn) (nm :: tn)
       (choices :: [ChoiceDef fn]).
SchemaQuery sch ('DEnum nm choices)
QueryEnum
  parseSchema _ _ fname :: Text
fname _
    = Text -> f (SchemaQuery sch ('DEnum name choices))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (SchemaQuery sch ('DEnum name choices)))
-> Text -> f (SchemaQuery sch ('DEnum name choices))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' should not have a selection of subfields"
instance (KnownSymbol name, ParseField sch fields)
         => ParseSchema sch ('DRecord name fields) where
  parseSchema :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (SchemaQuery sch ('DRecord name fields))
parseSchema vmap :: VariableMap
vmap frmap :: FragmentMap
frmap _ s :: SelectionSet
s
    = [OneFieldQuery sch fields]
-> SchemaQuery sch ('DRecord name fields)
forall typeName fieldName (sch :: Schema typeName fieldName)
       (fs :: [FieldDef typeName fieldName]) (ty :: typeName).
[OneFieldQuery sch fs] -> SchemaQuery sch ('DRecord ty fs)
QueryRecord ([OneFieldQuery sch fields]
 -> SchemaQuery sch ('DRecord name fields))
-> f [OneFieldQuery sch fields]
-> f (SchemaQuery sch ('DRecord name fields))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy sch
-> Proxy ('DRecord name fields)
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (rname :: Symbol) (fields :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(MonadError Text f, t ~ 'DRecord rname fields, KnownSymbol rname,
 ParseField sch fields) =>
Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
parseSchemaQuery (Proxy sch
forall k (t :: k). Proxy t
Proxy @sch) (Proxy ('DRecord name fields)
forall k (t :: k). Proxy t
Proxy @('DRecord name fields)) VariableMap
vmap FragmentMap
frmap SelectionSet
s

parseSchemaQuery ::
  forall (sch :: Schema') t (rname :: Symbol) fields f.
  ( MonadError T.Text f
  , t ~  'DRecord rname fields
  , KnownSymbol rname
  , ParseField sch fields ) =>
  Proxy sch ->
  Proxy t ->
  VariableMap -> FragmentMap -> GQL.SelectionSet ->
  f [OneFieldQuery sch fields]
parseSchemaQuery :: Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
parseSchemaQuery _ _ _ _ [] = [OneFieldQuery sch fields] -> f [OneFieldQuery sch fields]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
parseSchemaQuery pp :: Proxy sch
pp ps :: Proxy t
ps vmap :: VariableMap
vmap frmap :: FragmentMap
frmap (GQL.SelectionField fld :: Field
fld : ss :: SelectionSet
ss)
  = [OneFieldQuery sch fields]
-> [OneFieldQuery sch fields] -> [OneFieldQuery sch fields]
forall a. [a] -> [a] -> [a]
(++) ([OneFieldQuery sch fields]
 -> [OneFieldQuery sch fields] -> [OneFieldQuery sch fields])
-> f [OneFieldQuery sch fields]
-> f ([OneFieldQuery sch fields] -> [OneFieldQuery sch fields])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe (OneFieldQuery sch fields) -> [OneFieldQuery sch fields]
forall a. Maybe a -> [a]
maybeToList (Maybe (OneFieldQuery sch fields) -> [OneFieldQuery sch fields])
-> f (Maybe (OneFieldQuery sch fields))
-> f [OneFieldQuery sch fields]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> f (Maybe (OneFieldQuery sch fields))
fieldToMethod Field
fld)
         f ([OneFieldQuery sch fields] -> [OneFieldQuery sch fields])
-> f [OneFieldQuery sch fields] -> f [OneFieldQuery sch fields]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (rname :: Symbol) (fields :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(MonadError Text f, t ~ 'DRecord rname fields, KnownSymbol rname,
 ParseField sch fields) =>
Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
parseSchemaQuery Proxy sch
pp Proxy t
ps VariableMap
vmap FragmentMap
frmap SelectionSet
ss
  where
    fieldToMethod :: GQL.Field -> f (Maybe (OneFieldQuery sch fields))
    fieldToMethod :: Field -> f (Maybe (OneFieldQuery sch fields))
fieldToMethod (GQL.Field alias :: Maybe Alias
alias name :: Name
name args :: [Argument]
args dirs :: [Directive]
dirs sels :: SelectionSet
sels)
      | (Directive -> Bool) -> [Directive] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (VariableMap -> Directive -> Bool
shouldSkip VariableMap
vmap) [Directive]
dirs
      = Maybe (OneFieldQuery sch fields)
-> f (Maybe (OneFieldQuery sch fields))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (OneFieldQuery sch fields)
forall a. Maybe a
Nothing
      | Name -> Text
GQL.unName Name
name Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "__typename"
      = case ([Argument]
args, SelectionSet
sels) of
          ([], []) -> Maybe (OneFieldQuery sch fields)
-> f (Maybe (OneFieldQuery sch fields))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (OneFieldQuery sch fields)
 -> f (Maybe (OneFieldQuery sch fields)))
-> Maybe (OneFieldQuery sch fields)
-> f (Maybe (OneFieldQuery sch fields))
forall a b. (a -> b) -> a -> b
$ OneFieldQuery sch fields -> Maybe (OneFieldQuery sch fields)
forall a. a -> Maybe a
Just (OneFieldQuery sch fields -> Maybe (OneFieldQuery sch fields))
-> OneFieldQuery sch fields -> Maybe (OneFieldQuery sch fields)
forall a b. (a -> b) -> a -> b
$ Maybe Text -> OneFieldQuery sch fields
forall tn fn (sch :: Schema tn fn) (fs :: [FieldDef tn fn]).
Maybe Text -> OneFieldQuery sch fs
TypeNameFieldQuery (Maybe Text -> OneFieldQuery sch fields)
-> Maybe Text -> OneFieldQuery sch fields
forall a b. (a -> b) -> a -> b
$ Name -> Text
GQL.unName (Name -> Text) -> (Alias -> Name) -> Alias -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alias -> Name
GQL.unAlias (Alias -> Text) -> Maybe Alias -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Alias
alias
          _        -> Text -> f (Maybe (OneFieldQuery sch fields))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "__typename does not admit arguments nor selection of subfields"
      | _:_ <- [Argument]
args
      = Text -> f (Maybe (OneFieldQuery sch fields))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "this field does not support arguments"
      | Bool
otherwise
      = OneFieldQuery sch fields -> Maybe (OneFieldQuery sch fields)
forall a. a -> Maybe a
Just (OneFieldQuery sch fields -> Maybe (OneFieldQuery sch fields))
-> (NS (ChosenFieldQuery sch) fields -> OneFieldQuery sch fields)
-> NS (ChosenFieldQuery sch) fields
-> Maybe (OneFieldQuery sch fields)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Text
-> NS (ChosenFieldQuery sch) fields -> OneFieldQuery sch fields
forall tn fn (sch :: Schema tn fn) (fs :: [FieldDef tn fn]).
Maybe Text -> NS (ChosenFieldQuery sch) fs -> OneFieldQuery sch fs
OneFieldQuery (Name -> Text
GQL.unName (Name -> Text) -> (Alias -> Name) -> Alias -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alias -> Name
GQL.unAlias (Alias -> Text) -> Maybe Alias -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Alias
alias)
         (NS (ChosenFieldQuery sch) fields
 -> Maybe (OneFieldQuery sch fields))
-> f (NS (ChosenFieldQuery sch) fields)
-> f (Maybe (OneFieldQuery sch fields))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> VariableMap
-> FragmentMap
-> Name
-> SelectionSet
-> f (NS (ChosenFieldQuery sch) fields)
forall (sch :: Schema') (fs :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(ParseField sch fs, MonadError Text f) =>
Text
-> VariableMap
-> FragmentMap
-> Name
-> SelectionSet
-> f (NS (ChosenFieldQuery sch) fs)
selectField (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy rname -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy rname
forall k (t :: k). Proxy t
Proxy @rname)) VariableMap
vmap FragmentMap
frmap Name
name SelectionSet
sels
parseSchemaQuery pp :: Proxy sch
pp ps :: Proxy t
ps vmap :: VariableMap
vmap frmap :: FragmentMap
frmap (GQL.SelectionFragmentSpread (GQL.FragmentSpread nm :: Name
nm dirs :: [Directive]
dirs) : ss :: SelectionSet
ss)
  | Just fr :: FragmentDefinition
fr <- Text -> FragmentMap -> Maybe FragmentDefinition
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup (Name -> Text
GQL.unName Name
nm) FragmentMap
frmap
  = if Bool -> Bool
not ((Directive -> Bool) -> [Directive] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (VariableMap -> Directive -> Bool
shouldSkip VariableMap
vmap) [Directive]
dirs) Bool -> Bool -> Bool
&& Bool -> Bool
not ((Directive -> Bool) -> [Directive] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (VariableMap -> Directive -> Bool
shouldSkip VariableMap
vmap) ([Directive] -> Bool) -> [Directive] -> Bool
forall a b. (a -> b) -> a -> b
$ FragmentDefinition -> [Directive]
GQL._fdDirectives FragmentDefinition
fr)
       then [OneFieldQuery sch fields]
-> [OneFieldQuery sch fields] -> [OneFieldQuery sch fields]
forall a. [a] -> [a] -> [a]
(++) ([OneFieldQuery sch fields]
 -> [OneFieldQuery sch fields] -> [OneFieldQuery sch fields])
-> f [OneFieldQuery sch fields]
-> f ([OneFieldQuery sch fields] -> [OneFieldQuery sch fields])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (rname :: Symbol) (fields :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(MonadError Text f, t ~ 'DRecord rname fields, KnownSymbol rname,
 ParseField sch fields) =>
Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
parseSchemaQuery Proxy sch
pp Proxy t
ps VariableMap
vmap FragmentMap
frmap (FragmentDefinition -> SelectionSet
GQL._fdSelectionSet FragmentDefinition
fr)
                 f ([OneFieldQuery sch fields] -> [OneFieldQuery sch fields])
-> f [OneFieldQuery sch fields] -> f [OneFieldQuery sch fields]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (rname :: Symbol) (fields :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(MonadError Text f, t ~ 'DRecord rname fields, KnownSymbol rname,
 ParseField sch fields) =>
Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
parseSchemaQuery Proxy sch
pp Proxy t
ps VariableMap
vmap FragmentMap
frmap SelectionSet
ss
       else Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
forall (sch :: Schema') (t :: TypeDefB * Symbol Symbol)
       (rname :: Symbol) (fields :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(MonadError Text f, t ~ 'DRecord rname fields, KnownSymbol rname,
 ParseField sch fields) =>
Proxy sch
-> Proxy t
-> VariableMap
-> FragmentMap
-> SelectionSet
-> f [OneFieldQuery sch fields]
parseSchemaQuery Proxy sch
pp Proxy t
ps VariableMap
vmap FragmentMap
frmap SelectionSet
ss
  | Bool
otherwise  -- the fragment definition was not found
  = Text -> f [OneFieldQuery sch fields]
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f [OneFieldQuery sch fields])
-> Text -> f [OneFieldQuery sch fields]
forall a b. (a -> b) -> a -> b
$ "fragment '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Name -> Text
GQL.unName Name
nm Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found"
parseSchemaQuery _ _ _ _ (_ : _)  -- Inline fragments are not yet supported
  = Text -> f [OneFieldQuery sch fields]
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError "inline fragments are not (yet) supported"

class ParseField (sch :: Schema') (fs :: [FieldDef Symbol Symbol]) where
  selectField ::
    MonadError T.Text f =>
    T.Text ->
    VariableMap ->
    FragmentMap ->
    GQL.Name ->
    GQL.SelectionSet ->
    f (NS (ChosenFieldQuery sch) fs)

instance ParseField sch '[] where
  selectField :: Text
-> VariableMap
-> FragmentMap
-> Name
-> SelectionSet
-> f (NS (ChosenFieldQuery sch) '[])
selectField tyName :: Text
tyName _ _ (Name -> Text
GQL.unName -> Text
wanted) _
    = Text -> f (NS (ChosenFieldQuery sch) '[])
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (NS (ChosenFieldQuery sch) '[]))
-> Text -> f (NS (ChosenFieldQuery sch) '[])
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
wanted Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' was not found on type '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
tyName Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "'"
instance
  (KnownSymbol fname, ParseField sch fs, ParseSchemaReturn sch r) =>
  ParseField sch ('FieldDef fname r ': fs)
  where
  selectField :: Text
-> VariableMap
-> FragmentMap
-> Name
-> SelectionSet
-> f (NS (ChosenFieldQuery sch) ('FieldDef fname r : fs))
selectField tyName :: Text
tyName vmap :: VariableMap
vmap frmap :: FragmentMap
frmap w :: Name
w@(Name -> Text
GQL.unName -> Text
wanted) sels :: SelectionSet
sels
    | Text
wanted Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
mname
    = ChosenFieldQuery sch ('FieldDef fname r)
-> NS (ChosenFieldQuery sch) ('FieldDef fname r : fs)
forall k (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (ChosenFieldQuery sch ('FieldDef fname r)
 -> NS (ChosenFieldQuery sch) ('FieldDef fname r : fs))
-> f (ChosenFieldQuery sch ('FieldDef fname r))
-> f (NS (ChosenFieldQuery sch) ('FieldDef fname r : fs))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ReturnSchemaQuery sch r -> ChosenFieldQuery sch ('FieldDef fname r)
forall typeName fn (sch :: Schema typeName fn)
       (r :: FieldType typeName) (name :: fn).
ReturnSchemaQuery sch r -> ChosenFieldQuery sch ('FieldDef name r)
ChosenFieldQuery (ReturnSchemaQuery sch r
 -> ChosenFieldQuery sch ('FieldDef fname r))
-> f (ReturnSchemaQuery sch r)
-> f (ChosenFieldQuery sch ('FieldDef fname r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch r)
forall (sch :: Schema') (r :: FieldType Symbol) (f :: * -> *).
(ParseSchemaReturn sch r, MonadError Text f) =>
VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch r)
parseSchemaReturn VariableMap
vmap FragmentMap
frmap Text
wanted SelectionSet
sels)
    | Bool
otherwise
    = NS (ChosenFieldQuery sch) fs
-> NS (ChosenFieldQuery sch) ('FieldDef fname r : fs)
forall k (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (NS (ChosenFieldQuery sch) fs
 -> NS (ChosenFieldQuery sch) ('FieldDef fname r : fs))
-> f (NS (ChosenFieldQuery sch) fs)
-> f (NS (ChosenFieldQuery sch) ('FieldDef fname r : fs))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> VariableMap
-> FragmentMap
-> Name
-> SelectionSet
-> f (NS (ChosenFieldQuery sch) fs)
forall (sch :: Schema') (fs :: [FieldDef Symbol Symbol])
       (f :: * -> *).
(ParseField sch fs, MonadError Text f) =>
Text
-> VariableMap
-> FragmentMap
-> Name
-> SelectionSet
-> f (NS (ChosenFieldQuery sch) fs)
selectField Text
tyName VariableMap
vmap FragmentMap
frmap Name
w SelectionSet
sels
    where
      mname :: Text
mname = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Proxy fname -> String
forall k (a :: k) (proxy :: k -> *).
KnownName a =>
proxy a -> String
nameVal (Proxy fname
forall k (t :: k). Proxy t
Proxy @fname)

class ParseSchemaReturn (sch :: Schema') (r :: FieldType Symbol) where
  parseSchemaReturn :: MonadError T.Text f
                    => VariableMap
                    -> FragmentMap
                    -> T.Text
                    -> GQL.SelectionSet
                    -> f (ReturnSchemaQuery sch r)

instance ParseSchemaReturn sch ('TPrimitive t) where
  parseSchemaReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch ('TPrimitive t))
parseSchemaReturn _ _ _ []
    = ReturnSchemaQuery sch ('TPrimitive t)
-> f (ReturnSchemaQuery sch ('TPrimitive t))
forall (f :: * -> *) a. Applicative f => a -> f a
pure ReturnSchemaQuery sch ('TPrimitive t)
forall tn fn (sch :: Schema tn fn) t.
ReturnSchemaQuery sch ('TPrimitive t)
RetSchPrimitive
  parseSchemaReturn _ _ fname :: Text
fname _
    = Text -> f (ReturnSchemaQuery sch ('TPrimitive t))
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> f (ReturnSchemaQuery sch ('TPrimitive t)))
-> Text -> f (ReturnSchemaQuery sch ('TPrimitive t))
forall a b. (a -> b) -> a -> b
$ "field '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "' should not have a selection of subfields"
instance ( ParseSchema sch (sch :/: sty) )
         => ParseSchemaReturn sch ('TSchematic sty) where
  parseSchemaReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch ('TSchematic sty))
parseSchemaReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap fname :: Text
fname s :: SelectionSet
s
    = SchemaQuery sch (sch :/: sty)
-> ReturnSchemaQuery sch ('TSchematic sty)
forall typeName fn (sch :: Schema typeName fn) (sty :: typeName).
SchemaQuery sch (sch :/: sty)
-> ReturnSchemaQuery sch ('TSchematic sty)
RetSchSchema (SchemaQuery sch (sch :/: sty)
 -> ReturnSchemaQuery sch ('TSchematic sty))
-> f (SchemaQuery sch (sch :/: sty))
-> f (ReturnSchemaQuery sch ('TSchematic sty))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (SchemaQuery sch (sch :/: sty))
forall (s :: Schema') (t :: TypeDefB * Symbol Symbol)
       (f :: * -> *).
(ParseSchema s t, MonadError Text f) =>
VariableMap
-> FragmentMap -> Text -> SelectionSet -> f (SchemaQuery s t)
parseSchema VariableMap
vmap FragmentMap
frmap Text
fname SelectionSet
s
instance ParseSchemaReturn sch r
         => ParseSchemaReturn sch ('TList r) where
  parseSchemaReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch ('TList r))
parseSchemaReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap fname :: Text
fname s :: SelectionSet
s
    = ReturnSchemaQuery sch r -> ReturnSchemaQuery sch ('TList r)
forall typeName fn (sch :: Schema typeName fn)
       (r :: FieldType typeName).
ReturnSchemaQuery sch r -> ReturnSchemaQuery sch ('TList r)
RetSchList (ReturnSchemaQuery sch r -> ReturnSchemaQuery sch ('TList r))
-> f (ReturnSchemaQuery sch r)
-> f (ReturnSchemaQuery sch ('TList r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch r)
forall (sch :: Schema') (r :: FieldType Symbol) (f :: * -> *).
(ParseSchemaReturn sch r, MonadError Text f) =>
VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch r)
parseSchemaReturn VariableMap
vmap FragmentMap
frmap Text
fname SelectionSet
s
instance ParseSchemaReturn sch r
         => ParseSchemaReturn sch ('TOption r) where
  parseSchemaReturn :: VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch ('TOption r))
parseSchemaReturn vmap :: VariableMap
vmap frmap :: FragmentMap
frmap fname :: Text
fname s :: SelectionSet
s
    = ReturnSchemaQuery sch r -> ReturnSchemaQuery sch ('TOption r)
forall typeName fn (sch :: Schema typeName fn)
       (r :: FieldType typeName).
ReturnSchemaQuery sch r -> ReturnSchemaQuery sch ('TOption r)
RetSchOptional (ReturnSchemaQuery sch r -> ReturnSchemaQuery sch ('TOption r))
-> f (ReturnSchemaQuery sch r)
-> f (ReturnSchemaQuery sch ('TOption r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch r)
forall (sch :: Schema') (r :: FieldType Symbol) (f :: * -> *).
(ParseSchemaReturn sch r, MonadError Text f) =>
VariableMap
-> FragmentMap
-> Text
-> SelectionSet
-> f (ReturnSchemaQuery sch r)
parseSchemaReturn VariableMap
vmap FragmentMap
frmap Text
fname SelectionSet
s