forked from OSS/graphql
Replace Alternative with MonadPlus
This commit is contained in:
@ -25,13 +25,17 @@ module Data.GraphQL.Schema
|
||||
, Value(..)
|
||||
) where
|
||||
|
||||
import Control.Applicative (Alternative(empty), (<|>))
|
||||
import Data.Bifunctor (first)
|
||||
import Control.Applicative (Alternative(..))
|
||||
import Control.Monad (MonadPlus)
|
||||
import Control.Monad.Trans.Class (lift)
|
||||
import Control.Monad.Trans.State ( get
|
||||
, put
|
||||
)
|
||||
import Data.Foldable (fold)
|
||||
import Data.GraphQL.Error
|
||||
import Data.List.NonEmpty (NonEmpty)
|
||||
import Data.Maybe (fromMaybe)
|
||||
import Data.Monoid (Alt(Alt,getAlt))
|
||||
import Data.Monoid (Alt(..))
|
||||
import qualified Data.Aeson as Aeson
|
||||
import Data.HashMap.Strict (HashMap)
|
||||
import qualified Data.HashMap.Strict as HashMap
|
||||
@ -41,13 +45,13 @@ import Data.GraphQL.AST.Core
|
||||
|
||||
-- | A GraphQL schema.
|
||||
-- @f@ is usually expected to be an instance of 'Alternative'.
|
||||
type Schema f = NonEmpty (Resolver f)
|
||||
type Schema m = NonEmpty (Resolver m)
|
||||
|
||||
-- | Resolves a 'Field' into an @Aeson.@'Aeson.Object' with error information
|
||||
-- (or 'empty'). @f@ is usually expected to be an instance of 'Alternative'.
|
||||
type Resolver f = Field -> CollectErrsT f Aeson.Object
|
||||
type Resolver m = Field -> CollectErrsT m Aeson.Object
|
||||
|
||||
type Resolvers f = [Resolver f]
|
||||
type Resolvers m = [Resolver m]
|
||||
|
||||
type Fields = [Field]
|
||||
|
||||
@ -57,107 +61,108 @@ type Arguments = [Argument]
|
||||
type Subs = Name -> Maybe Value
|
||||
|
||||
-- | Create a new 'Resolver' with the given 'Name' from the given 'Resolver's.
|
||||
object :: Alternative f => Name -> Resolvers f -> Resolver f
|
||||
object :: MonadPlus m => Name -> Resolvers m -> Resolver m
|
||||
object name resolvers = objectA name $ \case
|
||||
[] -> resolvers
|
||||
_ -> empty
|
||||
|
||||
-- | Like 'object' but also taking 'Argument's.
|
||||
objectA
|
||||
:: Alternative f
|
||||
=> Name -> (Arguments -> Resolvers f) -> Resolver f
|
||||
:: MonadPlus m
|
||||
=> Name -> (Arguments -> Resolvers m) -> Resolver m
|
||||
objectA name f fld@(Field _ _ args flds) = withField name (resolve (f args) flds) fld
|
||||
|
||||
|
||||
-- | Create a named 'Resolver' from a list of 'Resolver's.
|
||||
object' :: (Alternative f, Monad f) => T.Text -> f [Resolver f] -> Resolver f
|
||||
object' :: MonadPlus m => Name -> m (Resolvers m) -> Resolver m
|
||||
object' name resolvs = objectA' name $ \case
|
||||
[] -> resolvs
|
||||
_ -> empty
|
||||
|
||||
-- | Like 'object'' but also taking 'Argument's.
|
||||
objectA'
|
||||
:: (Alternative f, Monad f)
|
||||
=> T.Text -> ([Argument] -> f [Resolver f]) -> Resolver f
|
||||
:: MonadPlus m
|
||||
=> Name -> (Arguments -> m (Resolvers m)) -> Resolver m
|
||||
objectA' name f fld@(Field _ _ args flds) = do
|
||||
resolvs <- f args
|
||||
resolvs <- lift $ f args
|
||||
withField name (resolve resolvs flds) fld
|
||||
|
||||
|
||||
-- | A scalar represents a primitive value, like a string or an integer.
|
||||
scalar :: (Alternative f, Aeson.ToJSON a) => Name -> a -> Resolver f
|
||||
scalar :: (MonadPlus m, Aeson.ToJSON a) => Name -> a -> Resolver m
|
||||
scalar name s = scalarA name $ \case
|
||||
[] -> pure s
|
||||
_ -> empty
|
||||
|
||||
-- | Like 'scalar' but also taking 'Argument's.
|
||||
scalarA
|
||||
:: (Alternative f, Aeson.ToJSON a)
|
||||
=> Name -> (Arguments -> f a) -> Resolver f
|
||||
scalarA name f fld@(Field _ _ args []) = withField name (errWrap $ f args) fld
|
||||
:: (MonadPlus m, Aeson.ToJSON a)
|
||||
=> Name -> (Arguments -> m a) -> Resolver m
|
||||
scalarA name f fld@(Field _ _ args []) = withField name (lift $ f args) fld
|
||||
scalarA _ _ _ = empty
|
||||
|
||||
array :: Alternative f => Name -> [Resolvers f] -> Resolver f
|
||||
array :: MonadPlus m => Name -> [Resolvers m] -> Resolver m
|
||||
array name resolvers = arrayA name $ \case
|
||||
[] -> resolvers
|
||||
_ -> empty
|
||||
|
||||
-- | Like 'array' but also taking 'Argument's.
|
||||
arrayA
|
||||
:: Alternative f
|
||||
=> T.Text -> (Arguments -> [Resolvers f]) -> Resolver f
|
||||
:: MonadPlus m
|
||||
=> Name -> (Arguments -> [Resolvers m]) -> Resolver m
|
||||
arrayA name f fld@(Field _ _ args sels) =
|
||||
withField name (joinErrs $ traverse (`resolve` sels) $ f args) fld
|
||||
withField name (traverse (`resolve` sels) $ f args) fld
|
||||
|
||||
-- | Like 'object'' but taking lists of 'Resolver's instead of a single list.
|
||||
array' :: (Alternative f, Monad f) => T.Text -> f [[Resolver f]] -> Resolver f
|
||||
array' :: MonadPlus m => Name -> m [Resolvers m] -> Resolver m
|
||||
array' name resolvs = arrayA' name $ \case
|
||||
[] -> resolvs
|
||||
_ -> empty
|
||||
|
||||
-- | Like 'array'' but also taking 'Argument's.
|
||||
arrayA'
|
||||
:: (Alternative f, Monad f)
|
||||
=> T.Text -> ([Argument] -> f [[Resolver f]]) -> Resolver f
|
||||
:: MonadPlus m
|
||||
=> Name -> (Arguments -> m [Resolvers m]) -> Resolver m
|
||||
arrayA' name f fld@(Field _ _ args sels) = do
|
||||
resolvs <- f args
|
||||
withField name (joinErrs $ traverse (`resolve` sels) resolvs) fld
|
||||
resolvs <- lift $ f args
|
||||
withField name (traverse (`resolve` sels) resolvs) fld
|
||||
|
||||
-- | Represents one of a finite set of possible values.
|
||||
-- Used in place of a 'scalar' when the possible responses are easily enumerable.
|
||||
enum :: Alternative f => T.Text -> f [T.Text] -> Resolver f
|
||||
enum :: MonadPlus m => Name -> m [T.Text] -> Resolver m
|
||||
enum name enums = enumA name $ \case
|
||||
[] -> enums
|
||||
_ -> empty
|
||||
|
||||
-- | Like 'enum' but also taking 'Argument's.
|
||||
enumA :: Alternative f => T.Text -> ([Argument] -> f [T.Text]) -> Resolver f
|
||||
enumA name f fld@(Field _ _ args []) = withField name (errWrap $ f args) fld
|
||||
enumA :: MonadPlus m => Name -> (Arguments -> m [T.Text]) -> Resolver m
|
||||
enumA name f fld@(Field _ _ args []) = withField name (lift $ f args) fld
|
||||
enumA _ _ _ = empty
|
||||
|
||||
-- | Helper function to facilitate 'Argument' handling.
|
||||
withField
|
||||
:: (Alternative f, Aeson.ToJSON a)
|
||||
=> Name -> CollectErrsT f a -> Field -> CollectErrsT f (HashMap T.Text Aeson.Value)
|
||||
withField :: (MonadPlus m, Aeson.ToJSON a)
|
||||
=> Name -> CollectErrsT m a -> Field -> CollectErrsT m (HashMap T.Text Aeson.Value)
|
||||
withField name v (Field alias name' _ _)
|
||||
| name == name' = fmap getValue v
|
||||
| name == name' = do
|
||||
collection <- HashMap.singleton aliasOrName . Aeson.toJSON <$> runAppendErrs v
|
||||
errors <- get
|
||||
if null errors
|
||||
then return collection
|
||||
-- TODO: Report error when Non-Nullable type for field argument.
|
||||
else put [] >> return (HashMap.singleton aliasOrName Aeson.Null)
|
||||
| otherwise = empty
|
||||
where
|
||||
aliasOrName = fromMaybe name alias
|
||||
getValue (x, []) = (HashMap.singleton aliasOrName $ Aeson.toJSON x, [])
|
||||
-- TODO: Report error when Non-Nullable type for field argument.
|
||||
getValue (_, _) = (HashMap.singleton aliasOrName Aeson.Null, [])
|
||||
|
||||
-- | Takes a list of 'Resolver's and a list of 'Field's and applies each
|
||||
-- 'Resolver' to each 'Field'. Resolves into a value containing the
|
||||
-- resolved 'Field', or a null value and error information.
|
||||
resolve :: Alternative f => Resolvers f -> Fields -> CollectErrsT f Aeson.Value
|
||||
resolve :: MonadPlus m => Resolvers m -> Fields -> CollectErrsT m Aeson.Value
|
||||
resolve resolvers =
|
||||
fmap (first Aeson.toJSON . fold)
|
||||
fmap (Aeson.toJSON . fold)
|
||||
. traverse (\fld -> getAlt (foldMap (Alt . ($ fld)) resolvers) <|> errmsg fld)
|
||||
where
|
||||
errmsg (Field alias name _ _) = addErrMsg msg $ (errWrap . pure) val
|
||||
where
|
||||
val = HashMap.singleton aliasOrName Aeson.Null
|
||||
msg = T.unwords ["field", name, "not resolved."]
|
||||
aliasOrName = fromMaybe name alias
|
||||
errmsg (Field alias name _ _) = do
|
||||
addErrMsg $ T.unwords ["field", name, "not resolved."]
|
||||
return $ HashMap.singleton aliasOrName Aeson.Null
|
||||
where
|
||||
aliasOrName = fromMaybe name alias
|
||||
|
||||
Reference in New Issue
Block a user