{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Data.Morpheus.App.Internal.Resolving.RootResolverValue
  ( runRootResolverValue,
    RootResolverValue (..),
  )
where

import Data.Morpheus.App.Internal.Resolving.Event
  ( EventHandler (..),
  )
import Data.Morpheus.App.Internal.Resolving.Resolver
  ( LiftOperation,
    Resolver,
    ResponseStream,
    runResolver,
  )
import Data.Morpheus.App.Internal.Resolving.ResolverState
  ( ResolverContext (..),
    ResolverState,
    runResolverStateT,
    toResolverStateT,
  )
import Data.Morpheus.App.Internal.Resolving.ResolverValue
  ( ResolverValue (..),
    resolveObject,
  )
import Data.Morpheus.Types.Internal.AST
  ( MUTATION,
    Operation (..),
    OperationType (..),
    QUERY,
    SUBSCRIPTION,
    Selection,
    VALID,
    Value,
  )
import Relude hiding
  ( Show,
    empty,
    show,
  )

data RootResolverValue e m = RootResolverValue
  { RootResolverValue e m
-> ResolverState (ResolverValue (Resolver QUERY e m))
query :: ResolverState (ResolverValue (Resolver QUERY e m)),
    RootResolverValue e m
-> ResolverState (ResolverValue (Resolver MUTATION e m))
mutation :: ResolverState (ResolverValue (Resolver MUTATION e m)),
    RootResolverValue e m
-> ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
subscription :: ResolverState (ResolverValue (Resolver SUBSCRIPTION e m)),
    RootResolverValue 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 (ResolverValue (Resolver o e m)) ->
  ResolverContext ->
  ResponseStream e m (Value VALID)
runRootDataResolver :: Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResolverValue (Resolver o e m))
-> ResolverContext
-> ResponseStream e m (Value VALID)
runRootDataResolver
  Maybe (Selection VALID -> ResolverState (Channel e))
channels
  ResolverState (ResolverValue (Resolver 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
      ResolverValue (Resolver o e m)
root <- ResolverStateT
  (ResponseEvent e m) m (ResolverValue (Resolver o e m))
-> ResolverContext
-> ResultT (ResponseEvent e m) m (ResolverValue (Resolver o e m))
forall e (m :: * -> *) a.
ResolverStateT e m a -> ResolverContext -> ResultT e m a
runResolverStateT (ResolverState (ResolverValue (Resolver o e m))
-> ResolverStateT
     (ResponseEvent e m) m (ResolverValue (Resolver o e m))
forall (m :: * -> *) a e.
Applicative m =>
ResolverState a -> ResolverStateT e m a
toResolverStateT ResolverState (ResolverValue (Resolver o e m))
res) ResolverContext
ctx
      Maybe (Selection VALID -> ResolverState (Channel e))
-> Resolver o e m (Value VALID)
-> ResolverContext
-> ResponseStream e m (Value VALID)
forall (m :: * -> *) event (o :: OperationType).
Monad m =>
Maybe (Selection VALID -> ResolverState (Channel event))
-> Resolver o event m (Value VALID)
-> ResolverContext
-> ResponseStream event m (Value VALID)
runResolver Maybe (Selection VALID -> ResolverState (Channel e))
channels (SelectionSet VALID
-> ResolverValue (Resolver o e m) -> Resolver o e m (Value VALID)
forall (m :: * -> *).
(Monad m, MonadReader ResolverContext m,
 Failure ValidationErrors m, Failure InternalError m,
 Failure GQLErrors m, Failure Message m) =>
SelectionSet VALID -> ResolverValue m -> m (Value VALID)
resolveObject SelectionSet VALID
operationSelection ResolverValue (Resolver o e m)
root) ResolverContext
ctx

runRootResolverValue :: Monad m => RootResolverValue e m -> ResolverContext -> ResponseStream e m (Value VALID)
runRootResolverValue :: RootResolverValue e m
-> ResolverContext -> ResponseStream e m (Value VALID)
runRootResolverValue
  RootResolverValue
    { ResolverState (ResolverValue (Resolver QUERY e m))
query :: ResolverState (ResolverValue (Resolver QUERY e m))
query :: forall e (m :: * -> *).
RootResolverValue e m
-> ResolverState (ResolverValue (Resolver QUERY e m))
query,
      ResolverState (ResolverValue (Resolver MUTATION e m))
mutation :: ResolverState (ResolverValue (Resolver MUTATION e m))
mutation :: forall e (m :: * -> *).
RootResolverValue e m
-> ResolverState (ResolverValue (Resolver MUTATION e m))
mutation,
      ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
subscription :: ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
subscription :: forall e (m :: * -> *).
RootResolverValue e m
-> ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
subscription,
      Maybe (Selection VALID -> ResolverState (Channel e))
channelMap :: Maybe (Selection VALID -> ResolverState (Channel e))
channelMap :: forall e (m :: * -> *).
RootResolverValue 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 (Value VALID)
selectByOperation OperationType
operationType
    where
      selectByOperation :: OperationType -> ResponseStream e m (Value VALID)
selectByOperation OperationType
Query =
        Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResolverValue (Resolver QUERY e m))
-> ResolverContext
-> ResponseStream e m (Value VALID)
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResolverValue (Resolver o e m))
-> ResolverContext
-> ResponseStream e m (Value VALID)
runRootDataResolver Maybe (Selection VALID -> ResolverState (Channel e))
channelMap ResolverState (ResolverValue (Resolver QUERY e m))
query ResolverContext
ctx
      selectByOperation OperationType
Mutation =
        Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResolverValue (Resolver MUTATION e m))
-> ResolverContext
-> ResponseStream e m (Value VALID)
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResolverValue (Resolver o e m))
-> ResolverContext
-> ResponseStream e m (Value VALID)
runRootDataResolver Maybe (Selection VALID -> ResolverState (Channel e))
channelMap ResolverState (ResolverValue (Resolver MUTATION e m))
mutation ResolverContext
ctx
      selectByOperation OperationType
Subscription =
        Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
-> ResolverContext
-> ResponseStream e m (Value VALID)
forall (m :: * -> *) (o :: OperationType) e.
(Monad m, LiftOperation o) =>
Maybe (Selection VALID -> ResolverState (Channel e))
-> ResolverState (ResolverValue (Resolver o e m))
-> ResolverContext
-> ResponseStream e m (Value VALID)
runRootDataResolver Maybe (Selection VALID -> ResolverState (Channel e))
channelMap ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
subscription ResolverContext
ctx