{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Data.Morpheus.App.Internal.Resolving.ResolveValue
  ( resolveRef,
    resolveObject,
  )
where

import Control.Monad.Except (MonadError (throwError))
import qualified Data.HashMap.Lazy as HM
import Data.Morpheus.App.Internal.Resolving.ResolverState
  ( ResolverContext (..),
    askFieldTypeName,
    updateCurrentType,
  )
import Data.Morpheus.App.Internal.Resolving.Types
  ( NamedResolver (..),
    NamedResolverRef (..),
    NamedResolverResult (..),
    ObjectTypeResolver (..),
    ResolverMap,
    ResolverValue (..),
    mkEnum,
    mkUnion,
  )
import Data.Morpheus.Error (subfieldsNotSelected)
import Data.Morpheus.Internal.Utils ((<:>), KeyOf (keyOf), selectOr, traverseCollection)
import Data.Morpheus.Types.Internal.AST
  ( GQLError,
    GQLError,
    Msg (msg),
    ObjectEntry (ObjectEntry),
    ScalarValue (..),
    Selection (..),
    SelectionContent (..),
    SelectionSet,
    TypeDefinition (..),
    TypeName,
    UnionTag (unionTagSelection),
    VALID,
    VALID,
    ValidValue,
    ValidValue,
    Value (..),
    internal,
    unitFieldName,
    unitTypeName,
    unpackName,
  )
import Relude

resolveSelection ::
  ( Monad m,
    MonadReader ResolverContext m,
    MonadError GQLError m
  ) =>
  ResolverMap m ->
  ResolverValue m ->
  SelectionContent VALID ->
  m ValidValue
resolveSelection :: ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
resolveSelection ResolverMap m
rmap (ResLazy m (ResolverValue m)
x) SelectionContent VALID
selection =
  m (ResolverValue m)
x m (ResolverValue m)
-> (ResolverValue m -> m ValidValue) -> m ValidValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ResolverValue m -> SelectionContent VALID -> m ValidValue)
-> SelectionContent VALID -> ResolverValue m -> m ValidValue
forall a b c. (a -> b -> c) -> b -> a -> c
flip (ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
forall (m :: * -> *).
(Monad m, MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
resolveSelection ResolverMap m
rmap) SelectionContent VALID
selection
resolveSelection ResolverMap m
rmap (ResList [ResolverValue m]
xs) SelectionContent VALID
selection =
  [ValidValue] -> ValidValue
forall (stage :: Stage). [Value stage] -> Value stage
List ([ValidValue] -> ValidValue) -> m [ValidValue] -> m ValidValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ResolverValue m -> m ValidValue)
-> [ResolverValue m] -> m [ValidValue]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((ResolverValue m -> SelectionContent VALID -> m ValidValue)
-> SelectionContent VALID -> ResolverValue m -> m ValidValue
forall a b c. (a -> b -> c) -> b -> a -> c
flip (ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
forall (m :: * -> *).
(Monad m, MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
resolveSelection ResolverMap m
rmap) SelectionContent VALID
selection) [ResolverValue m]
xs
-- Object -----------------
resolveSelection ResolverMap m
rmap (ResObject Maybe TypeName
tyName ObjectTypeResolver m
obj) SelectionContent VALID
sel = Maybe TypeName
-> (SelectionSet VALID -> m ValidValue)
-> SelectionContent VALID
-> m ValidValue
forall (m :: * -> *) value.
(Monad m, MonadError GQLError m, MonadReader ResolverContext m) =>
Maybe TypeName
-> (SelectionSet VALID -> m value)
-> SelectionContent VALID
-> m value
withObject Maybe TypeName
tyName (ResolverMap m
-> ObjectTypeResolver m -> SelectionSet VALID -> m ValidValue
forall (m :: * -> *).
(MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> ObjectTypeResolver m -> SelectionSet VALID -> m ValidValue
resolveObject ResolverMap m
rmap ObjectTypeResolver m
obj) SelectionContent VALID
sel
-- ENUM
resolveSelection ResolverMap m
_ (ResEnum TypeName
name) SelectionContent VALID
SelectionField = ValidValue -> m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValidValue -> m ValidValue) -> ValidValue -> m ValidValue
forall a b. (a -> b) -> a -> b
$ ScalarValue -> ValidValue
forall (stage :: Stage). ScalarValue -> Value stage
Scalar (ScalarValue -> ValidValue) -> ScalarValue -> ValidValue
forall a b. (a -> b) -> a -> b
$ Text -> ScalarValue
String (Text -> ScalarValue) -> Text -> ScalarValue
forall a b. (a -> b) -> a -> b
$ TypeName -> Text
forall a (t :: NAME). NamePacking a => Name t -> a
unpackName TypeName
name
resolveSelection ResolverMap m
rmap (ResEnum TypeName
name) unionSel :: SelectionContent VALID
unionSel@UnionSelection {} =
  ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
forall (m :: * -> *).
(Monad m, MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
resolveSelection ResolverMap m
rmap (TypeName -> [ResolverEntry m] -> ResolverValue m
forall (m :: * -> *).
Monad m =>
TypeName -> [ResolverEntry m] -> ResolverValue m
mkUnion TypeName
name [(FieldName
unitFieldName, ResolverValue m -> m (ResolverValue m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ResolverValue m -> m (ResolverValue m))
-> ResolverValue m -> m (ResolverValue m)
forall a b. (a -> b) -> a -> b
$ TypeName -> ResolverValue m
forall (m :: * -> *). TypeName -> ResolverValue m
mkEnum TypeName
unitTypeName)]) SelectionContent VALID
unionSel
resolveSelection ResolverMap m
_ ResEnum {} SelectionContent VALID
_ = GQLError -> m ValidValue
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (GQLError -> GQLError
internal GQLError
"wrong selection on enum value")
-- SCALARS
resolveSelection ResolverMap m
_ ResolverValue m
ResNull SelectionContent VALID
_ = ValidValue -> m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure ValidValue
forall (stage :: Stage). Value stage
Null
resolveSelection ResolverMap m
_ (ResScalar ScalarValue
x) SelectionContent VALID
SelectionField = ValidValue -> m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValidValue -> m ValidValue) -> ValidValue -> m ValidValue
forall a b. (a -> b) -> a -> b
$ ScalarValue -> ValidValue
forall (stage :: Stage). ScalarValue -> Value stage
Scalar ScalarValue
x
resolveSelection ResolverMap m
_ ResScalar {} SelectionContent VALID
_ =
  GQLError -> m ValidValue
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (GQLError -> GQLError
internal GQLError
"scalar Resolver should only receive SelectionField")
resolveSelection ResolverMap m
rmap (ResRef m NamedResolverRef
ref) SelectionContent VALID
sel = m NamedResolverRef
ref m NamedResolverRef
-> (NamedResolverRef -> m ValidValue) -> m ValidValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (NamedResolverRef -> SelectionContent VALID -> m ValidValue)
-> SelectionContent VALID -> NamedResolverRef -> m ValidValue
forall a b c. (a -> b -> c) -> b -> a -> c
flip (ResolverMap m
-> NamedResolverRef -> SelectionContent VALID -> m ValidValue
forall (m :: * -> *).
(MonadError GQLError m, MonadReader ResolverContext m) =>
ResolverMap m
-> NamedResolverRef -> SelectionContent VALID -> m ValidValue
resolveRef ResolverMap m
rmap) SelectionContent VALID
sel

withObject ::
  ( Monad m,
    MonadError GQLError m,
    MonadReader ResolverContext m
  ) =>
  Maybe TypeName ->
  (SelectionSet VALID -> m value) ->
  SelectionContent VALID ->
  m value
withObject :: Maybe TypeName
-> (SelectionSet VALID -> m value)
-> SelectionContent VALID
-> m value
withObject Maybe TypeName
__typename SelectionSet VALID -> m value
f = Maybe TypeName -> m value -> m value
forall (m :: * -> *) a.
(MonadReader ResolverContext m, MonadError GQLError m) =>
Maybe TypeName -> m a -> m a
updateCurrentType Maybe TypeName
__typename (m value -> m value)
-> (SelectionContent VALID -> m value)
-> SelectionContent VALID
-> m value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SelectionContent VALID -> m value
checkContent
  where
    checkContent :: SelectionContent VALID -> m value
checkContent (SelectionSet SelectionSet VALID
selection) = SelectionSet VALID -> m value
f SelectionSet VALID
selection
    checkContent (UnionSelection SelectionSet VALID
interface UnionSelection VALID
unionSel) = do
      TypeName
typename <- (ResolverContext -> TypeName) -> m TypeName
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks (TypeDefinition ANY VALID -> TypeName
forall (a :: TypeCategory) (s :: Stage).
TypeDefinition a s -> TypeName
typeName (TypeDefinition ANY VALID -> TypeName)
-> (ResolverContext -> TypeDefinition ANY VALID)
-> ResolverContext
-> TypeName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverContext -> TypeDefinition ANY VALID
currentType)
      MergeMap 'False FieldName (Selection VALID)
selection <- m (MergeMap 'False FieldName (Selection VALID))
-> (UnionTag -> m (MergeMap 'False FieldName (Selection VALID)))
-> TypeName
-> MergeMap 'False TypeName UnionTag
-> m (MergeMap 'False FieldName (Selection VALID))
forall k (c :: * -> *) d a.
IsMap k c =>
d -> (a -> d) -> k -> c a -> d
selectOr (MergeMap 'False FieldName (Selection VALID)
-> m (MergeMap 'False FieldName (Selection VALID))
forall (f :: * -> *) a. Applicative f => a -> f a
pure MergeMap 'False FieldName (Selection VALID)
SelectionSet VALID
interface) ((MergeMap 'False FieldName (Selection VALID)
SelectionSet VALID
interface MergeMap 'False FieldName (Selection VALID)
-> MergeMap 'False FieldName (Selection VALID)
-> m (MergeMap 'False FieldName (Selection VALID))
forall (m :: * -> *) a.
(Merge (HistoryT m) a, Monad m) =>
a -> a -> m a
<:>) (MergeMap 'False FieldName (Selection VALID)
 -> m (MergeMap 'False FieldName (Selection VALID)))
-> (UnionTag -> MergeMap 'False FieldName (Selection VALID))
-> UnionTag
-> m (MergeMap 'False FieldName (Selection VALID))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnionTag -> MergeMap 'False FieldName (Selection VALID)
UnionTag -> SelectionSet VALID
unionTagSelection) TypeName
typename MergeMap 'False TypeName UnionTag
UnionSelection VALID
unionSel
      SelectionSet VALID -> m value
f MergeMap 'False FieldName (Selection VALID)
SelectionSet VALID
selection
    checkContent SelectionContent VALID
_ = do
      Selection VALID
sel <- (ResolverContext -> Selection VALID) -> m (Selection VALID)
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ResolverContext -> Selection VALID
currentSelection
      GQLError -> m value
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (GQLError -> m value) -> GQLError -> m value
forall a b. (a -> b) -> a -> b
$ FieldName -> TypeName -> Position -> GQLError
subfieldsNotSelected (Selection VALID -> FieldName
forall (s :: Stage). Selection s -> FieldName
selectionName Selection VALID
sel) TypeName
"" (Selection VALID -> Position
forall (s :: Stage). Selection s -> Position
selectionPosition Selection VALID
sel)

resolveRef ::
  ( MonadError GQLError m,
    MonadReader ResolverContext m
  ) =>
  ResolverMap m ->
  NamedResolverRef ->
  SelectionContent VALID ->
  m ValidValue
resolveRef :: ResolverMap m
-> NamedResolverRef -> SelectionContent VALID -> m ValidValue
resolveRef ResolverMap m
rmap NamedResolverRef
ref SelectionContent VALID
selection = do
  NamedResolverResult m
namedResolver <- NamedResolverRef -> ResolverMap m -> m (NamedResolverResult m)
forall (m :: * -> *).
MonadError GQLError m =>
NamedResolverRef -> ResolverMap m -> m (NamedResolverResult m)
getNamedResolverBy NamedResolverRef
ref ResolverMap m
rmap
  case NamedResolverResult m
namedResolver of
    NamedObjectResolver ObjectTypeResolver m
res -> Maybe TypeName
-> (SelectionSet VALID -> m ValidValue)
-> SelectionContent VALID
-> m ValidValue
forall (m :: * -> *) value.
(Monad m, MonadError GQLError m, MonadReader ResolverContext m) =>
Maybe TypeName
-> (SelectionSet VALID -> m value)
-> SelectionContent VALID
-> m value
withObject (TypeName -> Maybe TypeName
forall a. a -> Maybe a
Just (NamedResolverRef -> TypeName
resolverTypeName NamedResolverRef
ref)) (ResolverMap m
-> ObjectTypeResolver m -> SelectionSet VALID -> m ValidValue
forall (m :: * -> *).
(MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> ObjectTypeResolver m -> SelectionSet VALID -> m ValidValue
resolveObject ResolverMap m
rmap ObjectTypeResolver m
res) SelectionContent VALID
selection
    NamedUnionResolver NamedResolverRef
unionRef -> ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
forall (m :: * -> *).
(Monad m, MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
resolveSelection ResolverMap m
rmap (m NamedResolverRef -> ResolverValue m
forall (m :: * -> *). m NamedResolverRef -> ResolverValue m
ResRef (m NamedResolverRef -> ResolverValue m)
-> m NamedResolverRef -> ResolverValue m
forall a b. (a -> b) -> a -> b
$ NamedResolverRef -> m NamedResolverRef
forall (f :: * -> *) a. Applicative f => a -> f a
pure NamedResolverRef
unionRef) SelectionContent VALID
selection
    NamedEnumResolver TypeName
value -> ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
forall (m :: * -> *).
(Monad m, MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
resolveSelection ResolverMap m
rmap (TypeName -> ResolverValue m
forall (m :: * -> *). TypeName -> ResolverValue m
ResEnum TypeName
value) SelectionContent VALID
selection

getNamedResolverBy ::
  (MonadError GQLError m) =>
  NamedResolverRef ->
  ResolverMap m ->
  m (NamedResolverResult m)
getNamedResolverBy :: NamedResolverRef -> ResolverMap m -> m (NamedResolverResult m)
getNamedResolverBy NamedResolverRef
ref = m (NamedResolverResult m)
-> (NamedResolver m -> m (NamedResolverResult m))
-> TypeName
-> ResolverMap m
-> m (NamedResolverResult m)
forall k (c :: * -> *) d a.
IsMap k c =>
d -> (a -> d) -> k -> c a -> d
selectOr m (NamedResolverResult m)
cantFoundError ((NamedResolverRef -> ValidValue
resolverArgument NamedResolverRef
ref ValidValue
-> (ValidValue -> m (NamedResolverResult m))
-> m (NamedResolverResult m)
forall a b. a -> (a -> b) -> b
&) ((ValidValue -> m (NamedResolverResult m))
 -> m (NamedResolverResult m))
-> (NamedResolver m -> ValidValue -> m (NamedResolverResult m))
-> NamedResolver m
-> m (NamedResolverResult m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NamedResolver m -> ValidValue -> m (NamedResolverResult m)
forall (m :: * -> *).
NamedResolver m -> ValidValue -> m (NamedResolverResult m)
resolver) (NamedResolverRef -> TypeName
resolverTypeName NamedResolverRef
ref)
  where
    cantFoundError :: m (NamedResolverResult m)
cantFoundError = GQLError -> m (NamedResolverResult m)
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (GQLError
"Resolver Type " GQLError -> GQLError -> GQLError
forall a. Semigroup a => a -> a -> a
<> TypeName -> GQLError
forall a. Msg a => a -> GQLError
msg (NamedResolverRef -> TypeName
resolverTypeName NamedResolverRef
ref) GQLError -> GQLError -> GQLError
forall a. Semigroup a => a -> a -> a
<> GQLError
"can't found")

resolveObject ::
  ( MonadReader ResolverContext m,
    MonadError GQLError m
  ) =>
  ResolverMap m ->
  ObjectTypeResolver m ->
  SelectionSet VALID ->
  m ValidValue
resolveObject :: ResolverMap m
-> ObjectTypeResolver m -> SelectionSet VALID -> m ValidValue
resolveObject ResolverMap m
rmap ObjectTypeResolver m
drv =
  (Object VALID -> ValidValue) -> m (Object VALID) -> m ValidValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Object VALID -> ValidValue
forall (stage :: Stage). Object stage -> Value stage
Object (m (Object VALID) -> m ValidValue)
-> (MergeMap 'False FieldName (Selection VALID)
    -> m (Object VALID))
-> MergeMap 'False FieldName (Selection VALID)
-> m ValidValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Selection VALID -> m (ObjectEntry VALID))
-> MergeMap 'False FieldName (Selection VALID) -> m (Object VALID)
forall (m :: * -> *) k b (map :: * -> * -> *) (t :: * -> *) a.
(Monad m, Failure GQLError m, KeyOf k b, FromList m map k b,
 Foldable t) =>
(a -> m b) -> t a -> m (map k b)
traverseCollection Selection VALID -> m (ObjectEntry VALID)
resolver
  where
    resolver :: Selection VALID -> m (ObjectEntry VALID)
resolver Selection VALID
currentSelection = do
      Maybe TypeName
t <- FieldName -> m (Maybe TypeName)
forall (m :: * -> *).
MonadReader ResolverContext m =>
FieldName -> m (Maybe TypeName)
askFieldTypeName (Selection VALID -> FieldName
forall (s :: Stage). Selection s -> FieldName
selectionName Selection VALID
currentSelection)
      Maybe TypeName -> m (ObjectEntry VALID) -> m (ObjectEntry VALID)
forall (m :: * -> *) a.
(MonadReader ResolverContext m, MonadError GQLError m) =>
Maybe TypeName -> m a -> m a
updateCurrentType Maybe TypeName
t (m (ObjectEntry VALID) -> m (ObjectEntry VALID))
-> m (ObjectEntry VALID) -> m (ObjectEntry VALID)
forall a b. (a -> b) -> a -> b
$ (ResolverContext -> ResolverContext)
-> m (ObjectEntry VALID) -> m (ObjectEntry VALID)
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\ResolverContext
ctx -> ResolverContext
ctx {Selection VALID
currentSelection :: Selection VALID
currentSelection :: Selection VALID
currentSelection}) (m (ObjectEntry VALID) -> m (ObjectEntry VALID))
-> m (ObjectEntry VALID) -> m (ObjectEntry VALID)
forall a b. (a -> b) -> a -> b
$
        FieldName -> ValidValue -> ObjectEntry VALID
forall (s :: Stage). FieldName -> Value s -> ObjectEntry s
ObjectEntry (Selection VALID -> FieldName
forall k a. KeyOf k a => a -> k
keyOf Selection VALID
currentSelection)
          (ValidValue -> ObjectEntry VALID)
-> m ValidValue -> m (ObjectEntry VALID)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ResolverMap m
-> Selection VALID -> ObjectTypeResolver m -> m ValidValue
forall (m :: * -> *).
(Monad m, MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> Selection VALID -> ObjectTypeResolver m -> m ValidValue
runFieldResolver ResolverMap m
rmap Selection VALID
currentSelection ObjectTypeResolver m
drv

runFieldResolver ::
  ( Monad m,
    MonadReader ResolverContext m,
    MonadError GQLError m
  ) =>
  ResolverMap m ->
  Selection VALID ->
  ObjectTypeResolver m ->
  m ValidValue
runFieldResolver :: ResolverMap m
-> Selection VALID -> ObjectTypeResolver m -> m ValidValue
runFieldResolver ResolverMap m
rmap Selection {FieldName
selectionName :: FieldName
selectionName :: forall (s :: Stage). Selection s -> FieldName
selectionName, SelectionContent VALID
selectionContent :: forall (s :: Stage). Selection s -> SelectionContent s
selectionContent :: SelectionContent VALID
selectionContent}
  | FieldName
selectionName FieldName -> FieldName -> Bool
forall a. Eq a => a -> a -> Bool
== FieldName
"__typename" =
    m ValidValue -> ObjectTypeResolver m -> m ValidValue
forall a b. a -> b -> a
const (ScalarValue -> ValidValue
forall (stage :: Stage). ScalarValue -> Value stage
Scalar (ScalarValue -> ValidValue)
-> (TypeName -> ScalarValue) -> TypeName -> ValidValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ScalarValue
String (Text -> ScalarValue)
-> (TypeName -> Text) -> TypeName -> ScalarValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeName -> Text
forall a (t :: NAME). NamePacking a => Name t -> a
unpackName (TypeName -> ValidValue) -> m TypeName -> m ValidValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ResolverContext -> TypeName) -> m TypeName
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks (TypeDefinition ANY VALID -> TypeName
forall (a :: TypeCategory) (s :: Stage).
TypeDefinition a s -> TypeName
typeName (TypeDefinition ANY VALID -> TypeName)
-> (ResolverContext -> TypeDefinition ANY VALID)
-> ResolverContext
-> TypeName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverContext -> TypeDefinition ANY VALID
currentType))
  | Bool
otherwise =
    m ValidValue
-> (m (ResolverValue m) -> m ValidValue)
-> Maybe (m (ResolverValue m))
-> m ValidValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ValidValue -> m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure ValidValue
forall (stage :: Stage). Value stage
Null) (m (ResolverValue m)
-> (ResolverValue m -> m ValidValue) -> m ValidValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ResolverValue m
x -> ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
forall (m :: * -> *).
(Monad m, MonadReader ResolverContext m, MonadError GQLError m) =>
ResolverMap m
-> ResolverValue m -> SelectionContent VALID -> m ValidValue
resolveSelection ResolverMap m
rmap ResolverValue m
x SelectionContent VALID
selectionContent)
      (Maybe (m (ResolverValue m)) -> m ValidValue)
-> (ObjectTypeResolver m -> Maybe (m (ResolverValue m)))
-> ObjectTypeResolver m
-> m ValidValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldName
-> HashMap FieldName (m (ResolverValue m))
-> Maybe (m (ResolverValue m))
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup FieldName
selectionName
      (HashMap FieldName (m (ResolverValue m))
 -> Maybe (m (ResolverValue m)))
-> (ObjectTypeResolver m
    -> HashMap FieldName (m (ResolverValue m)))
-> ObjectTypeResolver m
-> Maybe (m (ResolverValue m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectTypeResolver m -> HashMap FieldName (m (ResolverValue m))
forall (m :: * -> *).
ObjectTypeResolver m -> HashMap FieldName (m (ResolverValue m))
objectFields