{-# LANGUAGE CPP #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Data.Morpheus.Types.Internal.Resolving.Resolver
  ( Resolver,
    LiftOperation,
    lift,
    subscribe,
    ResponseEvent (..),
    ResponseStream,
    ObjectResModel (..),
    ResModel (..),
    WithOperation,
    ResolverContext (..),
    unsafeInternalContext,
    runRootResModel,
    RootResModel (..),
    withArguments,
    getArguments,
    SubscriptionField (..),
    liftResolverState,
  )
where

import Control.Monad.Trans.Reader (mapReaderT)
import qualified Data.HashMap.Lazy as HM
import Data.Morpheus.Error.Selection (subfieldsNotSelected)
import Data.Morpheus.Ext.SemigroupM (SemigroupM (..))
import Data.Morpheus.Internal.Utils
  ( empty,
    keyOf,
    selectOr,
    traverseCollection,
  )
import Data.Morpheus.Types.IO
  ( GQLResponse,
    renderResponse,
  )
import Data.Morpheus.Types.Internal.AST
  ( Arguments,
    FieldName,
    GQLValue (..),
    InternalError,
    MUTATION,
    Message,
    ObjectEntry (..),
    Operation (..),
    OperationType,
    OperationType (..),
    QUERY,
    Ref,
    SUBSCRIPTION,
    ScalarValue (..),
    Selection (..),
    SelectionContent (..),
    SelectionSet,
    TypeName (..),
    UnionSelection,
    UnionTag (..),
    VALID,
    ValidValue,
    Value (..),
    msg,
    toGQLError,
  )
import Data.Morpheus.Types.Internal.Resolving.Core
  ( Eventless,
    Failure (..),
    PushEvents (..),
    Result (..),
    ResultT (..),
    cleanEvents,
    mapEvent,
  )
import Data.Morpheus.Types.Internal.Resolving.Event
  ( EventHandler (..),
    ResponseEvent (..),
  )
import Data.Morpheus.Types.Internal.Resolving.ResolverState
  ( ResolverContext (..),
    ResolverState,
    ResolverStateT (..),
    clearStateResolverEvents,
    resolverFailureMessage,
    runResolverState,
    runResolverStateM,
    runResolverStateT,
    toResolverStateT,
  )
import Relude hiding
  ( Show,
    empty,
    show,
  )
import Prelude (Show (..))

type WithOperation (o :: OperationType) = LiftOperation o

type ResponseStream event (m :: * -> *) = ResultT (ResponseEvent event m) m

data SubscriptionField (a :: *) where
  SubscriptionField ::
    { SubscriptionField a
-> forall e (m :: * -> *) v.
   (a ~ Resolver SUBSCRIPTION e m v) =>
   Channel e
channel :: forall e m v. a ~ Resolver SUBSCRIPTION e m v => Channel e,
      SubscriptionField a -> a
unSubscribe :: a
    } ->
    SubscriptionField a

--
-- GraphQL Field Resolver
--
---------------------------------------------------------------
data Resolver (o :: OperationType) event (m :: * -> *) value where
  ResolverQ :: {Resolver QUERY event m value -> ResolverStateT () m value
runResolverQ :: ResolverStateT () m value} -> Resolver QUERY event m value
  ResolverM :: {Resolver MUTATION event m value -> ResolverStateT event m value
runResolverM :: ResolverStateT event m value} -> Resolver MUTATION event m value
  ResolverS :: {Resolver SUBSCRIPTION event m value
-> ResolverStateT () m (SubEventRes event m value)
runResolverS :: ResolverStateT () m (SubEventRes event m value)} -> Resolver SUBSCRIPTION event m value

type SubEventRes event m value = ReaderT event (ResolverStateT () m) value

instance Show (Resolver o e m value) where
  show :: Resolver o e m value -> String
show ResolverQ {} = String
"Resolver QUERY e m a"
  show ResolverM {} = String
"Resolver MUTATION e m a"
  show ResolverS {} = String
"Resolver SUBSCRIPTION e m a"

deriving instance (Functor m) => Functor (Resolver o e m)

-- Applicative
instance (LiftOperation o, Monad m) => Applicative (Resolver o e m) where
  pure :: a -> Resolver o e m a
pure = ResolverStateT e m a -> Resolver o e m a
forall (o :: OperationType) (m :: * -> *) e a.
(LiftOperation o, Monad m) =>
ResolverStateT e m a -> Resolver o e m a
packResolver (ResolverStateT e m a -> Resolver o e m a)
-> (a -> ResolverStateT e m a) -> a -> Resolver o e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ResolverStateT e m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  ResolverQ ResolverStateT () m (a -> b)
r1 <*> :: Resolver o e m (a -> b) -> Resolver o e m a -> Resolver o e m b
<*> ResolverQ ResolverStateT () m a
r2 = ResolverStateT () m b -> Resolver QUERY e m b
forall (m :: * -> *) value event.
ResolverStateT () m value -> Resolver QUERY event m value
ResolverQ (ResolverStateT () m b -> Resolver QUERY e m b)
-> ResolverStateT () m b -> Resolver QUERY e m b
forall a b. (a -> b) -> a -> b
$ ResolverStateT () m (a -> b)
r1 ResolverStateT () m (a -> b)
-> ResolverStateT () m a -> ResolverStateT () m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ResolverStateT () m a
r2
  ResolverM ResolverStateT e m (a -> b)
r1 <*> ResolverM ResolverStateT e m a
r2 = ResolverStateT e m b -> Resolver MUTATION e m b
forall event (m :: * -> *) value.
ResolverStateT event m value -> Resolver MUTATION event m value
ResolverM (ResolverStateT e m b -> Resolver MUTATION e m b)
-> ResolverStateT e m b -> Resolver MUTATION e m b
forall a b. (a -> b) -> a -> b
$ ResolverStateT e m (a -> b)
r1 ResolverStateT e m (a -> b)
-> ResolverStateT e m a -> ResolverStateT e m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ResolverStateT e m a
r2
  ResolverS ResolverStateT () m (SubEventRes e m (a -> b))
r1 <*> ResolverS ResolverStateT () m (SubEventRes e m a)
r2 = ResolverStateT () m (SubEventRes e m b)
-> Resolver SUBSCRIPTION e m b
forall (m :: * -> *) event value.
ResolverStateT () m (SubEventRes event m value)
-> Resolver SUBSCRIPTION event m value
ResolverS (ResolverStateT () m (SubEventRes e m b)
 -> Resolver SUBSCRIPTION e m b)
-> ResolverStateT () m (SubEventRes e m b)
-> Resolver SUBSCRIPTION e m b
forall a b. (a -> b) -> a -> b
$ SubEventRes e m (a -> b) -> SubEventRes e m a -> SubEventRes e m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>) (SubEventRes e m (a -> b)
 -> SubEventRes e m a -> SubEventRes e m b)
