{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Data.Morpheus.Server.Deriving.Encode
  ( deriveModel,
    EncodeConstraints,
  )
where

import qualified Data.Map as M
import Data.Morpheus.App.Internal.Resolving
  ( LiftOperation,
    Resolver,
    ResolverEntry,
    ResolverState,
    ResolverValue (..),
    RootResolverValue (..),
    failure,
    getArguments,
    liftResolverState,
    mkObject,
    mkUnion,
  )
import Data.Morpheus.Kind
  ( CUSTOM,
    DerivingKind,
    INTERFACE,
    SCALAR,
    TYPE,
    WRAPPER,
  )
import Data.Morpheus.Server.Deriving.Channels
  ( ChannelsConstraint,
    channelResolver,
  )
import Data.Morpheus.Server.Deriving.Decode
  ( DecodeConstraint,
    decodeArguments,
  )
import Data.Morpheus.Server.Deriving.Utils
  ( ConsRep (..),
    DataType (..),
    FieldRep (..),
    TypeConstraint (..),
    TypeRep (..),
    isUnionRef,
    toValue,
  )
import Data.Morpheus.Server.Types.GQLType (GQLType (..))
import Data.Morpheus.Server.Types.Types
  ( Pair (..),
  )
import Data.Morpheus.Types
  ( RootResolver (..),
  )
import Data.Morpheus.Types.GQLScalar
  ( EncodeScalar (..),
  )
import Data.Morpheus.Types.GQLWrapper (EncodeWrapper (..))
import Data.Morpheus.Types.Internal.AST
  ( IN,
    InternalError,
    MUTATION,
    OperationType,
    QUERY,
    SUBSCRIPTION,
    TypeRef (..),
  )
import GHC.Generics
  ( Generic (..),
  )
import Relude

newtype ContextValue (kind :: DerivingKind) a = ContextValue
  { ContextValue kind a -> a
unContextValue :: a
  }

class Encode (m :: * -> *) resolver where
  encode :: resolver -> m (ResolverValue m)

instance (EncodeKind (KIND a) m a) => Encode m a where
  encode :: a -> m (ResolverValue m)
encode a
resolver = ContextValue (KIND a) a -> m (ResolverValue m)
forall (kind :: DerivingKind) (m :: * -> *) a.
EncodeKind kind m a =>
ContextValue kind a -> m (ResolverValue m)
encodeKind (a -> ContextValue (KIND a) a
forall (kind :: DerivingKind) a. a -> ContextValue kind a
ContextValue a
resolver :: ContextValue (KIND a) a)

-- ENCODE GQL KIND
class EncodeKind (kind :: DerivingKind) (m :: * -> *) (a :: *) where
  encodeKind :: ContextValue kind a -> m (ResolverValue m)

instance
  ( EncodeWrapper f,
    Encode m a,
    Monad m
  ) =>
  EncodeKind WRAPPER m (f a)
  where
  encodeKind :: ContextValue WRAPPER (f a) -> m (ResolverValue m)
encodeKind = (a -> m (ResolverValue m)) -> f a -> m (ResolverValue m)
forall (wrapper :: * -> *) (m :: * -> *) a.
(EncodeWrapper wrapper, Monad m) =>
(a -> m (ResolverValue m)) -> wrapper a -> m (ResolverValue m)
encodeWrapper a -> m (ResolverValue m)
forall (m :: * -> *) resolver.
Encode m resolver =>
resolver -> m (ResolverValue m)
encode (f a -> m (ResolverValue m))
-> (ContextValue WRAPPER (f a) -> f a)
-> ContextValue WRAPPER (f a)
-> m (ResolverValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextValue WRAPPER (f a) -> f a
forall (kind :: DerivingKind) a. ContextValue kind a -> a
unContextValue

instance
  ( EncodeScalar a,
    Monad m
  ) =>
  EncodeKind SCALAR m a
  where
  encodeKind :: ContextValue SCALAR a -> m (ResolverValue m)
encodeKind = ResolverValue m -> m (ResolverValue m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ResolverValue m -> m (ResolverValue m))
-> (ContextValue SCALAR a -> ResolverValue m)
-> ContextValue SCALAR a
-> m (ResolverValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScalarValue -> ResolverValue m
forall (m :: * -> *). ScalarValue -> ResolverValue m
ResScalar (ScalarValue -> ResolverValue m)
-> (ContextValue SCALAR a -> ScalarValue)
-> ContextValue SCALAR a
-> ResolverValue m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ScalarValue
forall a. EncodeScalar a => a -> ScalarValue
encodeScalar (a -> ScalarValue)
-> (ContextValue SCALAR a -> a)
-> ContextValue SCALAR a
-> ScalarValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextValue SCALAR a -> a
forall (kind :: DerivingKind) a. ContextValue kind a -> a
unContextValue

instance
  ( EncodeConstraint m a,
    Monad m
  ) =>
  EncodeKind TYPE m a
  where
  encodeKind :: ContextValue TYPE a -> m (ResolverValue m)
encodeKind = ResolverValue m -> m (ResolverValue m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ResolverValue m -> m (ResolverValue m))
-> (ContextValue TYPE a -> ResolverValue m)
-> ContextValue TYPE a
-> m (ResolverValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ResolverValue m
forall (m :: * -> *) a.
(EncodeConstraint m a, Monad m) =>
a -> ResolverValue m
exploreResolvers (a -> ResolverValue m)
-> (ContextValue TYPE a -> a)
-> ContextValue TYPE a
-> ResolverValue m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextValue TYPE a -> a
forall (kind :: DerivingKind) a. ContextValue kind a -> a
unContextValue

instance
  ( EncodeConstraint m a,
    Monad m
  ) =>
  EncodeKind INTERFACE m a
  where
  encodeKind :: ContextValue INTERFACE a -> m (ResolverValue m)
encodeKind = ResolverValue m -> m (ResolverValue m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ResolverValue m -> m (ResolverValue m))
-> (ContextValue INTERFACE a -> ResolverValue m)
-> ContextValue INTERFACE a
-> m (ResolverValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ResolverValue m
forall (m :: * -> *) a.
(EncodeConstraint m a, Monad m) =>
a -> ResolverValue m
exploreResolvers (a -> ResolverValue m)
-> (ContextValue INTERFACE a -> a)
-> ContextValue INTERFACE a
-> ResolverValue m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextValue INTERFACE a -> a
forall (kind :: DerivingKind) a. ContextValue kind a -> a
unContextValue

--  Tuple  (a,b)
instance
  Encode m (Pair k v) =>
  EncodeKind CUSTOM m (k, v)
  where
  encodeKind :: ContextValue CUSTOM (k, v) -> m (ResolverValue m)
encodeKind = Pair k v -> m (ResolverValue m)
forall (m :: * -> *) resolver.
Encode m resolver =>
resolver -> m (ResolverValue m)
encode (Pair k v -> m (ResolverValue m))
-> (ContextValue CUSTOM (k, v) -> Pair k v)
-> ContextValue CUSTOM (k, v)
-> m (ResolverValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> v -> Pair k v) -> (k, v) -> Pair k v
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> v -> Pair k v
forall k v. k -> v -> Pair k v
Pair ((k, v) -> Pair k v)
-> (ContextValue CUSTOM (k, v) -> (k, v))
-> ContextValue CUSTOM (k, v)
-> Pair k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextValue CUSTOM (k, v) -> (k, v)
forall (kind :: DerivingKind) a. ContextValue kind a -> a
unContextValue

--  Map
instance (Monad m, Encode m [Pair k v]) => EncodeKind CUSTOM m (Map k v) where
  encodeKind :: ContextValue CUSTOM (Map k v) -> m (ResolverValue m)
encodeKind = [Pair k v] -> m (ResolverValue m)
forall (m :: * -> *) resolver.
Encode m resolver =>
resolver -> m (ResolverValue m)
encode ([Pair k v] -> m (ResolverValue m))
-> (ContextValue CUSTOM (Map k v) -> [Pair k v])
-> ContextValue CUSTOM (Map k v)
-> m (ResolverValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((k, v) -> Pair k v) -> [(k, v)] -> [Pair k v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((k -> v -> Pair k v) -> (k, v) -> Pair k v
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> v -> Pair k v
forall k v. k -> v -> Pair k v
Pair) ([(k, v)] -> [Pair k v])
-> (ContextValue CUSTOM (Map k v) -> [(k, v)])
-> ContextValue CUSTOM (Map k v)
-> [Pair k v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
M.toList (Map k v -> [(k, v)])
-> (ContextValue CUSTOM (Map k v) -> Map k v)
-> ContextValue CUSTOM (Map k v)
-> [(k, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContextValue CUSTOM (Map k v) -> Map k v
forall (kind :: DerivingKind) a. ContextValue kind a -> a
unContextValue

--  GQL a -> Resolver b, MUTATION, SUBSCRIPTION, QUERY
instance
  ( DecodeConstraint a,
    Generic a,
    Monad m,
    Encode (Resolver o e m) b,
    LiftOperation o
  ) =>
  EncodeKind CUSTOM (Resolver o e m) (a -> b)
  where
  encodeKind :: ContextValue CUSTOM (a -> b)
-> Resolver o e m (ResolverValue (Resolver o e m))
encodeKind (ContextValue a -> b
f) =
    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
>>= ResolverState a -> Resolver o e m a
forall (o :: OperationType) (m :: * -> *) a e.
(LiftOperation o, Monad m) =>
ResolverState a -> Resolver o e m a
liftResolverState (ResolverState a -> Resolver o e m a)
-> (Arguments VALID -> ResolverState a)
-> Arguments VALID
-> Resolver o e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Arguments VALID -> ResolverState a
forall a. DecodeConstraint a => Arguments VALID -> ResolverState a
decodeArguments
      Resolver o e m a
-> (a -> Resolver o e m (ResolverValue (Resolver o e m)))
-> Resolver o e m (ResolverValue (Resolver o e m))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> Resolver o e m (ResolverValue (Resolver o e m))
forall (m :: * -> *) resolver.
Encode m resolver =>
resolver -> m (ResolverValue m)
encode (b -> Resolver o e m (ResolverValue (Resolver o e m)))
-> (a -> b) -> a -> Resolver o e m (ResolverValue (Resolver o e m))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f

--  GQL a -> Resolver b, MUTATION, SUBSCRIPTION, QUERY
instance
  (Monad m, Encode (Resolver o e m) b, LiftOperation o) =>
  EncodeKind CUSTOM (Resolver o e m) (Resolver o e m b)
  where
  encodeKind :: ContextValue CUSTOM (Resolver o e m b)
-> Resolver o e m (ResolverValue (Resolver o e m))
encodeKind (ContextValue Resolver o e m b
value) = Resolver o e m b
value Resolver o e m b
-> (b -> Resolver o e m (ResolverValue (Resolver o e m)))
-> Resolver o e m (ResolverValue (Resolver o e m))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> Resolver o e m (ResolverValue (Resolver o e m))
forall (m :: * -> *) resolver.
Encode m resolver =>
resolver -> m (ResolverValue m)
encode

convertNode ::
  Monad m =>
  DataType (m (ResolverValue m)) ->
  ResolverValue m
convertNode :: DataType (m (ResolverValue m)) -> ResolverValue m
convertNode
  DataType
    { TypeName
tyName :: forall v. DataType v -> TypeName
tyName :: TypeName
tyName,
      Bool
tyIsUnion :: forall v. DataType v -> Bool
tyIsUnion :: Bool
tyIsUnion,
      tyCons :: forall v. DataType v -> ConsRep v
tyCons = cons :: ConsRep (m (ResolverValue m))
cons@ConsRep {[FieldRep (m (ResolverValue m))]
consFields :: forall v. ConsRep v -> [FieldRep v]
consFields :: [FieldRep (m (ResolverValue m))]
consFields, TypeName
consName :: forall v. ConsRep v -> TypeName
consName :: TypeName
consName}
    }
    | Bool
tyIsUnion = [FieldRep (m (ResolverValue m))] -> ResolverValue m
encodeUnion [FieldRep (m (ResolverValue m))]
consFields
    | Bool
otherwise = TypeName -> [ResolverEntry m] -> ResolverValue m
forall (m :: * -> *).
TypeName -> [ResolverEntry m] -> ResolverValue m
mkObject TypeName
tyName ((FieldRep (m (ResolverValue m)) -> ResolverEntry m)
-> [FieldRep (m (ResolverValue m))] -> [ResolverEntry m]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FieldRep (m (ResolverValue m)) -> ResolverEntry m
forall (m :: * -> *).
FieldRep (m (ResolverValue m)) -> ResolverEntry m
toFieldRes [FieldRep (m (ResolverValue m))]
consFields)
    where
      -- ENUM
      encodeUnion :: [FieldRep (m (ResolverValue m))] -> ResolverValue m
encodeUnion [] = TypeName -> ResolverValue m
forall (m :: * -> *). TypeName -> ResolverValue m
ResEnum TypeName
consName
      -- Type References --------------------------------------------------------------
      encodeUnion [FieldRep {fieldTypeRef :: forall a. FieldRep a -> TypeRef
fieldTypeRef = TypeRef {TypeName
typeConName :: TypeRef -> TypeName
typeConName :: TypeName
typeConName}, m (ResolverValue m)
fieldValue :: forall a. FieldRep a -> a
fieldValue :: m (ResolverValue m)
fieldValue}]
        | TypeName -> ConsRep (m (ResolverValue m)) -> Bool
forall k. TypeName -> ConsRep k -> Bool
isUnionRef TypeName
tyName ConsRep (m (ResolverValue m))
cons = TypeName -> m (ResolverValue m) -> ResolverValue m
forall (m :: * -> *).
TypeName -> m (ResolverValue m) -> ResolverValue m
ResUnion TypeName
typeConName m (ResolverValue m)
fieldValue
      -- Inline Union Types ----------------------------------------------------------------------------
      encodeUnion [FieldRep (m (ResolverValue m))]
fields = TypeName -> [ResolverEntry m] -> ResolverValue m
forall (m :: * -> *).
Monad m =>
TypeName -> [ResolverEntry m] -> ResolverValue m
mkUnion TypeName
consName ((FieldRep (m (ResolverValue m)) -> ResolverEntry m)
-> [FieldRep (m (ResolverValue m))] -> [ResolverEntry m]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FieldRep (m (ResolverValue m)) -> ResolverEntry m
forall (m :: * -> *).
FieldRep (m (ResolverValue m)) -> ResolverEntry m
toFieldRes [FieldRep (m (ResolverValue m))]
fields)

-- Types & Constrains -------------------------------------------------------
exploreResolvers ::
  forall m a.
  ( EncodeConstraint m a,
    Monad m
  ) =>
  a ->
  ResolverValue m
exploreResolvers :: a -> ResolverValue m
exploreResolvers =
  DataType (m (ResolverValue m)) -> ResolverValue m
forall (m :: * -> *).
Monad m =>
DataType (m (ResolverValue m)) -> ResolverValue m
convertNode
    (DataType (m (ResolverValue m)) -> ResolverValue m)
-> (a -> DataType (m (ResolverValue m))) -> a -> ResolverValue m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeConstraint (Encode m) (m (ResolverValue m)) Identity
-> Proxy IN -> a -> DataType (m (ResolverValue m))
forall (proxy :: TypeCategory -> *) (kind :: TypeCategory)
       (constraint :: * -> Constraint) value a.
(GQLType a, CategoryValue kind, Generic a,
 TypeRep constraint value (Rep a)) =>
TypeConstraint constraint value Identity
-> proxy kind -> a -> DataType value
toValue
      ( (forall a. Encode m a => Identity a -> m (ResolverValue m))
-> TypeConstraint (Encode m) (m (ResolverValue m)) Identity
forall (c :: * -> Constraint) v (f :: * -> *).
(forall a. c a => f a -> v) -> TypeConstraint c v f
TypeConstraint (a -> m (ResolverValue m)
forall (m :: * -> *) resolver.
Encode m resolver =>
resolver -> m (ResolverValue m)
encode (a -> m (ResolverValue m))
-> (Identity a -> a) -> Identity a -> m (ResolverValue m)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity a -> a
forall a. Identity a -> a
runIdentity) ::
          TypeConstraint (Encode m) (m (ResolverValue m)) Identity
      )
      (Proxy IN
forall k (t :: k). Proxy t
Proxy @IN)

----- HELPERS ----------------------------
objectResolvers ::
  ( EncodeConstraint m a,
    Monad m
  ) =>
  a ->
  ResolverState (ResolverValue m)
objectResolvers :: a -> ResolverState (ResolverValue m)
objectResolvers a
value = ResolverValue m -> ResolverState (ResolverValue m)
forall (f :: * -> *) (m :: * -> *).
Failure InternalError f =>
ResolverValue m -> f (ResolverValue m)
constraintObject (a -> ResolverValue m
forall (m :: * -> *) a.
(EncodeConstraint m a, Monad m) =>
a -> ResolverValue m
exploreResolvers a
value)
  where
    constraintObject :: ResolverValue m -> f (ResolverValue m)
constraintObject obj :: ResolverValue m
obj@ResObject {} =
      ResolverValue m -> f (ResolverValue m)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ResolverValue m
obj
    constraintObject ResolverValue m
_ =
      InternalError -> f (ResolverValue m)
forall error (f :: * -> *) v. Failure error f => error -> f v
failure (InternalError
"resolver must be an object" :: InternalError)

type EncodeConstraint (m :: * -> *) a =
  ( GQLType a,
    Generic a,
    TypeRep (Encode m) (m (ResolverValue m)) (Rep a)
  )

type EncodeObjectConstraint (o :: OperationType) e (m :: * -> *) a =
  EncodeConstraint (Resolver o e m) (a (Resolver o e m))

type EncodeConstraints e m query mut sub =
  ( ChannelsConstraint e m sub,
    EncodeObjectConstraint QUERY e m query,
    EncodeObjectConstraint MUTATION e m mut,
    EncodeObjectConstraint SUBSCRIPTION e m sub
  )

toFieldRes :: FieldRep (m (ResolverValue m)) -> ResolverEntry m
toFieldRes :: FieldRep (m (ResolverValue m)) -> ResolverEntry m
toFieldRes FieldRep {FieldName
fieldSelector :: forall a. FieldRep a -> FieldName
fieldSelector :: FieldName
fieldSelector, m (ResolverValue m)
fieldValue :: m (ResolverValue m)
fieldValue :: forall a. FieldRep a -> a
fieldValue} = (FieldName
fieldSelector, m (ResolverValue m)
fieldValue)

deriveModel ::
  forall e m query mut sub.
  (Monad m, EncodeConstraints e m query mut sub) =>
  RootResolver m e query mut sub ->
  RootResolverValue e m
deriveModel :: RootResolver m e query mut sub -> RootResolverValue e m
deriveModel
  RootResolver
    { query (Resolver QUERY e m)
queryResolver :: forall (m :: * -> *) event (query :: (* -> *) -> *)
       (mut :: (* -> *) -> *) (sub :: (* -> *) -> *).
RootResolver m event query mut sub
-> query (Resolver QUERY event m)
queryResolver :: query (Resolver QUERY e m)
queryResolver,
      mut (Resolver MUTATION e m)
mutationResolver :: forall (m :: * -> *) event (query :: (* -> *) -> *)
       (mut :: (* -> *) -> *) (sub :: (* -> *) -> *).
RootResolver m event query mut sub
-> mut (Resolver MUTATION event m)
mutationResolver :: mut (Resolver MUTATION e m)
mutationResolver,
      sub (Resolver SUBSCRIPTION e m)
subscriptionResolver :: forall (m :: * -> *) event (query :: (* -> *) -> *)
       (mut :: (* -> *) -> *) (sub :: (* -> *) -> *).
RootResolver m event query mut sub
-> sub (Resolver SUBSCRIPTION event m)
subscriptionResolver :: sub (Resolver SUBSCRIPTION e m)
subscriptionResolver
    } =
    RootResolverValue :: forall e (m :: * -> *).
ResolverState (ResolverValue (Resolver QUERY e m))
-> ResolverState (ResolverValue (Resolver MUTATION e m))
-> ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
-> Maybe (Selection VALID -> ResolverState (Channel e))
-> RootResolverValue e m
RootResolverValue
      { query :: ResolverState (ResolverValue (Resolver QUERY e m))
query = query (Resolver QUERY e m)
-> ResolverState (ResolverValue (Resolver QUERY e m))
forall (m :: * -> *) a.
(EncodeConstraint m a, Monad m) =>
a -> ResolverState (ResolverValue m)
objectResolvers query (Resolver QUERY e m)
queryResolver,
        mutation :: ResolverState (ResolverValue (Resolver MUTATION e m))
mutation = mut (Resolver MUTATION e m)
-> ResolverState (ResolverValue (Resolver MUTATION e m))
forall (m :: * -> *) a.
(EncodeConstraint m a, Monad m) =>
a -> ResolverState (ResolverValue m)
objectResolvers mut (Resolver MUTATION e m)
mutationResolver,
        subscription :: ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
subscription = sub (Resolver SUBSCRIPTION e m)
-> ResolverState (ResolverValue (Resolver SUBSCRIPTION e m))
forall (m :: * -> *) a.
(EncodeConstraint m a, Monad m) =>
a -> ResolverState (ResolverValue m)
objectResolvers sub (Resolver SUBSCRIPTION e m)
subscriptionResolver,
        Maybe (Selection VALID -> ResolverState (Channel e))
channelMap :: Maybe (Selection VALID -> ResolverState (Channel e))
channelMap :: Maybe (Selection VALID -> ResolverState (Channel e))
channelMap
      }
    where
      channelMap :: Maybe (Selection VALID -> ResolverState (Channel e))
channelMap
        | Proxy (sub (Resolver SUBSCRIPTION e m)) -> Bool
forall a (f :: * -> *). GQLType a => f a -> Bool
__isEmptyType (Proxy (sub (Resolver SUBSCRIPTION e m))
forall k (t :: k). Proxy t
Proxy :: Proxy (sub (Resolver SUBSCRIPTION e m))) = Maybe (Selection VALID -> ResolverState (Channel e))
forall a. Maybe a
Nothing
        | Bool
otherwise = (Selection VALID -> ResolverState (Channel e))
-> Maybe (Selection VALID -> ResolverState (Channel e))
forall a. a -> Maybe a
Just (sub (Resolver SUBSCRIPTION e m)
-> Selection VALID -> ResolverState (Channel e)
forall e (m :: * -> *) (subs :: (* -> *) -> *).
ChannelsConstraint e m subs =>
subs (Resolver SUBSCRIPTION e m)
-> Selection VALID -> ResolverState (Channel e)
channelResolver sub (Resolver SUBSCRIPTION e m)
subscriptionResolver)