{-# LANGUAGE GADTs #-}
{-# LANGUAGE RankNTypes #-}
module Data.Morpheus.App.NamedResolvers
( ref,
object,
variant,
list,
refs,
enum,
queryResolvers,
getArgument,
NamedResolverFunction,
RootResolverValue,
ResultBuilder,
nullRes,
)
where
import qualified Data.HashMap.Lazy as HM
import Data.Morpheus.App.Internal.Resolving.MonadResolver
( MonadResolver,
getArgument,
)
import Data.Morpheus.App.Internal.Resolving.Resolver (Resolver)
import Data.Morpheus.App.Internal.Resolving.RootResolverValue (RootResolverValue (..))
import Data.Morpheus.App.Internal.Resolving.Types
( NamedResolver (..),
NamedResolverRef (..),
NamedResolverResult (..),
ObjectTypeResolver (..),
ResolverMap,
ResolverValue (..),
mkEnum,
mkList,
)
import Data.Morpheus.Types.Internal.AST
( FieldName,
QUERY,
TypeName,
ValidValue,
)
enum :: TypeName -> ResolverValue m
enum :: forall (m :: * -> *). TypeName -> ResolverValue m
enum = forall (m :: * -> *). TypeName -> ResolverValue m
mkEnum
list :: [ResolverValue m] -> ResolverValue m
list :: forall (m :: * -> *). [ResolverValue m] -> ResolverValue m
list = forall (m :: * -> *). [ResolverValue m] -> ResolverValue m
mkList
ref :: Applicative m => TypeName -> ValidValue -> ResolverValue m
ref :: forall (m :: * -> *).
Applicative m =>
TypeName -> ValidValue -> ResolverValue m
ref TypeName
typeName = forall (m :: * -> *). m NamedResolverRef -> ResolverValue m
ResRef forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeName -> NamedResolverArg -> NamedResolverRef
NamedResolverRef TypeName
typeName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure
refs :: Applicative m => TypeName -> [ValidValue] -> ResolverValue m
refs :: forall (m :: * -> *).
Applicative m =>
TypeName -> NamedResolverArg -> ResolverValue m
refs TypeName
typeName = forall (m :: * -> *). [ResolverValue m] -> ResolverValue m
mkList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (forall (m :: * -> *).
Applicative m =>
TypeName -> ValidValue -> ResolverValue m
ref TypeName
typeName)
type NamedResolverFunction o e m = NamedFunction (Resolver o e m)
type NamedFunction m = [ValidValue] -> m [ResultBuilder m]
object :: (MonadResolver m) => [(FieldName, m (ResolverValue m))] -> m (ResultBuilder m)
object :: forall (m :: * -> *).
MonadResolver m =>
[(FieldName, m (ResolverValue m))] -> m (ResultBuilder m)
object = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *).
[(FieldName, m (ResolverValue m))] -> ResultBuilder m
Object
variant :: (MonadResolver m) => TypeName -> ValidValue -> m (ResultBuilder m)
variant :: forall (m :: * -> *).
MonadResolver m =>
TypeName -> ValidValue -> m (ResultBuilder m)
variant TypeName
tName = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). TypeName -> ValidValue -> ResultBuilder m
Union TypeName
tName
nullRes :: (MonadResolver m) => m (ResultBuilder m)
nullRes :: forall (m :: * -> *). MonadResolver m => m (ResultBuilder m)
nullRes = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (m :: * -> *). ResultBuilder m
Null
queryResolvers :: Monad m => [(TypeName, NamedFunction (Resolver QUERY e m))] -> RootResolverValue e m
queryResolvers :: forall (m :: * -> *) e.
Monad m =>
[(TypeName, NamedFunction (Resolver QUERY e m))]
-> RootResolverValue e m
queryResolvers = forall e (m :: * -> *).
ResolverMap (Resolver QUERY e m) -> RootResolverValue e m
NamedResolversValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *).
MonadResolver m =>
[(TypeName, NamedFunction m)] -> ResolverMap m
mkResolverMap
data ResultBuilder m
= Object [(FieldName, m (ResolverValue m))]
| Union TypeName ValidValue
| Null
mkResolverMap :: MonadResolver m => [(TypeName, NamedFunction m)] -> ResolverMap m
mkResolverMap :: forall (m :: * -> *).
MonadResolver m =>
[(TypeName, NamedFunction m)] -> ResolverMap m
mkResolverMap = forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall (m :: * -> *).
MonadResolver m =>
(TypeName, NamedFunction m) -> (TypeName, NamedResolver m)
packRes
where
packRes :: MonadResolver m => (TypeName, NamedFunction m) -> (TypeName, NamedResolver m)
packRes :: forall (m :: * -> *).
MonadResolver m =>
(TypeName, NamedFunction m) -> (TypeName, NamedResolver m)
packRes (TypeName
typeName, NamedFunction m
f) = (TypeName
typeName, forall (m :: * -> *).
TypeName -> NamedResolverFun m -> NamedResolver m
NamedResolver TypeName
typeName (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. (a -> b) -> [a] -> [b]
map forall {m :: * -> *}. ResultBuilder m -> NamedResolverResult m
mapValue) forall b c a. (b -> c) -> (a -> b) -> a -> c
. NamedFunction m
f))
where
mapValue :: ResultBuilder m -> NamedResolverResult m
mapValue (Object [(FieldName, m (ResolverValue m))]
x) = forall (m :: * -> *). ObjectTypeResolver m -> NamedResolverResult m
NamedObjectResolver (forall (m :: * -> *).
HashMap FieldName (m (ResolverValue m)) -> ObjectTypeResolver m
ObjectTypeResolver forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(FieldName, m (ResolverValue m))]
x)
mapValue (Union TypeName
name ValidValue
x) = forall (m :: * -> *). NamedResolverRef -> NamedResolverResult m
NamedUnionResolver (TypeName -> NamedResolverArg -> NamedResolverRef
NamedResolverRef TypeName
name [ValidValue
x])
mapValue ResultBuilder m
Null = forall (m :: * -> *). NamedResolverResult m
NamedNullResolver