-> ResolverStateT () m (SubEventRes e m (a -> b))
-> ResolverStateT () m (SubEventRes e m a -> SubEventRes e m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ResolverStateT () m (SubEventRes e m (a -> b))
r1 ResolverStateT () m (SubEventRes e m a -> SubEventRes e m b)
-> ResolverStateT () m (SubEventRes e m a)
-> ResolverStateT () m (SubEventRes e m b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ResolverStateT () m (SubEventRes e m a)
r2

-- Monad
instance (Monad m, LiftOperation o) => Monad (Resolver o e m) where
  return :: a -> Resolver o e m a
return = a -> Resolver o e m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  (ResolverQ ResolverStateT () m a
x) >>= :: Resolver o e m a -> (a -> Resolver o e m b) -> Resolver o e m b
>>= a -> Resolver o e m b
m2 = ResolverStateT () m b -> Resolver QUERY e m b
forall (m :: * -> *) value event.
ResolverStateT () m value -> Resolver QUERY event m value
ResolverQ (ResolverStateT () m a
x ResolverStateT () m a
-> (a -> ResolverStateT () m b) -> ResolverStateT () m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Resolver QUERY e m b -> ResolverStateT () m b
forall event (m :: * -> *) value.
Resolver QUERY event m value -> ResolverStateT () m value
runResolverQ (Resolver QUERY e m b -> ResolverStateT () m b)
-> (a -> Resolver QUERY e m b) -> a -> ResolverStateT () m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Resolver o e m b
a -> Resolver QUERY e m b
m2)
  (ResolverM ResolverStateT e m a
x) >>= a -> Resolver o e m b
m2 = ResolverStateT e m b -> Resolver MUTATION e m b
forall event (m :: * -> *) value.
ResolverStateT event m value -> Resolver MUTATION event m value
ResolverM (ResolverStateT e m a
x ResolverStateT e m a
-> (a -> ResolverStateT e m b) -> ResolverStateT e m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Resolver MUTATION e m b -> ResolverStateT e m b
forall event (m :: * -> *) value.
Resolver MUTATION event m value -> ResolverStateT event m value
runResolverM (Resolver MUTATION e m b -> ResolverStateT e m b)
-> (a -> Resolver MUTATION e m b) -> a -> ResolverStateT e m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Resolver o e m b
a -> Resolver MUTATION e m b
m2)
  (ResolverS ResolverStateT () m (SubEventRes e m a)
res) >>= a -> Resolver o e m b
m2 = ResolverStateT () m (SubEventRes e m b)
-> Resolver SUBSCRIPTION e m b
forall (m :: * -> *) event value.
ResolverStateT () m (SubEventRes event m value)
-> Resolver SUBSCRIPTION event m value
ResolverS ((a -> Resolver SUBSCRIPTION e m b)
-> SubEventRes e m a -> SubEventRes e m b
forall (m :: * -> *) t r a.
Monad m =>
(t -> Resolver SUBSCRIPTION r m a)
-> ReaderT r (ResolverStateT () m) t
-> ReaderT r (ResolverStateT () m) a
liftSubResolver a -> Resolver o e m b
a -> Resolver SUBSCRIPTION e m b
m2 (SubEventRes e m a -> SubEventRes e m b)
-> ResolverStateT () m (SubEventRes e m a)
-> ResolverStateT () m (SubEventRes e m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ResolverStateT () m (SubEventRes e m a)
res)

liftSubResolver ::
  (Monad m) =>
  (t -> Resolver SUBSCRIPTION r m a) ->
  ReaderT r (ResolverStateT () m) t ->
  ReaderT r (ResolverStateT () m) a
liftSubResolver :: (t -> Resolver SUBSCRIPTION r m a)
-> ReaderT r (ResolverStateT () m) t
-> ReaderT r (ResolverStateT () m) a
liftSubResolver t -> Resolver SUBSCRIPTION r m a
m2 ReaderT r (ResolverStateT () m) t
readResA = (r -> ResolverStateT () m a) -> ReaderT r (ResolverStateT () m) a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((r -> ResolverStateT () m a) -> ReaderT r (ResolverStateT () m) a)
-> (r -> ResolverStateT () m a)
-> ReaderT r (ResolverStateT () m) a
forall a b. (a -> b) -> a -> b
$ \r
e -> do
  t
a <- ReaderT r (ResolverStateT () m) t -> r -> ResolverStateT () m t
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT r (ResolverStateT () m) t
readResA r
e
  ReaderT r (ResolverStateT () m) a
readResB <- Resolver SUBSCRIPTION r m a
-> ResolverStateT () m (ReaderT r (ResolverStateT () m) a)
forall event (m :: * -> *) value.
Resolver SUBSCRIPTION event m value
-> ResolverStateT () m (SubEventRes event m value)
runResolverS (t -> Resolver SUBSCRIPTION r m a
m2 t
a)
  ReaderT r (ResolverStateT () m) a -> r -> ResolverStateT () m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT r (ResolverStateT () m) a
readResB r
e

-- MonadIO
instance (MonadIO m, LiftOperation o) => MonadIO (Resolver o e m) where
  liftIO :: IO a -> Resolver o e m a
liftIO = m a -> Resolver o e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> Resolver o e m a)
-> (IO a -> m a) -> IO a -> Resolver o e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO

-- Monad Transformers
instance (LiftOperation o) => MonadTrans (Resolver o e) where
  lift :: m a -> Resolver o e m a
lift = ResolverStateT e m a -> Resolver o e m a
forall (o :: OperationType) (m :: * -> *) e a.
(LiftOperation o, Monad m) =>
ResolverStateT e m a -> Resolver o e m a
packResolver (ResolverStateT e m a -> Resolver o e m a)
-> (m a -> ResolverStateT e m a) -> m a -> Resolver o e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> ResolverStateT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

-- Failure
instance (LiftOperation o, Monad m, Failure err (ResolverStateT e m)) => Failure err (Resolver o e m) where
  failure :: err -> Resolver o e m v
failure = ResolverStateT e m v -> Resolver o e m v
forall (o :: OperationType) (m :: * -> *) e a.
(LiftOperation o, Monad m) =>
ResolverStateT e m a -> Resolver o e m a
packResolver (ResolverStateT e m v -> Resolver o e m v)
-> (err -> ResolverStateT e m v) -> err -> Resolver o e m v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. err -> ResolverStateT e m v
forall error (f :: * -> *) v. Failure error f => error -> f v
failure

instance (Monad m, LiftOperation o) => MonadFail (Resolver o e m) where
  fail :: String -> Resolver o e m a
fail = Message -> Resolver o e m a
forall error (f :: * -> *) v. Failure error f => error -> f v
failure (Message -> Resolver o e m a)
-> (String -> Message) -> String -> Resolver o e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Message
forall a. Msg a => a -> Message
msg

-- PushEvents
instance (Monad m) => PushEvents e (Resolver MUTATION e m) where
  pushEvents :: [e] -> Resolver MUTATION e m ()
pushEvents = ResolverStateT e m () -> Resolver MUTATION e m ()
forall (o :: OperationType) (m :: * -> *) e a.
(LiftOperation o, Monad m) =>
ResolverStateT e m a -> Resolver o e m a
packResolver (ResolverStateT e m () -> Resolver MUTATION e m ())
-> ([e] -> ResolverStateT e m ())
-> [e]
-> Resolver MUTATION e m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [e] -> ResolverStateT e m ()
forall e (m :: * -> *). PushEvents e m => [e] -> m ()
pushEvents

instance (Monad m, Semigroup a, LiftOperation o) => Semigroup (Resolver o e m a) where
  Resolver o e m a
x <> :: Resolver o e m a -> Resolver o e m a -> Resolver o e m a
<> Resolver o e m a
y = (a -> a -> a) -> Resolver o e m a -> Resolver o e m (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>) Resolver o e m a
x Resolver o e m (a -> a) -> Resolver o e m a -> Resolver o e m a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Resolver o e m a
y

instance (LiftOperation o, Monad m) => MonadReader ResolverContext (Resolver o e m) where
  ask :: Resolver o e m ResolverContext
ask = ResolverStateT e m ResolverContext
-> Resolver o e m ResolverContext
forall (o :: OperationType) (m :: * -> *) e a.
(LiftOperation o, Monad m) =>
ResolverStateT e m a -> Resolver o e m a
packResolver ResolverStateT e m ResolverContext
forall r (m :: * -> *). MonadReader r m => m r
ask
  local :: (ResolverContext -> ResolverContext)
-> Resolver o e m a -> Resolver o e m a
local ResolverContext -> ResolverContext
f (ResolverQ ResolverStateT () m a
res) = ResolverStateT () m a -> Resolver QUERY e m a
forall (m :: * -> *) value event.
ResolverStateT () m value -> Resolver QUERY event m value
ResolverQ ((ResolverContext -> ResolverContext)
-> ResolverStateT () m a -> ResolverStateT () m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local ResolverContext -> ResolverContext
f ResolverStateT () m a
res)
  local ResolverContext -> ResolverContext
f (ResolverM ResolverStateT e m a
res) = ResolverStateT e m a -> Resolver MUTATION e m a
forall event (m :: * -> *) value.
ResolverStateT event m value -> Resolver MUTATION event m value
ResolverM ((ResolverContext -> ResolverContext)
-> ResolverStateT e m a -> ResolverStateT e m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local ResolverContext -> ResolverContext
f ResolverStateT e m a
res)
  local ResolverContext -> ResolverContext
f (ResolverS ResolverStateT () m (SubEventRes e m a)
resM) = ResolverStateT () m (SubEventRes e m a)
-> Resolver SUBSCRIPTION e m a
forall (m :: * -> *) event value.
ResolverStateT () m (SubEventRes event m value)
-> Resolver SUBSCRIPTION event m value
ResolverS (ResolverStateT () m (SubEventRes e m a)
 -> Resolver SUBSCRIPTION e m a)
-> ResolverStateT () m (SubEventRes e m a)
-> Resolver SUBSCRIPTION e m a
forall a b. (a -> b) -> a -> b
$ (ResolverStateT () m a -> ResolverStateT () m a)
-> SubEventRes e m a -> SubEventRes e m a
forall (m :: * -> *) a (n :: * -> *) b r.
(m a -> n b) -> ReaderT r m a -> ReaderT r n b
mapReaderT ((ResolverContext -> ResolverContext)
-> ResolverStateT () m a -> ResolverStateT () m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local ResolverContext -> ResolverContext
f) (SubEventRes e m a -> SubEventRes e m a)
-> ResolverStateT () m (SubEventRes e m a)
-> ResolverStateT () m (SubEventRes e m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ResolverStateT () m (SubEventRes e m a)
resM

-- | A function to return the internal 'ResolverContext' within a resolver's monad.
-- Using the 'ResolverContext' itself is unsafe because it expposes internal structures
-- of the AST, but you can use the "Data.Morpheus.Types.SelectionTree" typeclass to manipulate
-- the internal AST with a safe interface.
unsafeInternalContext :: (Monad m, LiftOperation o) => Resolver o e m ResolverContext
unsafeInternalContext :: Resolver o e m ResolverContext
unsafeInternalContext = Resolver o e m ResolverContext
forall r (m :: * -> *). MonadReader r m => m r
ask

liftResolverState :: (LiftOperation o, Monad m) => ResolverState a -> Resolver o e m a
liftResolverState :: ResolverState a -> Resolver o e m a
liftResolverState = ResolverStateT e m a -> Resolver o e m a
forall (o :: OperationType) (m :: * -> *) e a.
(LiftOperation o, Monad m) =>
ResolverStateT e m a -> Resolver o e m a
packResolver (ResolverStateT e m a -> Resolver o e m a)
-> (ResolverState a -> ResolverStateT e m a)
-> ResolverState a
-> Resolver o e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverState a -> ResolverStateT e m a
forall (m :: * -> *) a e.
Applicative m =>
ResolverState a -> ResolverStateT e m a
toResolverStateT

class LiftOperation (o :: OperationType) where
  packResolver :: Monad m => ResolverStateT e m a -> Resolver o e m a

instance LiftOperation QUERY where
  packResolver :: ResolverStateT e m a -> Resolver QUERY e m a
packResolver = ResolverStateT () m a -> Resolver QUERY e m a
forall (m :: * -> *) value event.
ResolverStateT () m value -> Resolver QUERY event m value
ResolverQ (ResolverStateT () m a -> Resolver QUERY e m a)
-> (ResolverStateT e m a -> ResolverStateT () m a)
-> ResolverStateT e m a
-> Resolver QUERY e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverStateT e m a -> ResolverStateT () m a
forall (m :: * -> *) e a e'.
Functor m =>
ResolverStateT e m a -> ResolverStateT e' m a
clearStateResolverEvents

instance LiftOperation MUTATION where
  packResolver :: ResolverStateT e m a -> Resolver MUTATION e m a
packResolver = ResolverStateT e m a -> Resolver MUTATION e m a
forall event (m :: * -> *) value.
ResolverStateT event m value -> Resolver MUTATION event m value
ResolverM

instance LiftOperation SUBSCRIPTION where
  packResolver :: ResolverStateT e m a -> Resolver SUBSCRIPTION e m a
packResolver = ResolverStateT () m (SubEventRes e m a)
-> Resolver SUBSCRIPTION e m a
forall (m :: * -> *) event value.
ResolverStateT () m (SubEventRes event m value)
-> Resolver SUBSCRIPTION event m value
ResolverS (ResolverStateT () m (SubEventRes e m a)
 -> Resolver SUBSCRIPTION e m a)
-> (ResolverStateT e m a
    -> ResolverStateT () m (SubEventRes e m a))
-> ResolverStateT e m a
-> Resolver SUBSCRIPTION e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SubEventRes e m a -> ResolverStateT () m (SubEventRes e m a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SubEventRes e m a -> ResolverStateT () m (SubEventRes e m a))
-> (ResolverStateT e m a -> SubEventRes e m a)
-> ResolverStateT e m a
-> ResolverStateT () m (SubEventRes e m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverStateT () m a -> SubEventRes e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ResolverStateT () m a -> SubEventRes e m a)
-> (ResolverStateT e m a -> ResolverStateT () m a)
-> ResolverStateT e m a
-> SubEventRes e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverStateT e m a -> ResolverStateT () m a
forall (m :: * -> *) e a e'.
Functor m =>
ResolverStateT e m a -> ResolverStateT e' m a
clearStateResolverEvents

subscribe ::
  (Monad m) =>
  Channel e ->
  Resolver QUERY e m (e -> Resolver SUBSCRIPTION e m a) ->
  SubscriptionField (Resolver SUBSCRIPTION e m a)
subscribe :: Channel e
-> Resolver QUERY e m (e -> Resolver SUBSCRIPTION e m a)
-> SubscriptionField (Resolver SUBSCRIPTION e m a)
subscribe Channel e
ch Resolver QUERY e m (e -> Resolver SUBSCRIPTION e m a)
res =
  (forall e (m :: * -> *) v.
 (Resolver SUBSCRIPTION e m a ~ Resolver SUBSCRIPTION e m v) =>
 Channel e)
-> Resolver SUBSCRIPTION e m a
-> SubscriptionField (Resolver SUBSCRIPTION e m a)
forall a.
(forall e (m :: * -> *) v.
 (a ~ Resolver SUBSCRIPTION e m v) =>
 Channel e)
-> a -> SubscriptionField a
SubscriptionField Channel e
forall e (m :: * -> *) v.
(Resolver SUBSCRIPTION e m a ~ Resolver SUBSCRIPTION e m v) =>
Channel e
ch
    (Resolver SUBSCRIPTION e m a
 -> SubscriptionField (Resolver SUBSCRIPTION e m a))
-> Resolver SUBSCRIPTION e m a
-> SubscriptionField (Resolver SUBSCRIPTION e m a)
forall a b. (a -> b) -> a -> b
$ ResolverStateT () m (SubEventRes e m a)
-> Resolver SUBSCRIPTION e m a
forall (m :: * -> *) event value.
ResolverStateT () m (SubEventRes event m value)
-> Resolver SUBSCRIPTION event m value
ResolverS
    (ResolverStateT () m (SubEventRes e m a)
 -> Resolver SUBSCRIPTION e m a)
-> ResolverStateT () m (SubEventRes e m a)
-> Resolver SUBSCRIPTION e m a
forall a b. (a -> b) -> a -> b
$ (e -> Resolver SUBSCRIPTION e m a) -> SubEventRes e m a
forall (m :: * -> *) e a.
Monad m =>
(e -> Resolver SUBSCRIPTION e m a)
-> ReaderT e (ResolverStateT () m) a
fromSub ((e -> Resolver SUBSCRIPTION e m a) -> SubEventRes e m a)
-> ResolverStateT () m (e -> Resolver SUBSCRIPTION e m a)
-> ResolverStateT () m (SubEventRes e m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Resolver QUERY e m (e -> Resolver SUBSCRIPTION e m a)
-> ResolverStateT () m (e -> Resolver SUBSCRIPTION e m a)
forall event (m :: * -> *) value.
Resolver QUERY event m value -> ResolverStateT () m value
runResolverQ Resolver QUERY e m (e -> Resolver SUBSCRIPTION e m a)
res
  where
    fromSub :: Monad m => (e -> Resolver SUBSCRIPTION e m a) -> ReaderT e (ResolverStateT () m) a
    fromSub :: (e -> Resolver SUBSCRIPTION e m a)
-> ReaderT e (ResolverStateT () m) a
fromSub e -> Resolver SUBSCRIPTION e m a
f = ReaderT e (ResolverStateT () m) (ReaderT e (ResolverStateT () m) a)
-> ReaderT e (ResolverStateT () m) a
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join ((e -> ResolverStateT () m (ReaderT e (ResolverStateT () m) a))
-> ReaderT
     e (ResolverStateT () m) (ReaderT e (ResolverStateT () m) a)
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT (Resolver SUBSCRIPTION e m a
-> ResolverStateT () m (ReaderT e (ResolverStateT () m) a)
forall event (m :: * -> *) value.
Resolver SUBSCRIPTION event m value
-> ResolverStateT () m (SubEventRes event m value)
runResolverS (Resolver SUBSCRIPTION e m a
 -> ResolverStateT () m (ReaderT e (ResolverStateT () m) a))
-> (e -> Resolver SUBSCRIPTION e m a)
-> e
-> ResolverStateT () m (ReaderT e (ResolverStateT () m) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Resolver SUBSCRIPTION e m a
f))

withArguments ::
  (LiftOperation o, Monad m) =>
  (Arguments VALID -> Resolver o e m a) ->
  Resolver o e m a
withArguments :: (Arguments VALID -> Resolver o e m a) -> Resolver o e m a
withArguments = (Resolver o e m (Arguments VALID)
forall (o :: OperationType) (m :: * -> *) e.
(LiftOperation o, Monad m) =>
Resolver o e m (Arguments VALID)
getArguments Resolver o e m (Arguments VALID)
-> (Arguments VALID -> Resolver o e m a) -> Resolver o e m a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=)

getArguments ::
  (LiftOperation o, Monad m) =>
  Resolver o e m (Arguments VALID)
getArguments :: Resolver o e m (Arguments VALID)
getArguments = Selection VALID -> Arguments VALID
forall (s :: Stage). Selection s -> Arguments s
selectionArguments (Selection VALID -> Arguments VALID)
-> (ResolverContext -> Selection VALID)
-> ResolverContext
-> Arguments VALID
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverContext -> Selection VALID
currentSelection (ResolverContext -> Arguments VALID)
-> Resolver o e m ResolverContext
-> Resolver o e m (Arguments VALID)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Resolver o e m ResolverContext
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
Resolver o e m ResolverContext
unsafeInternalContext

pickSelection :: TypeName -> UnionSelection VALID -> SelectionSet VALID
pickSelection :: TypeName -> UnionSelection VALID -> SelectionSet VALID
pickSelection = SelectionSet VALID
-> (UnionTag -> SelectionSet VALID)
-> TypeName
-> UnionSelection VALID
-> SelectionSet VALID
forall k a c d. Selectable k a c => d -> (a -> d) -> k -> c -> d
selectOr SelectionSet VALID
forall a coll. Collection a coll => coll
empty UnionTag -> SelectionSet VALID
unionTagSelection

withObject ::
  (LiftOperation o, Monad m) =>
  TypeName ->
  (SelectionSet VALID -> Resolver o e m value) ->
  Selection VALID ->
  Resolver o e m value
withObject :: TypeName
-> (SelectionSet VALID -> Resolver o e m value)
-> Selection VALID
-> Resolver o e m value
withObject TypeName
__typename SelectionSet VALID -> Resolver o e m value
f Selection {FieldName
selectionName :: forall (s :: Stage). Selection s -> FieldName
selectionName :: FieldName
selectionName, SelectionContent VALID
selectionContent :: forall (s :: Stage). Selection s -> SelectionContent s
selectionContent :: SelectionContent VALID
selectionContent, Position
selectionPosition :: forall (s :: Stage). Selection s -> Position
selectionPosition :: Position
selectionPosition} = SelectionContent VALID -> Resolver o e m value
checkContent SelectionContent VALID
selectionContent
  where
    checkContent :: SelectionContent VALID -> Resolver o e m value
checkContent (SelectionSet SelectionSet VALID
selection) = SelectionSet VALID -> Resolver o e m value
f SelectionSet VALID
selection
    checkContent (UnionSelection UnionSelection VALID
unionSel) =
      SelectionSet VALID -> Resolver o e m value
f (SelectionSet VALID
-> (UnionTag -> SelectionSet VALID)
-> TypeName
-> UnionSelection VALID
-> SelectionSet VALID
forall k a c d. Selectable k a c => d -> (a -> d) -> k -> c -> d
selectOr SelectionSet VALID
forall a coll. Collection a coll => coll
empty UnionTag -> SelectionSet VALID
unionTagSelection TypeName
__typename UnionSelection VALID
unionSel)
    checkContent SelectionContent VALID
_ = [GQLError] -> Resolver o e m value
forall error (f :: * -> *) v. Failure error f => error -> f v
failure [ValidationError -> GQLError
toGQLError (ValidationError -> GQLError) -> ValidationError -> GQLError
forall a b. (a -> b) -> a -> b
$ FieldName -> TypeName -> Position -> ValidationError
subfieldsNotSelected FieldName
selectionName TypeName
"" Position
selectionPosition]

lookupRes ::
  (LiftOperation o, Monad m) =>
  Selection VALID ->
  ObjectResModel o e m ->
  Resolver o e m ValidValue
lookupRes :: Selection VALID
-> ObjectResModel o e m -> Resolver o e m ValidValue
lookupRes Selection {FieldName
selectionName :: FieldName
selectionName :: forall (s :: Stage). Selection s -> FieldName
selectionName}
  | FieldName
selectionName FieldName -> FieldName -> Bool
forall a. Eq a => a -> a -> Bool
== FieldName
"__typename" =
    ValidValue -> Resolver o e m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValidValue -> Resolver o e m ValidValue)
-> (ObjectResModel o e m -> ValidValue)
-> ObjectResModel o e m
-> Resolver o e m ValidValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScalarValue -> ValidValue
forall (stage :: Stage). ScalarValue -> Value stage
Scalar (ScalarValue -> ValidValue)
-> (ObjectResModel o e m -> ScalarValue)
-> ObjectResModel o e m
-> ValidValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ScalarValue
String (Text -> ScalarValue)
-> (ObjectResModel o e m -> Text)
-> ObjectResModel o e m
-> ScalarValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeName -> Text
readTypeName (TypeName -> Text)
-> (ObjectResModel o e m -> TypeName)
-> ObjectResModel o e m
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectResModel o e m -> TypeName
forall (o :: OperationType) e (m :: * -> *).
ObjectResModel o e m -> TypeName
__typename
  | Bool
otherwise =
    Resolver o e m ValidValue
-> (Resolver o e m (ResModel o e m) -> Resolver o e m ValidValue)
-> Maybe (Resolver o e m (ResModel o e m))
-> Resolver o e m ValidValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
      (ValidValue -> Resolver o e m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure ValidValue
forall a. GQLValue a => a
gqlNull)
      (Resolver o e m (ResModel o e m)
-> (ResModel o e m -> Resolver o e m ValidValue)
-> Resolver o e m ValidValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ResModel o e m -> Resolver o e m ValidValue
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
ResModel o e m -> Resolver o e m ValidValue
runDataResolver)
      (Maybe (Resolver o e m (ResModel o e m))
 -> Resolver o e m ValidValue)
-> (ObjectResModel o e m
    -> Maybe (Resolver o e m (ResModel o e m)))
-> ObjectResModel o e m
-> Resolver o e m ValidValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldName
-> HashMap FieldName (Resolver o e m (ResModel o e m))
-> Maybe (Resolver o e m (ResModel o e m))
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup FieldName
selectionName
      (HashMap FieldName (Resolver o e m (ResModel o e m))
 -> Maybe (Resolver o e m (ResModel o e m)))
-> (ObjectResModel o e m
    -> HashMap FieldName (Resolver o e m (ResModel o e m)))
-> ObjectResModel o e m
-> Maybe (Resolver o e m (ResModel o e m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectResModel o e m
-> HashMap FieldName (Resolver o e m (ResModel o e m))
forall (o :: OperationType) e (m :: * -> *).
ObjectResModel o e m
-> HashMap FieldName (Resolver o e m (ResModel o e m))
objectFields

resolveObject ::
  forall o e m.
  (LiftOperation o, Monad m) =>
  SelectionSet VALID ->
  ResModel o e m ->
  Resolver o e m ValidValue
resolveObject :: SelectionSet VALID -> ResModel o e m -> Resolver o e m ValidValue
resolveObject SelectionSet VALID
selectionSet (ResObject drv :: ObjectResModel o e m
drv@ObjectResModel {TypeName
__typename :: TypeName
__typename :: forall (o :: OperationType) e (m :: * -> *).
ObjectResModel o e m -> TypeName
__typename}) =
  Object VALID -> ValidValue
forall (stage :: Stage). Object stage -> Value stage
Object (Object VALID -> ValidValue)
-> Resolver o e m (Object VALID) -> Resolver o e m ValidValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Selection VALID -> Resolver o e m (ObjectEntry VALID))
-> SelectionSet VALID -> Resolver o e m (Object VALID)
forall (f :: * -> *) k b a (t :: * -> *) (t' :: * -> *).
(Monad f, KeyOf k b, Elems a (t a), FromElems f b (t' b),
 Failure ValidationErrors f) =>
(a -> f b) -> t a -> f (t' b)
traverseCollection Selection VALID -> Resolver o e m (ObjectEntry VALID)
resolver SelectionSet VALID
selectionSet
  where
    resolver :: Selection VALID -> Resolver o e m (ObjectEntry VALID)
    resolver :: Selection VALID -> Resolver o e m (ObjectEntry VALID)
resolver Selection VALID
currentSelection =
      (ResolverContext -> ResolverContext)
-> Resolver o e m (ObjectEntry VALID)
-> Resolver o e 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, currentTypeName :: TypeName
currentTypeName = TypeName
__typename}) (Resolver o e m (ObjectEntry VALID)
 -> Resolver o e m (ObjectEntry VALID))
-> Resolver o e m (ObjectEntry VALID)
-> Resolver o e 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)
-> Resolver o e m ValidValue -> Resolver o e m (ObjectEntry VALID)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Selection VALID
-> ObjectResModel o e m -> Resolver o e m ValidValue
forall (o :: OperationType) (m :: * -> *) e.
(LiftOperation o, Monad m) =>
Selection VALID
-> ObjectResModel o e m -> Resolver o e m ValidValue
lookupRes Selection VALID
currentSelection ObjectResModel o e m
drv
resolveObject SelectionSet VALID
_ ResModel o e m
_ = ResolverStateT e m ValidValue -> Resolver o e m ValidValue
forall (o :: OperationType) (m :: * -> *) e a.
(LiftOperation o, Monad m) =>
ResolverStateT e m a -> Resolver o e m a
packResolver (ResolverStateT e m ValidValue -> Resolver o e m ValidValue)
-> ResolverStateT e m ValidValue -> Resolver o e m ValidValue
forall a b. (a -> b) -> a -> b
$ InternalError -> ResolverStateT e m ValidValue
forall error (f :: * -> *) v. Failure error f => error -> f v
failure (InternalError
"expected object as resolver" :: InternalError)

runDataResolver :: (Monad m, LiftOperation o) => ResModel o e m -> Resolver o e m ValidValue
runDataResolver :: ResModel o e m -> Resolver o e m ValidValue
runDataResolver ResModel o e m
res = (ResolverContext -> Selection VALID)
-> Resolver o e m (Selection VALID)
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ResolverContext -> Selection VALID
currentSelection Resolver o e m (Selection VALID)
-> (Selection VALID -> Resolver o e m ValidValue)
-> Resolver o e m ValidValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ResModel o e m -> Selection VALID -> Resolver o e m ValidValue
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
ResModel o e m -> Selection VALID -> Resolver o e m ValidValue
__encode ResModel o e m
res
  where
    __encode :: ResModel o e m -> Selection VALID -> Resolver o e m ValidValue
__encode ResModel o e m
obj sel :: Selection VALID
sel@Selection {SelectionContent VALID
selectionContent :: SelectionContent VALID
selectionContent :: forall (s :: Stage). Selection s -> SelectionContent s
selectionContent} = ResModel o e m
-> SelectionContent VALID -> Resolver o e m ValidValue
encodeNode ResModel o e m
obj SelectionContent VALID
selectionContent
      where
        -- LIST
        encodeNode :: ResModel o e m
-> SelectionContent VALID -> Resolver o e m ValidValue
encodeNode (ResList [ResModel o e m]
x) SelectionContent VALID
_ = [ValidValue] -> ValidValue
forall (stage :: Stage). [Value stage] -> Value stage
List ([ValidValue] -> ValidValue)
-> Resolver o e m [ValidValue] -> Resolver o e m ValidValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ResModel o e m -> Resolver o e m ValidValue)
-> [ResModel o e m] -> Resolver o e m [ValidValue]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ResModel o e m -> Resolver o e m ValidValue
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
ResModel o e m -> Resolver o e m ValidValue
runDataResolver [ResModel o e m]
x
        -- Object -----------------
        encodeNode objDrv :: ResModel o e m
objDrv@(ResObject ObjectResModel {TypeName
__typename :: TypeName
__typename :: forall (o :: OperationType) e (m :: * -> *).
ObjectResModel o e m -> TypeName
__typename}) SelectionContent VALID
_ = TypeName
-> (SelectionSet VALID -> Resolver o e m ValidValue)
-> Selection VALID
-> Resolver o e m ValidValue
forall (o :: OperationType) (m :: * -> *) e value.
(LiftOperation o, Monad m) =>
TypeName
-> (SelectionSet VALID -> Resolver o e m value)
-> Selection VALID
-> Resolver o e m value
withObject TypeName
__typename (SelectionSet VALID -> ResModel o e m -> Resolver o e m ValidValue
forall (o :: OperationType) e (m :: * -> *).
(LiftOperation o, Monad m) =>
SelectionSet VALID -> ResModel o e m -> Resolver o e m ValidValue
`resolveObject` ResModel o e m
objDrv) Selection VALID
sel
        -- ENUM
        encodeNode (ResEnum TypeName
_ TypeName
enum) SelectionContent VALID
SelectionField = ValidValue -> Resolver o e m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValidValue -> Resolver o e m ValidValue)
-> ValidValue -> Resolver o e m ValidValue
forall a b. (a -> b) -> a -> b
$ Text -> ValidValue
forall a. GQLValue a => Text -> a
gqlString (Text -> ValidValue) -> Text -> ValidValue
forall a b. (a -> b) -> a -> b
$ TypeName -> Text
readTypeName TypeName
enum
        encodeNode (ResEnum TypeName
typename TypeName
enum) unionSel :: SelectionContent VALID
unionSel@UnionSelection {} =
          ResModel o e m
-> SelectionContent VALID -> Resolver o e m ValidValue
encodeNode (TypeName -> ResModel o e m
unionDrv (TypeName
typename TypeName -> TypeName -> TypeName
forall a. Semigroup a => a -> a -> a
<> TypeName
"EnumObject")) SelectionContent VALID
unionSel
          where
            unionDrv :: TypeName -> ResModel o e m
unionDrv TypeName
name =
              TypeName -> Resolver o e m (ResModel o e m) -> ResModel o e m
forall (o :: OperationType) e (m :: * -> *).
TypeName -> Resolver o e m (ResModel o e m) -> ResModel o e m
ResUnion TypeName
name
                (Resolver o e m (ResModel o e m) -> ResModel o e m)
-> Resolver o e m (ResModel o e m) -> ResModel o e m
forall a b. (a -> b) -> a -> b
$ ResModel o e m -> Resolver o e m (ResModel o e m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure
                (ResModel o e m -> Resolver o e m (ResModel o e m))
-> ResModel o e m -> Resolver o e m (ResModel o e m)
forall a b. (a -> b) -> a -> b
$ ObjectResModel o e m -> ResModel o e m
forall (o :: OperationType) e (m :: * -> *).
ObjectResModel o e m -> ResModel o e m
ResObject
                (ObjectResModel o e m -> ResModel o e m)
-> ObjectResModel o e m -> ResModel o e m
forall a b. (a -> b) -> a -> b
$ TypeName
-> HashMap FieldName (Resolver o e m (ResModel o e m))
-> ObjectResModel o e m
forall (o :: OperationType) e (m :: * -> *).
TypeName
-> HashMap FieldName (Resolver o e m (ResModel o e m))
-> ObjectResModel o e m
ObjectResModel TypeName
name
                (HashMap FieldName (Resolver o e m (ResModel o e m))
 -> ObjectResModel o e m)
-> HashMap FieldName (Resolver o e m (ResModel o e m))
-> ObjectResModel o e m
forall a b. (a -> b) -> a -> b
$ FieldName
-> Resolver o e m (ResModel o e m)
-> HashMap FieldName (Resolver o e m (ResModel o e m))
forall k v. Hashable k => k -> v -> HashMap k v
HM.singleton FieldName
"enum" (ResModel o e m -> Resolver o e m (ResModel o e m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ResModel o e m -> Resolver o e m (ResModel o e m))
-> ResModel o e m -> Resolver o e m (ResModel o e m)
forall a b. (a -> b) -> a -> b
$ ScalarValue -> ResModel o e m
forall (o :: OperationType) e (m :: * -> *).
ScalarValue -> ResModel o e m
ResScalar (ScalarValue -> ResModel o e m) -> ScalarValue -> ResModel o e m
forall a b. (a -> b) -> a -> b
$ Text -> ScalarValue
String (Text -> ScalarValue) -> Text -> ScalarValue
forall a b. (a -> b) -> a -> b
$ TypeName -> Text
readTypeName TypeName
enum)
        encodeNode ResEnum {} SelectionContent VALID
_ = Message -> Resolver o e m ValidValue
forall error (f :: * -> *) v. Failure error f => error -> f v
failure (Message
"wrong selection on enum value" :: Message)
        -- UNION
        encodeNode (ResUnion TypeName
typename Resolver o e m (ResModel o e m)
unionRef) (UnionSelection UnionSelection VALID
selections) =
          Resolver o e m (ResModel o e m)
unionRef Resolver o e m (ResModel o e m)
-> (ResModel o e m -> Resolver o e m ValidValue)
-> Resolver o e m ValidValue
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SelectionSet VALID -> ResModel o e m -> Resolver o e m ValidValue
forall (o :: OperationType) e (m :: * -> *).
(LiftOperation o, Monad m) =>
SelectionSet VALID -> ResModel o e m -> Resolver o e m ValidValue
resolveObject SelectionSet VALID
currentSelection
          where
            currentSelection :: SelectionSet VALID
currentSelection = TypeName -> UnionSelection VALID -> SelectionSet VALID
pickSelection TypeName
typename UnionSelection VALID
selections
        encodeNode (ResUnion TypeName
name Resolver o e m (ResModel o e m)
_) SelectionContent VALID
_ =
          Message -> Resolver o e m ValidValue
forall error (f :: * -> *) v. Failure error f => error -> f v
failure (Message
"union Resolver " Message -> Message -> Message
forall a. Semigroup a => a -> a -> a
<> TypeName -> Message
forall a. Msg a => a -> Message
msg TypeName
name Message -> Message -> Message
forall a. Semigroup a => a -> a -> a
<> Message
" should only recieve UnionSelection")
        -- SCALARS
        encodeNode ResModel o e m
ResNull SelectionContent VALID
_ = ValidValue -> Resolver o e m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure ValidValue
forall (stage :: Stage). Value stage
Null
        encodeNode (ResScalar ScalarValue
x) SelectionContent VALID
SelectionField = ValidValue -> Resolver o e m ValidValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ValidValue -> Resolver o e m ValidValue)
-> ValidValue -> Resolver o e m ValidValue
forall a b. (a -> b) -> a -> b
$ ScalarValue -> ValidValue
forall (stage :: Stage). ScalarValue -> Value stage
Scalar ScalarValue
x
        encodeNode ResScalar {} SelectionContent VALID
_ =
          Message -> Resolver o e m ValidValue
forall error (f :: * -> *) v. Failure error f => error -> f v
failure (Message
"scalar Resolver should only recieve SelectionField" :: Message)

runResolver ::
  Monad m =>
  Maybe (Selection VALID -> ResolverState (Channel event)) ->
  Resolver o event m ValidValue ->
  ResolverContext ->
  ResponseStream event m ValidValue
runResolver :: Maybe (Selection VALID -> ResolverState (Channel event))
-> Resolver o event m ValidValue
-> ResolverContext
-> ResponseStream event m ValidValue
runResolver Maybe (Selection VALID -> ResolverState (Channel event))
_ (ResolverQ ResolverStateT () m ValidValue
resT) ResolverContext
sel = ResultT () m ValidValue -> ResponseStream event m ValidValue
forall (m :: * -> *) e a e'.
Functor m =>
ResultT e m a -> ResultT e' m a
cleanEvents (ResultT () m ValidValue -> ResponseStream event m ValidValue)
-> ResultT () m ValidValue -> ResponseStream event m ValidValue
forall a b. (a -> b) -> a -> b
$ ResolverStateT () m ValidValue
-> ResolverContext -> ResultT () m ValidValue
forall e (m :: * -> *) a.
ResolverStateT e m a -> ResolverContext -> ResultT e m a
runResolverStateT ResolverStateT () m ValidValue
resT ResolverContext
sel
runResolver Maybe (Selection VALID -> ResolverState (Channel event))
_ (ResolverM ResolverStateT event m ValidValue
resT) ResolverContext
sel = (event -> ResponseEvent event m)
-> ResultT event m ValidValue -> ResponseStream event m ValidValue
forall (m :: * -> *) e e' value.
Monad m =>
(e -> e') -> ResultT e m value -> ResultT e' m value
mapEvent event -> ResponseEvent event m
forall event (m :: * -> *). event -> ResponseEvent event m
Publish (ResultT event m ValidValue -> ResponseStream event m ValidValue)
-> ResultT event m ValidValue -> ResponseStream event m ValidValue
forall a b. (a -> b) -> a -> b
$ ResolverStateT event m ValidValue
-> ResolverContext -> ResultT event m ValidValue
forall e (m :: * -> *) a.
ResolverStateT e m a -> ResolverContext -> ResultT e m a
runResolverStateT ResolverStateT event m ValidValue
resT ResolverContext
sel
runResolver Maybe (Selection VALID -> ResolverState (Channel event))
toChannel (ResolverS ResolverStateT () m (SubEventRes event m ValidValue)
resT) ResolverContext
ctx = m (Result (ResponseEvent event m) ValidValue)
-> ResponseStream event m ValidValue
forall event (m :: * -> *) a.
m (Result event a) -> ResultT event m a
ResultT (m (Result (ResponseEvent event m) ValidValue)
 -> ResponseStream event m ValidValue)
-> m (Result (ResponseEvent event m) ValidValue)
-> ResponseStream event m ValidValue
forall a b. (a -> b) -> a -> b
$ do
  Result () (SubEventRes event m ValidValue)
readResValue <- ResolverStateT () m (SubEventRes event m ValidValue)
-> ResolverContext
-> m (Result () (SubEventRes event m ValidValue))
forall e (m :: * -> *) a.
ResolverStateT e m a -> ResolverContext -> m (Result e a)
runResolverStateM ResolverStateT () m (SubEventRes event m ValidValue)
resT ResolverContext
ctx
  Result (ResponseEvent event m) ValidValue
-> m (Result (ResponseEvent event m) ValidValue)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Result (ResponseEvent event m) ValidValue
 -> m (Result (ResponseEvent event m) ValidValue))
-> Result (ResponseEvent event m) ValidValue
-> m (Result (ResponseEvent event m) ValidValue)
forall a b. (a -> b) -> a -> b
$ case Result () (SubEventRes event m ValidValue)
readResValue Result () (SubEventRes event m ValidValue)
-> (SubEventRes event m ValidValue
    -> Result () (ResponseEvent event m))
-> Result () (ResponseEvent event m)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ResolverContext
-> Maybe (Selection VALID -> ResolverState (Channel event))
-> (event -> m GQLResponse)
-> Result () (ResponseEvent event m)
forall e (m :: * -> *).
ResolverContext
-> Maybe (Selection VALID -> ResolverState (Channel e))
-> (e -> m GQLResponse)
-> Eventless (ResponseEvent e m)
subscriptionEvents ResolverContext
ctx Maybe (Selection VALID -> ResolverState (Channel event))
toChannel ((event -> m GQLResponse) -> Result () (ResponseEvent event m))
-> (SubEventRes event m ValidValue -> event -> m GQLResponse)
-> SubEventRes event m ValidValue
-> Result () (ResponseEvent event m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverContext
-> SubEventRes event m ValidValue -> event -> m GQLResponse
forall (m :: * -> *) event.
Monad m =>
ResolverContext
-> SubEventRes event m ValidValue -> event -> m GQLResponse
toEventResolver ResolverContext
ctx of
    Failure [GQLError]
x -> [GQLError] -> Result (ResponseEvent event m) ValidValue
forall events a. [GQLError] -> Result events a
Failure [GQLError]
x
    Success {[GQLError]
warnings :: forall events a. Result events a -> [GQLError]
warnings :: [GQLError]
warnings, ResponseEvent event m
result :: forall events a. Result events a -> a
result :: ResponseEvent event m
result} ->
      Success :: forall events a. a -> [GQLError] -> [events] -> Result events a
Success
        { events :: [ResponseEvent event m]
events = [ResponseEvent event m
result],
          [GQLError]
warnings :: [GQLError]
warnings :: [GQLError]
warnings,
          result :: ValidValue
result = ValidValue
forall a. GQLValue a => a
gqlNull
        }

toEventResolver :: Monad m => ResolverContext -> SubEventRes event m ValidValue -> (event -> m GQLResponse)
toEventResolver :: ResolverContext
-> SubEventRes event m ValidValue -> event -> m GQLResponse
toEventResolver ResolverContext
sel (ReaderT event -> ResolverStateT () m ValidValue
subRes) event
event = Result () ValidValue -> GQLResponse
forall e. Result e ValidValue -> GQLResponse
renderResponse (Result () ValidValue -> GQLResponse)
-> m (Result () ValidValue) -> m GQLResponse
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ResolverStateT () m ValidValue
-> ResolverContext -> m (Result () ValidValue)
forall e (m :: * -> *) a.
ResolverStateT e m a -> ResolverContext -> m (Result e a)
runResolverStateM (event -> ResolverStateT () m ValidValue
subRes event
event) ResolverContext
sel

subscriptionEvents ::
  ResolverContext ->
  Maybe (Selection VALID -> ResolverState (Channel e)) ->
  (e -> m GQLResponse) ->
  Eventless (ResponseEvent e m)
subscriptionEvents :: ResolverContext
-> Maybe (Selection VALID -> ResolverState (Channel e))
-> (e -> m GQLResponse)
-> Eventless (ResponseEvent e m)
subscriptionEvents ctx :: ResolverContext
ctx@ResolverContext {Selection VALID
currentSelection :: Selection VALID
currentSelection :: ResolverContext -> Selection VALID
currentSelection} (Just Selection VALID -> ResolverState (Channel e)
channelGenerator) e -> m GQLResponse
res =
  ResolverState (ResponseEvent e m)
-> ResolverContext -> Eventless (ResponseEvent e m)
forall a. ResolverState a -> ResolverContext -> Eventless a
runResolverState ResolverState (ResponseEvent e m)
handle ResolverContext
ctx
  where
    handle :: ResolverState (ResponseEvent e m)
handle = do
      Channel e
channel <- Selection VALID -> ResolverState (Channel e)
channelGenerator Selection VALID
currentSelection
      ResponseEvent e m -> ResolverState (ResponseEvent e m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ResponseEvent e m -> ResolverState (ResponseEvent e m))
-> ResponseEvent e m -> ResolverState (ResponseEvent e m)
forall a b. (a -> b) -> a -> b
$ Channel e -> (e -> m GQLResponse) -> ResponseEvent e m
forall event (m :: * -> *).
Channel event -> (event -> m GQLResponse) -> ResponseEvent event m
Subscribe Channel e
channel e -> m GQLResponse
res
subscriptionEvents ResolverContext
ctx Maybe (Selection VALID -> ResolverState (Channel e))
Nothing e -> m GQLResponse
_ = [GQLError] -> Eventless (ResponseEvent e m)
forall error (f :: * -> *) v. Failure error f => error -> f v
failure [ResolverContext -> Message -> GQLError
resolverFailureMessage ResolverContext
ctx Message
"channel Resolver is not defined"]

-- Resolver Models -------------------------------------------------------------------

data ObjectResModel o e m = ObjectResModel
  { ObjectResModel o e m -> TypeName
__typename :: TypeName,
    ObjectResModel o e m
-> HashMap FieldName (Resolver o e m (ResModel o e m))
objectFields :: HashMap FieldName (Resolver o e m (ResModel o e m))
  }
  deriving (Int -> ObjectResModel o e m -> ShowS
[ObjectResModel o e m] -> ShowS
ObjectResModel o e m -> String
(Int -> ObjectResModel o e m -> ShowS)
-> (ObjectResModel o e m -> String)
-> ([ObjectResModel o e m] -> ShowS)
-> Show (ObjectResModel o e m)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (o :: OperationType) e (m :: * -> *).
Int -> ObjectResModel o e m -> ShowS
forall (o :: OperationType) e (m :: * -> *).
[ObjectResModel o e m] -> ShowS
forall (o :: OperationType) e (m :: * -> *).
ObjectResModel o e m -> String
showList :: [ObjectResModel o e m] -> ShowS
$cshowList :: forall (o :: OperationType) e (m :: * -> *).
[ObjectResModel o e m] -> ShowS
show :: ObjectResModel o e m -> String
$cshow :: forall (o :: OperationType) e (m :: * -> *).
ObjectResModel o e m -> String
showsPrec :: Int -> ObjectResModel o e m -> ShowS
$cshowsPrec :: forall (o :: OperationType) e (m :: * -> *).
Int -> ObjectResModel o e m -> ShowS
Show)

instance
  ( Monad m,
    Applicative f,
    LiftOperation o
  ) =>
  SemigroupM f (ObjectResModel o e m)
  where
  mergeM :: [Ref]
-> ObjectResModel o e m
-> ObjectResModel o e m
-> f (ObjectResModel o e m)
mergeM [Ref]
path (ObjectResModel TypeName
tyname HashMap FieldName (Resolver o e m (ResModel o e m))
x) (ObjectResModel TypeName
_ HashMap FieldName (Resolver o e m (ResModel o e m))
y) =
    ObjectResModel o e m -> f (ObjectResModel o e m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ObjectResModel o e m -> f (ObjectResModel o e m))
-> ObjectResModel o e m -> f (ObjectResModel o e m)
forall a b. (a -> b) -> a -> b
$ TypeName
-> HashMap FieldName (Resolver o e m (ResModel o e m))
-> ObjectResModel o e m
forall (o :: OperationType) e (m :: * -> *).
TypeName
-> HashMap FieldName (Resolver o e m (ResModel o e m))
-> ObjectResModel o e m
ObjectResModel TypeName
tyname ((Resolver o e m (ResModel o e m)
 -> Resolver o e m (ResModel o e m)
 -> Resolver o e m (ResModel o e m))
-> HashMap FieldName (Resolver o e m (ResModel o e m))
-> HashMap FieldName (Resolver o e m (ResModel o e m))
-> HashMap FieldName (Resolver o e m (ResModel o e m))
forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> HashMap k v -> HashMap k v -> HashMap k v
HM.unionWith ([Ref]
-> Resolver o e m (ResModel o e m)
-> Resolver o e m (ResModel o e m)
-> Resolver o e m (ResModel o e m)
forall (m :: * -> *) e a (o :: OperationType).
(Monad m, SemigroupM (ResolverStateT e m) a, LiftOperation o) =>
[Ref] -> Resolver o e m a -> Resolver o e m a -> Resolver o e m a
mergeResolver [Ref]
path) HashMap FieldName (Resolver o e m (ResModel o e m))
x HashMap FieldName (Resolver o e m (ResModel o e m))
y)

mergeResolver ::
  (Monad m, SemigroupM (ResolverStateT e m) a, LiftOperation o) =>
  [Ref] ->
  Resolver o e m a ->
  Resolver o e m a ->
  Resolver o e m a
mergeResolver :: [Ref] -> Resolver o e m a -> Resolver o e m a -> Resolver o e m a
mergeResolver [Ref]
path Resolver o e m a
a Resolver o e m a
b = do
  a
a' <- Resolver o e m a
a
  Resolver o e m a
b Resolver o e m a -> (a -> Resolver o e m a) -> Resolver o e m a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ResolverStateT e m a -> Resolver o e m a
forall (o :: OperationType) (m :: * -> *) e a.
(LiftOperation o, Monad m) =>
ResolverStateT e m a -> Resolver o e m a
packResolver (ResolverStateT e m a -> Resolver o e m a)
-> (a -> ResolverStateT e m a) -> a -> Resolver o e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Ref] -> a -> a -> ResolverStateT e m a
forall (m :: * -> *) a. SemigroupM m a => [Ref] -> a -> a -> m a
mergeM [Ref]
path a
a'

data ResModel (o :: OperationType) e (m :: * -> *)
  = ResNull
  | ResScalar ScalarValue
  | ResEnum TypeName TypeName
  | ResObject (ObjectResModel o e m)
  | ResList [ResModel o e m]
  | ResUnion TypeName (Resolver o e m (ResModel o e m))
  deriving (Int -> ResModel o e m -> ShowS
[ResModel o e m] -> ShowS
ResModel o e m -> String
(Int -> ResModel o e m -> ShowS)
-> (ResModel o e m -> String)
-> ([ResModel o e m] -> ShowS)
-> Show (ResModel o e m)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (o :: OperationType) e (m :: * -> *).
Int -> ResModel o e m -> ShowS
forall (o :: OperationType) e (m :: * -> *).
[ResModel o e m] -> ShowS
forall (o :: OperationType) e (m :: * -> *).
ResModel o e m -> String
showList :: [ResModel o e m] -> ShowS
$cshowList :: forall (o :: OperationType) e (m :: * -> *).
[ResModel o e m] -> ShowS
show :: ResModel o e m -> String
$cshow :: forall (o :: OperationType) e (m :: * -> *).
ResModel o e m -> String
showsPrec :: Int -> ResModel o e m -> ShowS
$cshowsPrec :: forall (o :: OperationType) e (m :: * -> *).
Int -> ResModel o e m -> ShowS
Show)

instance
  ( Monad f,
    Monad m,
    LiftOperation o,
    Failure InternalError f
  ) =>
  SemigroupM f (ResModel o e m)
  where
  mergeM :: [Ref] -> ResModel o e m -> ResModel o e m -> f (ResModel o e m)
mergeM [Ref]
_ ResModel o e m
ResNull ResModel o e m
ResNull = ResModel o e m -> f (ResModel o e m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ResModel o e m
forall (o :: OperationType) e (m :: * -> *). ResModel o e m
ResNull
  mergeM [Ref]
_ ResScalar {} x :: ResModel o e m
x@ResScalar {} = ResModel o e m -> f (ResModel o e m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ResModel o e m
x
  mergeM [Ref]
_ ResEnum {} x :: ResModel o e m
x@ResEnum {} = ResModel o e m -> f (ResModel o e m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ResModel o e m
x
  mergeM [Ref]
p (ResObject ObjectResModel o e m
x) (ResObject ObjectResModel o e m
y) = ObjectResModel o e m -> ResModel o e m
forall (o :: OperationType) e (m :: * -> *).
ObjectResModel o e m -> ResModel o e m
ResObject (ObjectResModel o e m -> ResModel o e m)
-> f (ObjectResModel o e m) -> f (ResModel o e m)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Ref]
-> ObjectResModel o e m
-> ObjectResModel o e m
-> f (ObjectResModel o e m)
forall (m :: * -> *) a. SemigroupM m a => [Ref] -> a -> a -> m a
mergeM [Ref]
p ObjectResModel o e m
x ObjectResModel o e m
y
  mergeM [Ref]
_ ResModel o e m
_ ResModel o e m
_ = InternalError -> f (ResModel o e m)
forall error (f :: * -> *) v. Failure error f => error -> f v
failure (InternalError
"can't merge: incompatible resolvers" :: InternalError)

data RootResModel e m = RootResModel
  { RootResModel e m -> ResolverState (ResModel QUERY e m)
query :: ResolverState (ResModel QUERY e m),
    RootResModel e m -> ResolverState (ResModel MUTATION e m)
mutation :: ResolverState (ResModel MUTATION e m),
    RootResModel e m -> ResolverState (ResModel SUBSCRIPTION e m)
subscription :: ResolverState (ResModel SUBSCRIPTION e m),
    RootResModel e m
-> Maybe (Selection VALID -> ResolverState (Channel e))
channelMap :: Maybe (Selection VALID -> ResolverState (Channel e))
  }

runRootDataResolver ::
  (Monad m, LiftOperation o) =>
  Maybe (Selection VALID -> ResolverState (Channel e)) ->
  ResolverState (ResModel o e m) ->
  ResolverContext ->
  ResponseStream e m (Value VALID)
runRootDataResolver :: Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResModel o e m)
-> ResolverContext
-> ResponseStream e m ValidValue
runRootDataResolver
  Maybe (Selection VALID -> ResolverState (Channel e))
channels
  ResolverState (ResModel o e m)
res
  ctx :: ResolverContext
ctx@ResolverContext {operation :: ResolverContext -> Operation VALID
operation = Operation {SelectionSet VALID
operationSelection :: forall (s :: Stage). Operation s -> SelectionSet s
operationSelection :: SelectionSet VALID
operationSelection}} =
    do
      ResModel o e m
root <- ResolverStateT (ResponseEvent e m) m (ResModel o e m)
-> ResolverContext
-> ResultT (ResponseEvent e m) m (ResModel o e m)
forall e (m :: * -> *) a.
ResolverStateT e m a -> ResolverContext -> ResultT e m a
runResolverStateT (ResolverState (ResModel o e m)
-> ResolverStateT (ResponseEvent e m) m (ResModel o e m)
forall (m :: * -> *) a e.
Applicative m =>
ResolverState a -> ResolverStateT e m a
toResolverStateT ResolverState (ResModel o e m)
res) ResolverContext
ctx
      Maybe (Selection VALID -> ResolverState (Channel e))
-> Resolver o e m ValidValue
-> ResolverContext
-> ResponseStream e m ValidValue
forall (m :: * -> *) event (o :: OperationType).
Monad m =>
Maybe (Selection VALID -> ResolverState (Channel event))
-> Resolver o event m ValidValue
-> ResolverContext
-> ResponseStream event m ValidValue
runResolver Maybe (Selection VALID -> ResolverState (Channel e))
channels (SelectionSet VALID -> ResModel o e m -> Resolver o e m ValidValue
forall (o :: OperationType) e (m :: * -> *).
(LiftOperation o, Monad m) =>
SelectionSet VALID -> ResModel o e m -> Resolver o e m ValidValue
resolveObject SelectionSet VALID
operationSelection ResModel o e m
root) ResolverContext
ctx

runRootResModel :: Monad m => RootResModel e m -> ResolverContext -> ResponseStream e m (Value VALID)
runRootResModel :: RootResModel e m
-> ResolverContext -> ResponseStream e m ValidValue
runRootResModel
  RootResModel
    { ResolverState (ResModel QUERY e m)
query :: ResolverState (ResModel QUERY e m)
query :: forall e (m :: * -> *).
RootResModel e m -> ResolverState (ResModel QUERY e m)
query,
      ResolverState (ResModel MUTATION e m)
mutation :: ResolverState (ResModel MUTATION e m)
mutation :: forall e (m :: * -> *).
RootResModel e m -> ResolverState (ResModel MUTATION e m)
mutation,
      ResolverState (ResModel SUBSCRIPTION e m)
subscription :: ResolverState (ResModel SUBSCRIPTION e m)
subscription :: forall e (m :: * -> *).
RootResModel e m -> ResolverState (ResModel SUBSCRIPTION e m)
subscription,
      Maybe (Selection VALID -> ResolverState (Channel e))
channelMap :: Maybe (Selection VALID -> ResolverState (Channel e))
channelMap :: forall e (m :: * -> *).
RootResModel e m
-> Maybe (Selection VALID -> ResolverState (Channel e))
channelMap
    }
  ctx :: ResolverContext
ctx@ResolverContext {operation :: ResolverContext -> Operation VALID
operation = Operation {OperationType
operationType :: forall (s :: Stage). Operation s -> OperationType
operationType :: OperationType
operationType}} =
    OperationType -> ResponseStream e m ValidValue
selectByOperation OperationType
operationType
    where
      selectByOperation :: OperationType -> ResponseStream e m ValidValue
selectByOperation OperationType
Query =
        Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResModel QUERY e m)
-> ResolverContext
-> ResponseStream e m ValidValue
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResModel o e m)
-> ResolverContext
-> ResponseStream e m ValidValue
runRootDataResolver Maybe (Selection VALID -> ResolverState (Channel e))
channelMap ResolverState (ResModel QUERY e m)
query ResolverContext
ctx
      selectByOperation OperationType
Mutation =
        Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResModel MUTATION e m)
-> ResolverContext
-> ResponseStream e m ValidValue
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResModel o e m)
-> ResolverContext
-> ResponseStream e m ValidValue
runRootDataResolver Maybe (Selection VALID -> ResolverState (Channel e))
channelMap ResolverState (ResModel MUTATION e m)
mutation ResolverContext
ctx
      selectByOperation OperationType
Subscription =
        Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResModel SUBSCRIPTION e m)
-> ResolverContext
-> ResponseStream e m ValidValue
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResModel o e m)
-> ResolverContext
-> ResponseStream e m ValidValue
runRootDataResolver Maybe (Selection VALID -> ResolverState (Channel e))
channelMap ResolverState (ResModel SUBSCRIPTION e m)
subscription ResolverContext
ctx